anchor.diff:  
   -type ast()   :: erl_parse:abstract_form().
   
  --type state() :: #{ asts            => [ast()]
  -                  , lexical_renames => clj_scope:scope()
  +-type state() :: #{ asts                => [ast()]
  +                  , lexical_renames     => clj_scope:scope()
  +                  , force_remote_invoke => boolean()
                     }.
   
   -spec emit(clj_env:env()) -> clj_env:env().
  
positive.code:       VarMeta = clj_core:meta(Var),
        Module  = 'clojerl.Var':module(Var),
  
        Ast = case clj_core:get(VarMeta, 'fn?', false) of
                true ->
                  Function = 'clojerl.Var':function(Var),
                  Args1    = 'clojerl.Var':process_args(Var, Args, fun list_ast/1),
                  CurrentNs = clj_namespace:current(),
                  NsName    = clj_core:name(clj_namespace:name(CurrentNs)),
                  VarNsName = clj_core:namespace(Var),
  
                  %% When the var's symbol is not namespace qualified and the var's
                  %% namespace is the current namespace, emit a local function
                  %% call, otherwise emit a remote call.
                  case clj_core:namespace(Symbol) of
                    undefined when NsName =:= VarNsName ->
                      application_fa(Function, Args1, Anno);
                    _ ->
                      application_mfa(Module, Function, Args1, Anno)
                  end;
                false ->
                  ValFunction = 'clojerl.Var':val_function(Var),
                  FunAst      = application_mfa(Module, ValFunction, [], Anno),
                  ArgsAst     = list_ast(Args),
                  application_mfa(clj_core, invoke, [FunAst, ArgsAst], Anno)
              end,
  
        push_ast(Ast, State1);
      #{op := erl_fun} ->
  
negative.code:         StateAcc2
      end,
  
    State1 = lists:foldl( EmitProtocolFun
                        , State#{force_remote_invoke => true}
                        , maps:keys(Impls)
                        ),
  
    Ast = {atom, 0, undefined},
    push_ast(Ast, State1#{force_remote_invoke => ForceRemote});
  %%------------------------------------------------------------------------------
  %% fn, invoke, erl_fun
  %%------------------------------------------------------------------------------
  