anchor.diff:  
   'expand_let*'([], Body, SynEnv) -> ['let', [] | expand_body(Body, nested(SynEnv))];
   'expand_let*'([[Var, Init] | Bindings], Body, SynEnv) ->
  -  ['let', [[Var, expand_expr(Init, SynEnv)]], 'expand_let*'(Bindings, Body, do_unbind_var(Var, nested(SynEnv)))].
  +  ['let', [[Var, expand_expr(Init, SynEnv)]], 'expand_let*'(Bindings, Body, do_bind_var(Var, nested(SynEnv)))].
   
   %% (let <bindings> <body>+)
   %% (let <name> <bindings> <body>+)
   expand_let([_Let, Name, Bindings | Body], SynEnv) when is_atom(Name) ->
     Formals = lists:map(fun ([Var, _Init]) -> Var end, Bindings),
     Inits = lists:map(fun ([_Var, Init]) -> expand_expr(Init, SynEnv) end, Bindings),
  -  SynEnvBody = unbind_vars([Name | Formals], nested(SynEnv)),
  +  SynEnvBody = bind_vars([Name | Formals], nested(SynEnv)),
     Lambda = ['lambda', Formals | expand_body(Body, SynEnvBody)],
     {[['letrec', [[Name, Lambda]], Name] | Inits], SynEnv};
   expand_let(Form, SynEnv) -> expand_let_or_letrec(Form, SynEnv).
  
positive.code:   {[Try, Expr | (MaybeOf ++ (MaybeCatch ++ After))], SynEnv}.
  
  expand_try_clause(Tag, [[Tag, Var | Exprs] | Rest], SynEnv) when is_atom(Var) ->
    {[[Tag, Var, ['begin' | expand_list(Exprs, do_unbind_var(Var, nested(SynEnv)))]]], Rest};
  expand_try_clause(_Tag, Rest, _SynEnv) ->
    {[], Rest}.
  
  
negative.code:     expand_toplevel(NewSexpr, NewSynEnv)
    end.
  
  bind_vars(Vars, SynEnv) ->
    false = es_synenv:is_gloenv(SynEnv), % assert
    lists:foldl(fun do_bind_var/2, SynEnv, Vars).
  
  bind_var(Var, SynEnv) ->
    case es_synenv:is_gloenv(SynEnv) of
      true ->
        SynEnv; % toplevel (define ..), nothing for us to do
      false ->
        do_bind_var(Var, SynEnv)
    end.
  
  %% Variables are bound to false, as opposed to expanders which are bound to functions.
  do_bind_var(Var, SynEnv) ->
    es_synenv:enter(SynEnv, Var, false).
  
  nested(SynEnv) ->
  