anchor.diff:      mapfoldl2(Fun, Vt, St, Ss).
   
   to_pat_bitseg([Val|Specs]=F, L, Vt, St) ->
  -    case is_integer_list(F) of
  +    case is_posint_list(F) of
           true ->
               {Size,Type} = to_bitspecs([]),
               to_pat_bin_element(F, Size, Type, L, Vt, St);
  
positive.code:     {[Et|Eqs],Vt1,St2};
  to_lc_quals([], _, Vt, St) -> {[],Vt,St}.
  
  %% to_bitsegs(Segs, LineNumber, VarTable, State) -> {Segs,State}.
  %% This gives a verbose value, but it is correct.
  
  to_bitsegs(Ss, L, Vt, St) ->
      Fun = fun (S, St0) -> to_bitseg(S, L, Vt, St0) end,
      mapfoldl(Fun, St, Ss).
  
  to_bitseg([Val|Specs]=F, L, Vt, St) ->
      case is_integer_list(F) of
          true ->
              {Size,Type} = to_bitspecs([]),
              to_bin_element(F, Size, Type, L, Vt, St);
          false ->
              {Size,Type} = to_bitspecs(Specs),
              to_bin_element(Val, Size, Type, L, Vt, St)
      end;
  to_bitseg(Val, L, Vt, St) ->
      {Size,Type} = to_bitspecs([]),
      to_bin_element(Val, Size, Type, L, Vt, St).
  
  to_bin_element(Val, Size, {Type,Unit,Sign,End}, L, Vt, St0) ->
      {Eval,St1} = to_expr(Val, L, Vt, St0),
      {Esiz,St2} = to_bin_size(Size, L, Vt, St1),
      {{bin_element,L,Eval,Esiz,[Type,to_bin_unit(Unit),Sign,End]},St2}.
  
  to_bin_size(default, _, _, St) -> {default,St};
  to_bin_size(undefined, _, _, St) -> {default,St};
  to_bin_size(Size, L, Vt, St) -> to_expr(Size, L, Vt, St).
  
  to_bin_unit(default) -> default;
  to_bin_unit(Unit) -> {unit,Unit}.
  
  %% to_bitspec(Specs) -> {Size,Type}.
  %%  Get the error handling as we want it.
  
  to_bitspecs(Ss) ->
      case lfe_bits:get_bitspecs(Ss) of
          {ok,Sz,Ty} -> {Sz,Ty};
          {error,Error} -> erlang:error(Error)
      end.
  
  %% to_map_pairs(Pairs, LineNumber, VarTable, State) -> {Fields,State}.
  
  to_map_pairs([K,V|Ps], Field, L, Vt, St0) ->
      {Ek,St1} = to_expr(K, L, Vt, St0),
      {Ev,St2} = to_expr(V, L, Vt, St1),
      {Eps,St3} = to_map_pairs(Ps, Field, L, Vt, St2),
      {[{Field,L,Ek,Ev}|Eps],St3};
  to_map_pairs([], _, _, _, St) -> {[],St}.
  
  new_to_var(#to{vc=C}=St) ->
      V = list_to_atom(lists:concat(["___",C,"___"])),
      {V,St#to{vc=C+1}}.
  
negative.code: from_expr({bin,_,Segs}, Vt0, St0) ->
      {Ss,Vt1,St1} = from_bitsegs(Segs, Vt0, St0),
      {[binary|Ss],Vt1,St1};
  from_expr({map,_,Assocs}, Vt0, St0) ->          %Build a map
      {Ps,Vt1,St1} = from_map_assocs(Assocs, Vt0, St0),
      {[map|Ps],Vt1,St1};
  from_expr({map,_,Map,Assocs}, Vt0, St0) ->      %Update a map
      {Lm,Vt1,St1} = from_expr(Map, Vt0, St0),
      from_map_update(Assocs, nul, Lm, Vt1, St1);
  %% Core closure special forms.
  from_expr({'fun',_,{clauses,Cls}}, Vt, St0) ->
      {Lcls,St1} = from_fun_cls(Cls, Vt, St0),
  