Updated tests

src/aeso_aci.erl

@@ -264,7 +264,10 @@ decode_types(Ets) ->
 
 decode_type(#{tuple := Ets}) ->
     Ts = decode_types(Ets),
-    [$(,lists:join(",", Ts),$)];
+    case Ts of
+        [] -> ["unit"];
+        _ -> ["(", $(,lists:join(" * ", Ts),$), ")"]
+    end;
 decode_type(#{record := Efs}) ->
     Fs = decode_fields(Efs),
     [${,lists:join(",", Fs),$}];

src/aeso_ast_infer_types.erl

@@ -388,6 +388,7 @@ global_env() ->
                      {"require", Fun([Bool, String], Unit)}])
         , types = MkDefs(
                     [{"int", 0}, {"bool", 0}, {"char", 0}, {"string", 0}, {"address", 0},
+                     {"unit", {[], {alias_t, Unit}}},
                      {"hash", {[], {alias_t, Bytes(32)}}},
                      {"signature", {[], {alias_t, Bytes(64)}}},
                      {"bits", 0},
@@ -2320,8 +2321,10 @@ pp({uvar, _, Ref}) ->
     ["?u" | integer_to_list(erlang:phash2(Ref, 16384)) ];
 pp({tvar, _, Name}) ->
     Name;
+pp({tuple_t, _, []}) ->
+    "unit";
 pp({tuple_t, _, Cpts}) ->
-    ["(", pp(Cpts), ")"];
+    ["(", string:join(lists:map(fun pp/1, Cpts), " * "), ")"];
 pp({bytes_t, _, any}) -> "bytes(_)";
 pp({bytes_t, _, Len}) ->
     ["bytes(", integer_to_list(Len), ")"];

src/aeso_parser.erl

@@ -141,7 +141,7 @@ type200() ->
     ?RULE(many({fun_domain(), keyword('=>')}), type300(), fun_t(_1, _2)).
 
 type300() ->
-    ?RULE(sep1(type400(), tok('*')), tuple_t(get_ann(_1), _1)).
+    ?RULE(sep1(type400(), tok('*')), tuple_t(get_ann(lists:nth(1, _1)), _1)).
 
 type400() ->
     choice(
@@ -156,12 +156,17 @@ type400() ->
 
 typeAtom() ->
     ?LAZY_P(choice(
-    [ id(), token(con), token(qcon), token(qid), tvar()
+    [ parens(type())
+    , id(), token(con), token(qcon), token(qid), tvar()
     ])).
 
 fun_domain() -> ?LAZY_P(choice(
-    [ paren_list(type())
-    , type300()
+    [ ?RULE(tok('('), tok(')'), [])
+      %% Note avoidance of ambiguity: `(int)` can be treated as:
+      %% - literally `int`
+      %% - list of arguments with just one element – int. This approach is dropped.
+    , ?RULE(tok('('), type(), tok(','), sep1(type(), tok(',')), tok(')'), [_2|_4])
+    , ?RULE(type300(), [_1])
     ])).
 
 %% -- Statements -------------------------------------------------------------

src/aeso_pretty.erl

@@ -222,7 +222,7 @@ typedef({variant_t, Constructors}) ->
 
 -spec constructor_t(aeso_syntax:constructor_t()) -> doc().
 constructor_t({constr_t, _, C, []}) -> name(C);
-constructor_t({constr_t, _, C, Args}) -> beside(name(C), tuple_type(Args)).
+constructor_t({constr_t, _, C, Args}) -> beside(name(C), args_type(Args)).
 
 -spec field_t(aeso_syntax:field_t()) -> doc().
 field_t({field_t, _, Name, Type}) ->
@@ -234,11 +234,11 @@ type(Type, Options) ->
 
 -spec type(aeso_syntax:type()) -> doc().
 type({fun_t, _, Named, Args, Ret}) ->
-    follow(hsep(tuple_type(Named ++ Args), text("=>")), type(Ret));
+    follow(hsep(args_type(Named ++ Args), text("=>")), type(Ret));
 type({app_t, _, Type, []}) ->
     type(Type);
 type({app_t, _, Type, Args}) ->
-    beside(type(Type), tuple_type(Args));
+    beside(type(Type), args_type(Args));
 type({tuple_t, _, Args}) ->
     tuple_type(Args);
 type({bytes_t, _, any}) -> text("bytes(_)");
@@ -256,10 +256,20 @@ type(T = {con, _, _})  -> name(T);
 type(T = {qcon, _, _}) -> name(T);
 type(T = {tvar, _, _}) -> name(T).
 
--spec tuple_type([aeso_syntax:type()]) -> doc().
-tuple_type(Args) ->
+-spec args_type([aeso_syntax:type()]) -> doc().
+args_type(Args) ->
     tuple(lists:map(fun type/1, Args)).
 
+-spec tuple_type([aeso_syntax:type()]) -> doc().
+tuple_type([]) ->
+    text("unit");
+tuple_type(Factors) ->
+    beside(
+      [ text("(")
+      , par(punctuate(text(" *"), lists:map(fun type/1, Factors)), 0)
+      , text(")")
+      ]).
+
 -spec arg_expr(aeso_syntax:arg_expr()) -> doc().
 arg_expr({named_arg, _, Name, E}) ->
     follow(hsep(expr(Name), text("=")), expr(E));