anchor.diff:      Arity = length(ArgsPattern),
       valid_expect(Mod, Func, Arity),
       MatchSpec = ets:match_spec_compile([?MATCH_SPEC(ArgsPattern)]),
  -    Clause = {{pattern, ArgsPattern, MatchSpec}, ret_spec_2_answer(RetSpec)},
  +    Clause = {{pattern, ArgsPattern, MatchSpec}, RetSpec},
       {Arity, Clause}.
   
   
   get_expect(Expects, _Mod, FuncAri, Args) ->
       case find_match(Args, dict:fetch(FuncAri, Expects)) of
  -        {_ArgsMatcher, {sequence, [Result]}} ->
  -            {{value, Result}, Expects};
  -        {ArgsMatcher, {sequence, [Result | Rest]}} ->
  +        not_found ->
  +            {meck_undefined, Expects};
  +        {_ArgsMatcher, {meck_sequence, [Result]}} ->
  +            {{meck_value, Result}, Expects};
  +        {ArgsMatcher, {meck_sequence, [Result | Rest]}} ->
               NewExpects = update_clause(Expects, FuncAri, ArgsMatcher,
  -                                       {sequence, Rest}),
  -            {{value, Result}, NewExpects};
  -        {ArgsMatcher, {loop, [Result], Loop}} ->
  +                                       {meck_sequence, Rest}),
  +            {{meck_value, Result}, NewExpects};
  +        {ArgsMatcher, {meck_loop, [Result], Loop}} ->
               NewExpects = update_clause(Expects, FuncAri, ArgsMatcher,
  -                                       {loop, Loop, Loop}),
  -            {{value, Result}, NewExpects};
  -        {ArgsMatcher, {loop, [Result | Rest], Loop}} ->
  +                                       {meck_loop, Loop, Loop}),
  +            {{meck_value, Result}, NewExpects};
  +        {ArgsMatcher, {meck_loop, [Result | Rest], Loop}} ->
               NewExpects = update_clause(Expects, FuncAri, ArgsMatcher,
  -                                       {loop, Rest, Loop}),
  -            {{value, Result}, NewExpects};
  -        {_ArgsMatcher, Answer} ->
  -            {Answer, Expects};
  -        not_found ->
  -            {not_found, Expects}
  +                                       {meck_loop, Rest, Loop}),
  +            {{meck_value, Result}, NewExpects};
  +        {_ArgsMatcher, RetSpec} ->
  +            {RetSpec, Expects}
       end.
   
   
  
positive.code: %% @doc Converts a list of terms into {@link ret_spec()} defining a loop of
  %% values. It is intended to be in construction of clause specs for the
  %% {@link expect/3} function.
  -spec loop(Loop::[term()]) -> ret_spec().
  loop(L) when is_list(L) -> {meck_loop, L}.
  
  
  %% @doc Converts a list of terms into {@link ret_spec()} defining a sequence of
  %% values. It is intended to be in construction of clause specs for the
  %% {@link expect/3} function.
  -spec seq(Sequence::[term()]) -> ret_spec().
  seq(S) when is_list(S) -> {meck_sequence, S}.
  
  
negative.code: 
  mock_exception_fun(Class, Reason) -> fun() -> {exception, Class, Reason} end.
  
  call_expect(_Mod, _Func, meck_undefined, _Args) ->
      erlang:error(function_clause);
  call_expect(_Mod, _Func, {meck_value, Value}, _Args) ->
      Value;
  call_expect(_Mod, _Func, {meck_func, Fun}, Args) when is_function(Fun) ->
      apply(Fun, Args);
  call_expect(Mod, Func, passthrough, Args) ->
      apply(original_name(Mod), Func, Args);
  call_expect(_Mod, _Func, Value, _Args) ->
      Value.
  
  inject(_Mod, _Func, _Args, []) ->
      [];
  