anchor.diff:         {{a,b,2},[{['$1',"foo"],[],[]}],[local]}}
        ,{"x:y({A,{B,A}},A)",
          {{x,y,2},[{[{'$1',{'$2','$1'}},'$1'],[],[]}],[local]}}
  +     ,{"x:y(A,[A,{B,[B,A]},A],B)",
  +       {{x,y,3},[{['$1',['$1',{'$2',['$2','$1']},'$1'],'$2'],[],[]}],[local]}}
        ,{" a:foo when a==b",
          guards_without_args}
        ,{"a:b(X,y)when is_atom(Y)",
          unbound_variable}
        ,{"x:c([string])",
  -       {syntax_error,"lists not allowed in arg list"}}
  +       {{x,c,1},[{[[string]],[],[]}],[local]}}
        ,{"x(s)",
          this_is_too_confusing}
        ,{"x:c(S)when S==x;S==y",
  
positive.code: compile_args(As) ->
    lists:foldl(fun ca_fun/2,{[],[]},As).
  
  ca_fun({tuple,Es},{Vars,O}) ->
    {Vs,Ps} = lists:foldr(fun(E,{V0,P0})-> {V,P}=ca_fun(E,{V0,[]}),
                                           {V0++V,P++P0}
                          end,
                          {Vars,[]},
                          Es),
    {Vs,O++[list_to_tuple(Ps)]};
  ca_fun({var,'_'},{Vars,O}) -> 
    {Vars,O++['_']};
  
negative.code: ca_fun({Type,Val},{Vars,O}) -> 
    assert_type(Type,Val),
    {Vars,O++[Val]}.
  
  ca_fun_list(Es,Vars) ->
    lists:foldr(fun(E,{V0,P0})-> {V,P}=ca_fun(E,{V0,[]}),
                                 {lists:usort(V0++V),P++P0}
                end,
                {Vars,[]},
                Es).
  
  assert_type(Type,Val) -> 
    case lists:member(Type,[integer,atom,string]) of
  