anchor.diff:      is_integer_list(Is);
   is_integer_list([]) -> true;
   is_integer_list(_) -> false.
  +
  +%% var_name(Var, Vars) -> Var.
  +%% new_var_name(Var, Vars) -> {Var,Vars}.
  +%%  New_var_name is used in patterns and always generates a new unused
  +%%  var name. This so we don't have to know all vars which we may be
  +%%  shadowing.
  +
  +var_name(V, Vs) ->
  +    case find(V, Vs) of
  +	{ok,V1} -> V1;
  +	error -> V
  +    end.
  +
  +new_var_name(Base, Vs) ->
  +    case find(Base, Vs) of
  +	{ok,V} ->
  +	    V1 = list_to_atom(lists:concat([V,'_'])),
  +	    {V1,store(Base, V1, Vs)};
  +	error ->
  +	    V1 = list_to_atom(lists:concat(['_',Base,'_'])),
  +	    {V1,store(Base, V1, Vs)}
  +    end.
  
positive.code: from_expr({float,_,F}) -> F;
  from_expr({atom,_,A}) -> ?Q(A);			%Must quote here
  from_expr({string,_,S}) -> ?Q(S);		%Must quote here
  from_expr({cons,_,H,T}) ->
      [cons,from_expr(H),from_expr(T)];
  from_expr({tuple,_,Es}) ->
      [tuple|from_expr_list(Es)];
  from_expr({bin,_,Segs}) ->
  
negative.code: 	{error,Error} -> erlang:error(Error)
      end.
  
  %% to_pat(Pattern, LineNumber, Vars) -> {Pattern,Vars}.
  
  to_pat([], L, Vs) -> {{nil,L},Vs};
  to_pat(I, L, Vs) when is_integer(I) -> {{integer,L,I},Vs};
  to_pat(F, L, Vs) when is_float(F) -> {{float,L,F},Vs};
  to_pat(V0, L, Vs0) when is_atom(V0) ->		%Unquoted atom
      {V1,Vs1} = new_var_name(V0, Vs0),
      {{var,L,V1},Vs1};
  to_pat(T, L, _) when is_tuple(T) ->		%Tuple literal
      {tuple,L,to_lit_list(tuple_to_list(T), L)};
  to_pat(?Q(P), L, Vs) -> {to_lit(P, L),Vs};	%Everything quoted here
  to_pat([cons,H0,T0], L, Vs0) ->
      {H1,Vs1} = to_pat(H0, L, Vs0),
      {T1,Vs2} = to_pat(T0, L, Vs1),
      {{cons,L,H1,T1},Vs2};
  to_pat([list|Ps], L, Vs) ->
      F = fun (P0, {T,Vs0}) ->
  		{P1,Vs1} = to_pat(P0, L, Vs0),
  		{{cons,L,P1,T},Vs1}
  	end,
      foldr(F, {{nil,L},Vs}, Ps);
  to_pat([tuple|Ps0], L, Vs0) ->
      {Ps1,Vs1} = to_pat_list(Ps0, L, Vs0),
      {{tuple,L,Ps1},Vs1};
  to_pat(['=',P1,P2], L, Vs0) ->			%Alias
      {P11,Vs1} = to_pat(P1, L, Vs0),
      {P21,Vs2} = to_pat(P2, L, Vs1),
      {{match,L,P11,P21},Vs2}.
  
  to_pat_list(Ps, L, Vs) ->
      mapfoldl(fun (P, Vs0) -> to_pat(P, L, Vs0) end, Vs, Ps).
  
  to_lit([], L) -> {nil,L};
  to_lit(I, L) when is_integer(I) -> {integer,L,I};
  