anchor.diff:                    end,
     {FieldsAsts, HiddenFieldsAsts} = lists:partition(IsRecordFld, AllFieldsAsts),
   
  -  CtorAst      = constructor_function(Module, AllFieldsAsts, HiddenFieldsAsts),
  -  CtorExport  = {?CONSTRUCTOR, length(FieldsAsts)},
  -
     %% Generate accessor functions for all fields.
     AccessorsAsts = lists:map( fun(F) -> accessor_function(Module, F) end
                              , AllFieldsAsts
                              ),
   
  -  %% When there are hidden fields we also want to create a constructor function
  -  %% that includes them.
  +  %% Create a constructor that doesn't include the hidded fields.
  +  CtorAst   = constructor_function(Module, AllFieldsAsts, HiddenFieldsAsts),
  +  %% When there are hidden fields we assume  it is a record, so we also want
  +  %% to create:
  +  %%   - a constructor function that includes the hidden fields.
  +  %%   - a create/1 function that takes a map.
     CtorsAsts = case HiddenFieldsAsts of
                   [] -> [CtorAst];
                   _  -> [ CtorAst
                         , constructor_function(Module, AllFieldsAsts, [])
  +                      , create_function(Module, AllFieldsAsts, HiddenFieldsAsts)
                         ]
                 end,
   
     %% Exports
     MethodsExports = lists:map(fun function_signature/1, MethodsAsts1),
  +  CtorExport     = {?CONSTRUCTOR, length(FieldsAsts)},
     CtorsExports   = case HiddenFieldsAsts of
                        [] -> [CtorExport];
  -                     _  -> [CtorExport, {?CONSTRUCTOR, length(AllFieldsAsts)}]
  +                     _  -> [ CtorExport
  +                           , {?CONSTRUCTOR, length(AllFieldsAsts)}
  +                           , {create, 1}
  +                           ]
                      end,
     AccessorsExports = lists:map( fun({var, _, FName}) ->
                                       {field_fun_name(FName), 1}
  
positive.code: %%      to build Clojerl data types.
  -spec type_tuple(atom(), [ast()], [ast()], create | match) -> ast().
  type_tuple(Typename, AllFieldsAsts, HiddenFieldsAsts, TupleType) ->
    {MapField, Info} =
      case TupleType of
        create ->
          {map_field_assoc, {atom, 0, undefined}};
  
negative.code: do_list_ast([H | Hs], Tail) ->
    {cons, 0, H, do_list_ast(Hs, Tail)}.
  
  %% @doc Replaces the first argument of a function with a pattern match.
  %%
  %% This function is used for deftype methods so that the fields are available
  %% in the scope of the body of each method.
  -spec expand_first_argument(ast(), ast()) -> ast().
  expand_first_argument( {function, _, _, _, [ClauseAst]} = Function
                       , TypeTupleAst
  