anchor.diff:                , init    => InitExpr
                 , form    => Pattern
                 , local   => OpAtom
  +              , tag     => maps:get(tag, PatternExpr, ?NO_TAG)
                 },
   
     LocalExprs = clj_env:get(pattern_locals, [], Env2),
  
positive.code: %%------------------------------------------------------------------------------
  
  -spec analyze_symbol('clojerl.Symbol':type(), clj_env:env()) -> clj_env:env().
  analyze_symbol(Symbol, Env) ->
    InPattern = clj_env:get(in_pattern, false, Env),
    case InPattern orelse resolve(Symbol, Env) of
      true ->
        clj_utils:error_when( not is_valid_bind_symbol(Symbol)
                            , [<<"Not a valid binding symbol, had: ">>, Symbol]
                            , clj_env:location(Env)
                            ),
        {TagExpr, Env1} = maybe_type_tag(Symbol, Env),
  
        Ast = #{ op         => local
               , env        => Env
               , name       => Symbol
               , tag        => TagExpr
               , shadow     => clj_env:get_local(Symbol, Env)
               , underscore => clj_rt:name(Symbol) =:= <<"_">>
               , id         => erlang:unique_integer()
               },
        Env2 = add_pattern_local(Ast, Env1),
        clj_env:push_expr(Ast, Env2);
      {?NIL, _} ->
        clj_utils:error([ <<"Unable to resolve symbol '">>, Symbol
                        , <<"' in this context">>
                        ]
                       , clj_env:location(Env)
                       );
      {{local, Local}, Env1} ->
        clj_env:push_expr(Local#{env => Env}, Env1);
      {{erl_fun, Module, Function, Arity}, Env1} ->
        FunExpr = erl_fun_expr(Symbol, Module, Function, Arity, Env1),
        clj_env:push_expr(FunExpr, Env1);
      {{var, Var}, Env1} ->
        {VarExpr, Env2} = var_expr(Var, Symbol, Env1),
        clj_env:push_expr(VarExpr, Env2);
      {{type, Type}, Env1} ->
        TypeExpr = type_expr(Type, Symbol, Env1),
        clj_env:push_expr(TypeExpr, Env1)
    end.
  
  -spec erl_fun_expr( 'clojerl.Symbol':type()
  
negative.code:                                        , analyze_forms(Args, Env1)
                                         ),
  
    {TagExpr, Env3} = case FExpr of
                        #{op := fn, tag := Tag0} ->
                          {Tag0, Env2};
                        #{op := var, var := Var, tag := Tag0} ->
                          signature_tag(ArgCount, Tag0, Var, Env2);
                        _   ->
                          {?NO_TAG, Env2}
                      end,
  
    InvokeExpr0 = #{ op   => invoke
                   , env  => Env
                   , form => Form
                   , tag  => TagExpr
                   , f    => FExpr#{arity => ArgCount}
                   , args => ArgsExpr
                   },
  
    {InvokeExpr1, Env4} = add_type_tag(Form, InvokeExpr0, Env3),
  
    clj_env:push_expr(InvokeExpr1, Env4).
  
  -spec signature_tag( integer()
                     , map() | ?NO_TAG
  