Unify tuple patterns with type vars

2 files changed, 31 insertions, 11 deletions

diff --git a/gen/any.erl b/gen/any.erl
index a29ed3d..951fab9 100644
--- a/gen/any.erl
+++ b/gen/any.erl
@@ -2,7 +2,7 @@
 -compile(no_auto_import).
 -include_lib("eunit/include/eunit.hrl").
 
--export([from/1, unsafeCoerce/1, string/1, int/1, float/1, bool/1, thunk/1, tuple/1]).
+-export([from/1, unsafeCoerce/1, string/1, int/1, float/1, bool/1, thunk/1, tuple/1, field/2]).
 
 from(A) ->
     gleam__stdlib:identity(A).
@@ -66,5 +66,29 @@ tuple_test() ->
     expect:equal(tuple(from({<<"ok">>, <<"ok">>})),
                  {ok, {from(<<"ok">>), from(<<"ok">>)}}),
     expect:is_error(tuple(from({1}))),
-    expect:is_error(tuple(from({1, 2, 3}))).
+    expect:is_error(tuple(from({1, 2, 3}))),
+    expect:equal(result:then(result:then(tuple(from({1, 2.0})),
+                                         fun(X) -> {A, B} = X,
+                                             result:map(int(A),
+                                                        fun(I) ->
+                                                            {I, B}
+                                                        end) end),
+                             fun(X) -> {A1, B1} = X,
+                                 result:map(float(B1),
+                                            fun(F) -> {A1, F} end) end),
+                 {ok, {1, 2.0}}).
+-endif.
+
+field(A, B) ->
+    gleam__stdlib:decode_field(A, B).
+
+-ifdef(TEST).
+field_test() ->
+    {ok, OkAtom} = atom:from_string(<<"ok">>),
+    expect:equal(field(from(#{}#{ok => 1}), OkAtom), {ok, from(1)}),
+    expect:equal(field(from(#{}#{ok => 3}#{earlier => 2}), OkAtom),
+                 {ok, from(3)}),
+    expect:is_error(field(from(#{}), OkAtom)),
+    expect:is_error(field(from(1), OkAtom)),
+    expect:is_error(field(from([]), [])).
 -endif.
diff --git a/gen/result.erl b/gen/result.erl
index 19d87ed..e793c6b 100644
--- a/gen/result.erl
+++ b/gen/result.erl
@@ -85,22 +85,18 @@ flatten_test() ->
 then(Result, Fun) ->
     case Result of
         {ok, X} ->
-            case Fun(X) of
-                {ok, Y} ->
-                    {ok, Y};
+            Fun(X);
 
-                {error, Y1} ->
-                    {error, Y1}
-            end;
-
-        {error, _} ->
-            Result
+        {error, E} ->
+            {error, E}
     end.
 
 -ifdef(TEST).
 then_test() ->
     expect:equal(then({error, 1}, fun(X) -> {ok, X + 1} end), {error, 1}),
     expect:equal(then({ok, 1}, fun(X) -> {ok, X + 1} end), {ok, 2}),
+    expect:equal(then({ok, 1}, fun(_) -> {ok, <<"type change">>} end),
+                 {ok, <<"type change">>}),
     expect:equal(then({ok, 1}, fun(_) -> {error, 1} end), {error, 1}).
 -endif.