anchor.diff:  % recompile the file, if needed
   get_template(Name, Options) ->
     case ets:lookup(zml_templates, Name) of
  -    [{_Name, none, 0,  Templ}] -> Templ;
  -    [{_Name, Path, Ts, Templ}] ->
  +    [{_Name, none, 0,  Templ, IsStatic}] -> {ok, Templ, IsStatic};
  +    [{_Name, Path, Ts, Templ, IsStatic}] ->
         {ok, FileInfo} = file:read_file_info(Path),
         NewTs = FileInfo#file_info.mtime,
         case NewTs > Ts of
           true ->
  -          NewTempl = compile_file(Path, Options),
  -          ets:insert(zml_templates, {Name, Path, NewTs, NewTempl}),
  -          {ok, NewTempl};
  +          {NewTempl, IsNewStatic} = compile_file(Path, Options),
  +          ets:insert(zml_templates, {Name, Path, NewTs, NewTempl, IsNewStatic}),
  +          {ok, NewTempl, IsNewStatic};
           false ->
  -          {ok, Templ}
  +          {ok, Templ, IsStatic}
         end;
       [] ->
         case string:right(Name, 5) of
  
positive.code: compile_static_files() -> compile_static_files([]).
  
  compile_static_files([]) ->
    Template = compile_stream(standard_io, []),
    io:format("~s~n", [zml_render:render(Template, fake)]);
  
  compile_static_files(FLS) ->
    lists:foreach(fun(FName) ->
      FNameOut = output_file_name(FName),
      io:format("~s --> ~s~n", [FName, FNameOut]),
      Template = compile_file(FName, []),
      ok = file:write_file(FNameOut, zml_render:render(Template, fake))
    end, FLS).
  
  % TODO: take output path from the options.
  
negative.code: run_specialized_handlers_inner([_H|T], Options, FullAST) ->
    run_specialized_handlers_inner(T, Options, FullAST).
  
  translate_ast_item([], Acc, IsStatic) -> {lists:reverse(Acc), IsStatic};
  translate_ast_item([newline | T], Acc, IsStatic) ->
    translate_ast_item(T, ["\n" | Acc], IsStatic);
  translate_ast_item([{var,_} = Var | T], Acc, _IsStatic) ->
    translate_ast_item(T, [Var | Acc], false);
  % In case a special one still remains, remove ID and pretend it's normal
  translate_ast_item([{{Name, _ID}, Type, Attributes, Children} | T], Acc, IsStatic) ->
    translate_ast_item([{Name, Type, Attributes, Children} | T], Acc, IsStatic);
  translate_ast_item([{with, Attr, Children} | T], Acc, _IsStatic) ->
    {ChildAST, _IsStatic} = translate_ast_item(Children, [], true),
     % *with Attr truncated in the special handler:
    translate_ast_item(T, [{with, Attr, ChildAST} | Acc], false);
  translate_ast_item([{Name, _Type, Attributes, []} | T], Acc, IsStatic) ->
    {AttrTempl, AttrStatic} = translate_attributes(Attributes),
    translate_ast_item(T,
      [["<", Name, AttrTempl, "/>"] | Acc], IsStatic and AttrStatic);
  translate_ast_item([{Name, _Type, Attributes, Children} | T], Acc, IsStatic) ->
    {AttrTempl,  AttrStatic } = translate_attributes(Attributes),
    {ChildTempl, ChildStatic} = translate_ast_item(Children, [], true),
    ToAppend = ["<", Name, AttrTempl, ">", ChildTempl, "</", Name, ">"],
    translate_ast_item(T, [ToAppend | Acc], IsStatic and AttrStatic and ChildStatic);
  translate_ast_item([Str | T], Acc, IsStatic) ->
    translate_ast_item(T, [Str | Acc], IsStatic).
  
  translate_attributes(Attrs) ->
    {[[" ", Name, "=\"", zml_util:intersperse(Values, " "), "\""]
      || {Name, Values} <- Attrs ], true}.
  
  