anchor.diff:  'expand_set!'([Set, Var, Val], SynEnv) ->
     {[Set, Var, expand_expr(Val, SynEnv)], SynEnv}.
   
  +%% (case <expr> (<pat> [(when <expr>)] <expr>+)+)
  +%% This is the ErlScheme-specific (case ...), NOT Scheme's pointless version.
  +expand_case([Case, Expr0 | Clauses0], SynEnv) ->
  +  Expr = expand_expr(Expr0, SynEnv),
  +  Clauses = lists:map(fun (Clause) -> expand_case_clause(Clause, SynEnv) end, Clauses0),
  +  {[Case, Expr | Clauses], SynEnv}.
  +
  +expand_case_clause([Pat, ['when', Expr] | Exprs], SynEnv) ->
  +  SynEnvClause = bind_pat_vars(Pat, nested(SynEnv)),
  +  [Pat, ['when', expand_expr(Expr, SynEnvClause)], ['begin' | expand_list(Exprs, SynEnvClause)]];
  +expand_case_clause([Pat | Exprs], SynEnv) ->
  +  SynEnvClause = bind_pat_vars(Pat, nested(SynEnv)),
  +  [Pat, ['begin' | expand_list(Exprs, SynEnvClause)]].
  +
   %% (cond <clause>+)
   expand_cond([_Cond, Clause | Rest], SynEnv) ->
     {expand_cond(Clause, Rest, SynEnv), SynEnv}.
  
positive.code: %% Sometimes we need to generate an unspecified value.
  expand_unspecified() ->
    ['quote', es_datum:unspecified()].
  
  %% Quasiquote expander ---------------------------------------------------------
  %%
  
negative.code:   lists:map(
      fun ({Name, Type, Expander}) -> {Name, wrap_expander(Type, Expander)} end,
      [ {'begin', ?syntax, fun expand_begin/2}
      , {'case', ?syntax, fun expand_case/2}
      , {'compiler-syntax', ?syntax, fun expand_compiler_syntax/2}
      , {'cond', ?syntax, fun expand_cond/2}
      , {'define', ?syntax, fun expand_define/2}
  