anchor.diff:  pattern([], Pvs, _, _, St) -> {Pvs,St};
   pattern(Symb, Pvs, _, L, St) when is_atom(Symb) ->
       pat_symb(Symb, Pvs, L, St);
  -pattern(_, Pvs, _, _, St) -> {Pvs,St}.          %Atomic
  +pattern(Lit, Pvs, Env, L, St) ->
  +    {Pvs,literal(Lit, Env, L, St)}.             %Everything else is a literal
   
   pat_list([P|Ps], Pvs0, Env, L, St0) ->
       {Pvs1,St1} = pattern(P, Pvs0, Env, L, St0),
       pat_list(Ps, Pvs1, Env, L, St1);
   pat_list([], Pvs, _, _, St) -> {Pvs,St};
  -pat_list(_, Pvs, _, L, St) -> {Pvs,add_error(L, illegal_pattern, St)}.
  +pat_list(_, Pvs, _, L, St) ->
  +    {Pvs,add_error(L, illegal_pattern, St)}.
   
   pat_symb('_', Pvs, _, St) -> {Pvs,St};          %Don't care variable
   pat_symb(Symb, Pvs, L, St) ->
       case is_element(Symb, Pvs) of
  -    true -> {Pvs,multi_var_error(L, Symb, St)};
  -    false -> {add_element(Symb, Pvs),St}
  +        true -> {Pvs,multi_var_error(L, Symb, St)};
  +        false -> {add_element(Symb, Pvs),St}
       end.
   
   %% pat_alias(Pattern, Pattern) -> true | false.
  
positive.code:     {Fs,St1} = check_fbindings(Fbs, St0),
      %% Now check function definitions.
      St2 = foldl(fun ({_,[lambda|Lambda],L}, St) ->
              check_lambda(Lambda, Env0, L, St);
              ({_,['match-lambda'|Match],L}, St) ->
              check_match_lambda(Match, Env0, L, St)
          end, St1, Fbs),
      %% Add to environment
      Env1 = foldl(fun ({F,A}, Env) -> add_fbinding(F, A, Env) end, Env0, Fs),
      {Fs,Env1,St2}.
  
negative.code: check_let_vb(Vb, Env, L, St0) ->
      %% Get the environments right here!
      case pattern_guard(Vb, Env, L, St0) of
          {[Val],Pvs,_,St1} ->                    %One value expression only
              {Pvs,check_expr(Val, Env, L, St1)};
          {_,_,_,St1} -> {[],bad_form_error(L, 'let', St1)}
      end.
  
  %% check_let_function(FletBody, Env, Line, State) -> {Env,State}.
  