anchor.diff:                         fun(F, G) ->
                                  case schema(get, F) of
                                      {group, GroupId} ->
  -                                       [%%{GroupId,
  -                                         link_node(GroupId, 
  -                                                   binary_to_atom(schema(get, name, F), latin1), 
  -                                                   Nodes)
  -                                                %}
  -                                        |G];
  +                                       Name = binary_to_atom(schema(get, name, F), latin1),
  +                                       [link_node(GroupId, Name, Nodes)|G];
                                      _ -> G
                                  end
                          end,
  
positive.code:     {Node, Schema} = proplists:get_value(Id, Nodes),
      NestedNodes = [begin
                         Name = binary_to_atom(schema(get, name, N), latin1),
                         %%{Name, 
                          link_node(schema(get, id, N), Name, Nodes)
                         %%}
                     end || N <- schema(get, nestedNodes, Node)],
      Groups = case schema(get, Node) of
                   {struct, S} ->
  
negative.code:     Type = schema(get, type, Field),
      compile_field(schema(get, Type), schema(get, offset, Field));
  compile_struct_field_type({group, Id}) ->
      #group{ type=Id }.
  
  compile_field({list, Type}, Offset) -> ptr_field(list_field_type(Type), Offset);
  compile_field({enum, Id}, Offset) -> data_field({{enum, Id}, 16}, Offset);
  compile_field({struct, Id}, Offset) -> ptr_field({struct, Id}, Offset);
  compile_field({interface, Id}, Offset) -> ptr_field({interface, Id}, Offset);
  compile_field(object, Offset) -> ptr_field(object, Offset);
  compile_field(text, Offset) -> ptr_field(text, Offset);
  compile_field(Type, Offset)
    when is_atom(Type) ->
      data_field(capnp_type_info(Type), Offset).
  
  list_field_type(Type) ->
      {list, 
  