anchor.diff:  
   init_expects(Mod, Options) ->
       case proplists:get_value(passthrough, Options, false) andalso exists(Mod) of
  -        true -> dict:from_list([{FuncAri, [{arity_2_matcher(Arity), passthrough}]} ||
  -                                   FuncAri = {_Func, Arity} <- exports(Mod)]);
  +        true -> dict:from_list([passthrough_stub(Func, Arity) ||
  +                                   {Func, Arity} <- exports(Mod)]);
           _    -> dict:new()
       end.
   
  +passthrough_stub(Func, Arity) ->
  +    {{Func, Arity}, [{arity_2_matcher(Arity), passthrough}]}.
   
   parse_clause_specs(Mod, Func, ClauseSpecs) ->
       parse_clause_specs(Mod, Func, ClauseSpecs, undefined, []).
   
  -parse_clause_specs(Mod, Func, [{ArgPatterns, RetSpec} | Rest], undefined, []) ->
  -    {Arity, Clause} = parse_clause_spec(Mod, Func, ArgPatterns, RetSpec),
  +parse_clause_specs(Mod, Func, [ClauseSpec | Rest], undefined, []) ->
  +    {Arity, Clause} = parse_clause_spec(Mod, Func, ClauseSpec),
       parse_clause_specs(Mod, Func, Rest, Arity, [Clause]);
  -parse_clause_specs(Mod, Func, [{ArgPatterns, RetSpec} | Rest], Arity, Clauses) ->
  -    {Arity, Clause} = parse_clause_spec(Mod, Func, ArgPatterns, RetSpec),
  +parse_clause_specs(Mod, Func, [ClauseSpec | Rest], Arity, Clauses) ->
  +    {Arity, Clause} = parse_clause_spec(Mod, Func, ClauseSpec),
       parse_clause_specs(Mod, Func, Rest, Arity, [Clause | Clauses]);
   parse_clause_specs(_Mod, _Func, [], Arity, Clauses) ->
       {Arity, lists:reverse(Clauses)}.
   
   
  -parse_clause_spec(Mod, Func, ArgPatterns, RetSpec) ->
  +parse_clause_spec(Mod, Func, {ArgPatterns, RetSpec}) ->
       Arity = length(ArgPatterns),
       valid_expect(Mod, Func, Arity),
  -    Clause = {{pattern, ArgPatterns},
  -              ret_spec_2_answer(RetSpec)},
  +    Clause = {{pattern, ArgPatterns}, ret_spec_2_answer(RetSpec)},
       {Arity, Clause}.
   
   
  
positive.code:         {_ArgsMatcher, {sequence, [Result]}} ->
              {{value, Result}, Expects};
          {ArgsMatcher, {sequence, [Result | Rest]}} ->
              NewExpects = update_clause(Expects, FuncAri, ArgsMatcher, {sequence, Rest}),
              {{value, Result}, NewExpects};
          {ArgsMatcher, {loop, [Result], Loop}} ->
              NewExpects = update_clause(Expects, FuncAri, ArgsMatcher, {loop, Loop, Loop}),
              {{value, Result}, NewExpects};
          {ArgsMatcher, {loop, [Result | Rest], Loop}} ->
              NewExpects = update_clause(Expects, FuncAri, ArgsMatcher, {loop, Rest, Loop}),
              {{value, Result}, NewExpects};
          {_ArgsMatcher, Answer} ->
              {Answer, Expects}
  
negative.code:       Arity :: non_neg_integer(),
        ArgPatterns :: [term() | '_'],
        RetSpec :: term() | ret_spec().
  expect(Mod, Func, Arity, RetSpec)
    when is_atom(Mod), is_atom(Func), is_integer(Arity), Arity >= 0 ->
      valid_expect(Mod, Func, Arity),
      Clause = {arity_2_matcher(Arity), ret_spec_2_answer(RetSpec)},
      call(Mod, {expect, {Func, Arity}, [Clause]});
  expect(Mod, Func, ArgPatterns, RetSpec)
    when is_atom(Mod), is_atom(Func), is_list(ArgPatterns) ->
      {Arity, Clause} = parse_clause_spec(Mod, Func, {ArgPatterns, RetSpec}),
      call(Mod, {expect, {Func, Arity}, [Clause]});
  expect(Mod, Func, ArgsSpec, RetSpec) when is_list(Mod) ->
      lists:foreach(fun(M) -> expect(M, Func, ArgsSpec, RetSpec) end, Mod),
  