Generate type variables for polymorphic functions

src/aeso_fcode_to_fate.erl

@@ -138,16 +138,44 @@ functions_to_scode(ContractName, Functions, Options) ->
                     return := Type}} <- maps:to_list(Functions)]).
 
 function_to_scode(ContractName, Functions, _Name, Args, Body, ResType, _Options) ->
-    ArgTypes = [ type_to_scode(T) || {_, T} <- Args ],
+    {ArgTypes, ResType1} = typesig_to_scode(Args, ResType),
     SCode    = to_scode(init_env(ContractName, Functions, Args), Body),
-    {{ArgTypes, type_to_scode(ResType)}, SCode}.
+    {{ArgTypes, ResType1}, SCode}.
 
+-define(tvars, '$tvars').
+
+typesig_to_scode(Args, Res) ->
+    put(?tvars, {0, #{}}),
+    R = {[type_to_scode(T) || {_, T} <- Args], type_to_scode(Res)},
+    erase(?tvars),
+    R.
+
+type_to_scode(integer)         -> integer;
+type_to_scode(boolean)         -> boolean;
+type_to_scode(string)          -> string;
+type_to_scode(address)         -> address;
+type_to_scode(hash)            -> hash;
+type_to_scode(signature)       -> signature;
+type_to_scode(contract)        -> contract;
+type_to_scode(oracle)          -> oracle;
+type_to_scode(oracle_query)    -> oracle_query;
+type_to_scode(name)            -> name;
+type_to_scode(channel)         -> channel;
+type_to_scode(bits)            -> bits;
+type_to_scode(any)             -> any;
 type_to_scode({variant, Cons}) -> {variant, lists:map(fun(T) -> type_to_scode({tuple, T}) end, Cons)};
 type_to_scode({list, Type})    -> {list, type_to_scode(Type)};
 type_to_scode({tuple, Types})  -> {tuple, lists:map(fun type_to_scode/1, Types)};
 type_to_scode({map, Key, Val}) -> {map, type_to_scode(Key), type_to_scode(Val)};
 type_to_scode({function, _Args, _Res}) -> {tuple, [string, any]};
-type_to_scode(T)               -> T.
+type_to_scode({tvar, X}) ->
+    {I, Vars} = get(?tvars),
+    case maps:get(X, Vars, false) of
+        false ->
+            put(?tvars, {I + 1, Vars#{ X => I }}),
+            {tvar, I};
+        J -> {tvar, J}
+    end.
 
 add_default_init_function(SFuns, StateType) when StateType /= {tuple, []} ->
     %% Only add default if the type is unit.