anchor.diff:  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
  
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: guard({op,1,Op,One})            -> {Op,guard(One)};           % binary op
  guard(Guard)                    -> arg(Guard).                % variable
  
  arg({nil,_})        -> {list,[]};
  arg(L={cons,_,_,_}) -> {list,arg_list(L)};
  arg({tuple,1,Args}) -> {tuple,[arg(A)||A<-Args]};
  arg({T,1,Var})      -> {T,Var}.
  
  arg_list({cons,_,H,T}) -> [arg(H)|arg_list(T)];
  arg_list({nil,_})      -> [].
  %% non-proper list should be handled here.
  
  actions_fun(Str) ->
    fun() ->
  