anchor.diff:  pattern({tuple,_Line,Ps}, Vt, Old, Bvt, St) ->
       pattern_list(Ps, Vt, Old, Bvt, St);
   pattern({map,_Line,Ps}, Vt, Old, Bvt, St) ->
  -    foldl(fun
  -	    ({map_field_assoc,L,_,_}, {Psvt,Bvt0,St0}) ->
  -		{Psvt,Bvt0,add_error(L, illegal_pattern, St0)};
  -	    ({map_field_exact,L,KP,VP}, {Psvt,Bvt0,St0}) ->
  -		case is_valid_map_key(KP, pattern, St0) of
  -		    true ->
  -			{Pvt,Bvt1,St1} = pattern(VP, Vt, Old, Bvt, St0),
  -			{vtmerge_pat(Pvt, Psvt),vtmerge_pat(Bvt0, Bvt1), St1};
  -		    false ->
  -			{Psvt,Bvt0,add_error(L, illegal_map_key, St0)};
  -		    {false,variable,Var} ->
  -			{Psvt,Bvt0,add_error(L, {illegal_map_key_variable,Var}, St0)}
  -		end
  -	end, {[],[],St}, Ps);
  +    pattern_map(Ps, Vt, Old, Bvt, St);
   %%pattern({struct,_Line,_Tag,Ps}, Vt, Old, Bvt, St) ->
   %%    pattern_list(Ps, Vt, Old, Bvt, St);
   pattern({record_index,Line,Name,Field}, _Vt, _Old, _Bvt, St) ->
  
positive.code:         _ -> true
      end.
  
  %% is_valid_map_key(K,St) -> true | false | {false, Var::atom()}
  %%   check for value expression without variables
  
  is_valid_map_key(K,St) ->
      is_valid_map_key(K,expr,St).
  is_valid_map_key(K,Ctx,St) ->
      case expr(K,[],St) of
  	{[],_} ->
  	    is_valid_map_key_value(K,Ctx);
  	{[Var|_],_} ->
  	    {false,variable,element(1,Var)}
      end.
  
  is_valid_map_key_value(K,Ctx) ->
      case K of
  	{char,_,_} -> true;
  	{integer,_,_} -> true;
  	{float,_,_} -> true;
  
negative.code: 	{nil,_} -> true;
  	{atom,_,_} -> true;
  	{cons,_,H,T} ->
  	    is_valid_map_key_value(H) andalso
  	    is_valid_map_key_value(T);
  	{tuple,_,Es} ->
  	    foldl(fun(E,B) ->
  			B andalso is_valid_map_key_value(E)
  		end,true,Es);
  	{map,_,Arg,Ps} ->
  	    % only check for value expressions to be valid
  	    % invalid map expressions are later checked in
  	    % core and kernel
  	    is_valid_map_key_value(Arg) andalso foldl(fun
  		    ({Tag,_,Ke,Ve},B) when Tag =:= map_field_assoc;
  					   Tag =:= map_field_exact ->
  		    B andalso is_valid_map_key_value(Ke)
  		      andalso is_valid_map_key_value(Ve);
  		    (_,_) -> false
  	    end,true,Ps);
  	{map,_,Ps} ->
  	    foldl(fun
  		    ({Tag,_,Ke,Ve},B) when Tag =:= map_field_assoc;
  					   Tag =:= map_field_exact ->
  		    B andalso is_valid_map_key_value(Ke)
  		      andalso is_valid_map_key_value(Ve);
  		    (_,_) -> false
  	    end, true, Ps);
  	{record,_,_,Fs} ->
  	    foldl(fun
  		    ({record_field,_,Ke,Ve},B) ->
  		    B andalso is_valid_map_key_value(Ke)
  		      andalso is_valid_map_key_value(Ve)
  	      end,true,Fs);
  	{bin,_,Es} ->
  	    % only check for value expressions to be valid
  