anchor.diff:  
   -export([module/1,module/2,form/1,expr/1,expr/2,
            pattern/1,pattern/2,format_error/1]).
  -
  --import(lfe_env, [new/0,is_vbound/2,is_fbound/3,is_gbound/3,
  -                  add_vbinding/3,add_fbinding/4,add_ibinding/5]).
   
   -import(lfe_lib, [is_erl_bif/2,is_guard_bif/2,
                     is_symb_list/1,is_proper_list/1]).
  
positive.code:     %% Add the imports.
      Env0 = foldl(fun ({M,Fs}, Env) ->
                           foldl(fun ({{F,A},R}, E) ->
                                         add_ibinding(M, F, A, R, E)
                                 end, Env, Fs)
                   end, lfe_env:new(), St#lint.imps),
      %% Basic predefines
  
negative.code:     end.
  
  %% check_match_lambda(MatchBody, Env, Line, State) -> State.
  %%  Check form (match-lambda Clause ...), must be at least one clause.
  %%  Use arity of 1st as THE arity. Do one pass to get errors in right
  %%  order.
  
  check_match_lambda([C|_]=Cls, Env, L, St) ->
      Ar = ml_arity(C),                           %Arity of 1st clause
      check_ml_clauses(Cls, Ar, Env, L, St);
  check_match_lambda(_, _, L, St) ->              %Totally wrong, no clauses
      bad_form_error(L, 'match-lambda', St).
  
  ml_arity([Pat|_]) ->
      safe_length(Pat, -1);
  ml_arity(_) -> -1.
  
  check_ml_clause([Pat|Rest]=C, Ar, Env0, L, St0) ->
      St1 = case ml_arity(C) =:= Ar of
                true -> St0;
                false -> add_error(L, bad_arity, St0)
            end,
      check_clause([[list|Pat]|Rest], Env0, L, St1);
  check_ml_clause(_, _, _, L, St) ->
      bad_form_error(L, clause, St).
  
  check_ml_clauses(Cls, Ar, Env, L, St) ->
      foreach_form(fun (C, S) -> check_ml_clause(C, Ar, Env, L, S) end,
                   'match-lambda', L, St, Cls).
  
  %% check_let(LetBody, Env, Line, State) -> {Env,State}.
  %%  Check let variable bindings and then body. Must be careful to use
  