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:       ClauseSpec :: {ArgPatterns, RetSpec},
        ArgPatterns :: [term() | '_'],
        RetSpec :: term() | ret_spec().
  expect(Mod, Func, StubFun) when is_atom(Mod),
                                  is_atom(Func),
                                  is_function(StubFun) ->
      {arity, Arity} = erlang:fun_info(StubFun, arity),
      Clause = {arity_2_matcher(Arity), {func, StubFun}},
      call(Mod, {expect, {Func, Arity}, [Clause]});
  expect(Mod, Func, ClauseSpecs) when is_atom(Mod),
                                      is_atom(Func),
                                      is_list(ClauseSpecs) ->
      {Arity, Clauses} = parse_clause_specs(Mod, Func, ClauseSpecs),
      call(Mod, {expect, {Func, Arity}, Clauses});
  expect(Mod, Func, Expect) when is_list(Mod) ->
  
negative.code: update_clause(Expects, FuncAri, ArgsMatcher, Answer) ->
      dict:update(FuncAri,
                  fun(Clauses) ->
                          lists:keyreplace(ArgsMatcher, 1, Clauses,
                                           {ArgsMatcher, Answer})
                  end,
                  Expects).
  
  