anchor.diff:          false -> {{call,L,{atom,L,F},Eas},St1}
       end;
   to_expr(List, L, _, St) ->
  -    case is_integer_list(List) of
  +    case is_posint_list(List) of
           true -> {{string,L,List},St};
           false ->
  -            io:format("BOOM:~p\n", [List]),
  -            {integer,L,4711}                    %Not right!
  +            error({illegal_code,List})          %Not right!
       end.
   
   to_expr_var(V, L, Vt, St) ->
  
positive.code: from_expr({bin,_,Segs}, Vt0, St0) ->
      {Ss,Vt1,St1} = from_bitsegs(Segs, Vt0, St0),
      {[binary|Ss],Vt1,St1};
  from_expr({map,_,Pairs}, Vt0, St0) ->           %Build a map
      {Ps,Vt1,St1} = from_map_pairs(Pairs, Vt0, St0),
      {[map|Ps],Vt1,St1};
  from_expr({map,_,Map,Pairs}, Vt0, St0) ->       %Update a map
      {Es,As} = split_map_pairs(Pairs),
      {Lm,Vt1,St1} = from_expr(Map, Vt0, St0),
      {Les,Vt2,St2} = from_map_pairs(Es, Vt1, St1),
      {Aes,Vt3,St3} = from_map_pairs(As, Vt2, St2),
      %% First do updates then normal sets as these can over write.
      Lum = if Les =:= [] -> Lm;                  %Expand update fields
               true -> ['map-update',Lm|Les]
            end,
      Lam = if Aes =:= [] -> Lum;                 %Expand set fields
               true -> ['map-set',Lum|Aes]
            end,
      {Lam,Vt3,St3};
  %% Core closure special forms.
  from_expr({'fun',_,{clauses,Cls}}, Vt, St0) ->
      {Lcls,St1} = from_fun_cls(Cls, Vt, St0),
  
negative.code:     {[Lp|Lps],Eqt++Eqts,Vt2,St2};
  from_pat_list([], Vt, St) -> {[],[],Vt,St}.
  
  from_pat_map_assocs([{map_field_exact,_,Key,Val}|As], Vt0, St0) ->
      {Lk,Eqt1,Vt1,St1} = from_pat(Key, Vt0, St0),
      {Lv,Eqt2,Vt2,St2} = from_pat(Val, Vt1, St1),
      {Lfs,Eqt3,Vt3,St3} = from_pat_map_assocs(As, Vt2, St2),
      {[Lk,Lv|Lfs],Eqt1 ++ Eqt2 ++ Eqt3,Vt3,St3};
  from_pat_map_assocs([], Vt, St) -> {[],[],Vt,St}.
  
  %% from_pat_rec_fields(Recfields, VarTable, State) ->
  %%     {Recfields,EqTable,VarTable,State}.
  
  