Is it possible to use record name as a parameter?

Lets say I have a record:

-record(foo, {bar}).

What I would like to do is to be able to pass the record name to a function as a parameter, and get back a new record. The function should 开发者_运维技巧be generic so that it should be able to accept any record, something like this.

make_record(foo, [bar], ["xyz"])

When implementing such a function I've tried this:

make_record(RecordName, Fields, Values) ->
    NewRecord = #RecordName{} %% this line gives me an error: syntax error before RecordName

Is it possible to use the record name as a parameter?

You can't use the record syntax if you don't have access to the record during compile time.

But because records are simply transformed into tuples during compilation it is really easy to construct them manually:

-record(some_rec, {a, b}).

make_record(Rec, Values) ->
    list_to_tuple([Rec | Values]).

test() ->
    R = make_record(some_rec, ["Hej", 5]),  % Dynamically create record
    #some_rec{a = A, b = B} = R,            % Access it using record syntax
    io:format("a = ~p, b = ~p~n", [A, B]).  

Alternative solution

Or, if you at compile time make a list of all records that the function should be able to construct, you can use the field names also:

%% List of record info created with record_info macro during compile time
-define(recs, 
    [
     {some_rec, record_info(fields, some_rec)},
     {some_other_rec, record_info(fields, some_other_rec)}
    ]).

make_record_2(Rec, Fields, Values) ->
    ValueDict = lists:zip(Fields, Values),

    % Look up the record name and fields in record list
    Body = lists:map(
         fun(Field) -> proplists:get_value(Field, ValueDict, undefined) end,
         proplists:get_value(Rec, ?recs)),

    list_to_tuple([Rec | Body]).

test_2() ->
    R = make_record_2(some_rec, [b, a], ["B value", "A value"]),
    #some_rec{a = A, b = B} = R,
    io:format("a = ~p, b = ~p~n", [A, B]).

With the second version you can also do some verification to make sure you are using the right fields etc.

Other tips

Other useful constructs to keep in mind when working with records dynamically is the #some_rec.a expression which evaluates to the index of the a field in some_recs, and the element(N, Tuple) function which given a tuple and an index returns the element in that index.

This is not possible, as records are compile-time only structures. At compilation they are converted into tuples. Thus the compiler needs to know the name of the record, so you cannot use a variable.

You could also use some parse-transform magic (see exprecs) to create record constructors and accessors, but this design seems to go in the wrong direction. If you need to dynamically create record-like things, you can use some structures instead, like key-value lists, or dicts.

To cover all cases: If you have fields and values but don't necessarily have them in the correct order, you could make your function take in the result of record_info(fields, Record), with Record being the atom of the record you want to make. Then it'll have the ordered field names to work with. And a record is just a tuple with its atom name in the first slot, so you can build it that way. Here's how I build an arbitrary shallow record from a JSON string (not thoroughly tested and not optimized, but tested and working):

% Converts the given JSON string to a record
% WARNING: Only for shallow records. Won't work for nested ones!
%
% Record: The atom representing the type of record to be converted to
% RecordInfo: The result of calling record_info(fields, Record)
% JSON: The JSON string
jsonToRecord(Record, RecordInfo, JSON) ->
   JiffyList = element(1, jiffy:decode(JSON)),
   Struct = erlang:make_tuple(length(RecordInfo)+1, ""),
   Struct2 = erlang:setelement(1, Struct, Record),
   recordFromJsonList(RecordInfo, Struct2, JiffyList).

% private methods

recordFromJsonList(_RecordInfo, Struct, []) -> Struct;
recordFromJsonList(RecordInfo, Struct, [{Name, Val} | Rest]) ->
   FieldNames = atomNames(RecordInfo),
   Index = index_of(erlang:binary_to_list(Name), FieldNames),
   recordFromJsonList(RecordInfo, erlang:setelement(Index+1, Struct, Val), Rest). 

% Converts a list of atoms to a list of strings
%
% Atoms: The list of atoms
atomNames(Atoms) ->
   F = fun(Field) ->
      lists:flatten(io_lib:format("~p", [Field]))
      end,
   lists:map(F, Atoms).

% Gets the index of an item in a list (one-indexed)
%
% Item: The item to search for
% List: The list
index_of(Item, List) -> index_of(Item, List, 1).

% private helper
index_of(_, [], _)  -> not_found;
index_of(Item, [Item|_], Index) -> Index;
index_of(Item, [_|Tl], Index) -> index_of(Item, Tl, Index+1).

Brief explanation: The JSON represents some key:value pairs corresponding to field:value pairs in the record we're trying to build. We might not get the key:value pairs in the correct order, so we need the list of record fields passed in so we can insert the values into their correct positions in the tuple.