anchor.diff:  check_func_spec(Func, Spec, L, St0) ->
       {Ar,St1} = check_func_name(Func, L, St0),
       case lfe_types:check_func_spec_list(Spec, Ar, St1#lint.types) of
  -	ok -> St1;
  -	{error,Error} -> add_error(L, Error, St1)
  +        ok -> St1;
  +        {error,Error} -> add_error(L, Error, St1)
       end.
   
   check_func_name([F,Ar], L, #lint{specs=Kss}=St)
     when is_atom(F), is_integer(Ar), Ar >= 0 ->
       Ks = {F,Ar},
       case lists:member(Ks, Kss) of
  -	true -> {Ar,add_error(L, {redef_spec,[F,Ar]}, St)};
  -	false -> {Ar,St#lint{specs=[Ks|Kss]}}
  +        true -> {Ar,add_error(L, {redef_spec,[F,Ar]}, St)};
  +        false -> {Ar,St#lint{specs=[Ks|Kss]}}
       end;
   check_func_name(F, L, St) ->
       {0,add_error(L, {bad_spec,F}, St)}.
  
positive.code: %% collect_function(Name, Meta, Def, Line, Fbs, State) -> {Fbs,State}.
  %%  Collect function and do some basic checks.
  
  collect_function(Name, Meta, Def, L, Fbs, St) ->
      Valid = is_atom(Name) and check_fmeta(Meta),
      case Def of
          [lambda|_] when Valid ->
              {[{Name,Def,L}|Fbs],St};
          ['match-lambda'|_] when Valid ->
              {[{Name,Def,L}|Fbs],St};
          _ -> {Fbs,bad_form_error(L, 'define-function', St)}
      end.
  
  check_fmeta([[doc|Docs]|Meta]) ->
      check_docs(Docs) andalso check_fmeta(Meta);
  check_fmeta([M|Meta]) -> is_list(M) andalso check_fmeta(Meta);
  check_fmeta([]) -> true;
  check_fmeta(_) -> false.
  
  %% check_docs(Docs) -> boolean().
  
  
negative.code:     St1 = check_mmetas(Meta, L, St0),
      check_attrs(Atts, L, St1).
  
  %% check_mmetas(Metas, Line, State) -> State.
  %%  Only allow docs and type definitions.
  
  check_mmetas(Ms, L, St) ->
      check_foreach(fun (M, S) -> check_mmeta(M, L, S) end,
                    fun (S) -> bad_mdef_error(L, form, S) end,
                    St, Ms).
  
  check_mmeta([doc|Docs], L, St) ->
      ?IF(check_docs(Docs), St, bad_meta_error(L, doc, St));
  