Removing is_error from tests

Author: lpil

gen/src/[email protected]

@@ -232,7 +232,7 @@ strict_zip(L1, L2) ->
             {ok, zip(L1, L2)};
 
         false ->
-            {error, {}}
+            {error, length_mismatch}
     end.
 
 intersperse(List, Elem) ->

gen/test/gleam@atom_test.erl

@@ -6,8 +6,9 @@
 from_string_test() ->
     gleam@expect:is_ok(gleam@atom:from_string(<<"ok">>)),
     gleam@expect:is_ok(gleam@atom:from_string(<<"expect">>)),
-    gleam@expect:is_error(
-        gleam@atom:from_string(<<"this is not an atom we have seen before">>)
+    gleam@expect:equal(
+        gleam@atom:from_string(<<"this is not an atom we have seen before">>),
+        {error, atom_not_loaded}
     ).
 
 create_from_string_test() ->

gen/test/gleam@float_test.erl

@@ -7,9 +7,9 @@ parse_test() ->
     gleam@expect:equal(gleam@float:parse(<<"1.23">>), {ok, 1.23}),
     gleam@expect:equal(gleam@float:parse(<<"5.0">>), {ok, 5.0}),
     gleam@expect:equal(gleam@float:parse(<<"0.123456789">>), {ok, 0.123456789}),
-    gleam@expect:is_error(gleam@float:parse(<<"">>)),
-    gleam@expect:is_error(gleam@float:parse(<<"what">>)),
-    gleam@expect:is_error(gleam@float:parse(<<"1">>)).
+    gleam@expect:equal(gleam@float:parse(<<"">>), {error, nil}),
+    gleam@expect:equal(gleam@float:parse(<<"what">>), {error, nil}),
+    gleam@expect:equal(gleam@float:parse(<<"1">>), {error, nil}).
 
 to_string_test() ->
     gleam@expect:equal(gleam@float:to_string(123.0), <<"123.0">>),

gen/test/gleam@int_test.erl

@@ -12,9 +12,9 @@ parse() ->
     gleam@expect:equal(gleam@int:parse(<<"123">>), {ok, 123}),
     gleam@expect:equal(gleam@int:parse(<<"-123">>), {ok, -123}),
     gleam@expect:equal(gleam@int:parse(<<"0123">>), {ok, 123}),
-    gleam@expect:is_error(gleam@int:parse(<<"">>)),
-    gleam@expect:is_error(gleam@int:parse(<<"what">>)),
-    gleam@expect:is_error(gleam@int:parse(<<"1.23">>)).
+    gleam@expect:equal(gleam@int:parse(<<"">>), {error, nil}),
+    gleam@expect:equal(gleam@int:parse(<<"what">>), {error, nil}),
+    gleam@expect:equal(gleam@int:parse(<<"1.23">>), {error, nil}).
 
 to_base_string() ->
     gleam@expect:equal(gleam@int:to_base_string(100, 16), <<"64">>),

gen/test/gleam@list_test.erl

@@ -24,12 +24,12 @@ contains_test() ->
 
 head_test() ->
     gleam@expect:equal(gleam@list:head([0, 4, 5, 7]), {ok, 0}),
-    gleam@expect:is_error(gleam@list:head([])).
+    gleam@expect:equal(gleam@list:head([]), {error, nil}).
 
 tail_test() ->
     gleam@expect:equal(gleam@list:tail([0, 4, 5, 7]), {ok, [4, 5, 7]}),
     gleam@expect:equal(gleam@list:tail([0]), {ok, []}),
-    gleam@expect:is_error(gleam@list:tail([])).
+    gleam@expect:equal(gleam@list:tail([]), {error, nil}).
 
 filter_test() ->
     gleam@expect:equal(gleam@list:filter([], fun(_) -> true end), []),
@@ -112,7 +112,7 @@ find_test() ->
         end end,
     gleam@expect:equal(gleam@list:find([1, 2, 3], F), {ok, 4}),
     gleam@expect:equal(gleam@list:find([1, 3, 2], F), {ok, 4}),
-    gleam@expect:is_error(gleam@list:find([1, 3], F)).
+    gleam@expect:equal(gleam@list:find([1, 3], F), {error, nil}).
 
 all_test() ->
     gleam@expect:equal(
@@ -147,24 +147,36 @@ zip_test() ->
     gleam@expect:equal(gleam@list:zip([5, 6, 7], [1, 2]), [{5, 1}, {6, 2}]).
 
 strict_zip_test() ->
-    gleam@expect:is_error(gleam@list:strict_zip([], [1, 2, 3])),
-    gleam@expect:is_error(gleam@list:strict_zip([1, 2], [])),
+    gleam@expect:equal(
+        gleam@list:strict_zip([], [1, 2, 3]),
+        {error, length_mismatch}
+    ),
+    gleam@expect:equal(
+        gleam@list:strict_zip([1, 2], []),
+        {error, length_mismatch}
+    ),
     gleam@expect:equal(
         gleam@list:strict_zip([1, 2, 3], [4, 5, 6]),
         {ok, [{1, 4}, {2, 5}, {3, 6}]}
     ),
-    gleam@expect:is_error(gleam@list:strict_zip([5, 6], [1, 2, 3])),
-    gleam@expect:is_error(gleam@list:strict_zip([5, 6, 7], [1, 2])).
+    gleam@expect:equal(
+        gleam@list:strict_zip([5, 6], [1, 2, 3]),
+        {error, length_mismatch}
+    ),
+    gleam@expect:equal(
+        gleam@list:strict_zip([5, 6, 7], [1, 2]),
+        {error, length_mismatch}
+    ).
 
 intersperse_test() ->
     gleam@expect:equal(gleam@list:intersperse([1, 2, 3], 4), [1, 4, 2, 4, 3]),
     gleam@expect:equal(gleam@list:intersperse([], 2), []).
 
 at_test() ->
     gleam@expect:equal(gleam@list:at([1, 2, 3], 2), {ok, 3}),
-    gleam@expect:is_error(gleam@list:at([1, 2, 3], 5)),
-    gleam@expect:is_error(gleam@list:at([], 0)),
-    gleam@expect:is_error(gleam@list:at([1, 2, 3, 4, 5, 6], -1)).
+    gleam@expect:equal(gleam@list:at([1, 2, 3], 5), {error, nil}),
+    gleam@expect:equal(gleam@list:at([], 0), {error, nil}),
+    gleam@expect:equal(gleam@list:at([1, 2, 3, 4, 5, 6], -1), {error, nil}).
 
 unique_test() ->
     gleam@expect:equal(
@@ -270,4 +282,4 @@ key_find_test() ->
     Proplist = [{0, <<"1">>}, {1, <<"2">>}],
     gleam@expect:equal(gleam@list:key_find(Proplist, 0), {ok, <<"1">>}),
     gleam@expect:equal(gleam@list:key_find(Proplist, 1), {ok, <<"2">>}),
-    gleam@expect:is_error(gleam@list:key_find(Proplist, 2)).
+    gleam@expect:equal(gleam@list:key_find(Proplist, 2), {error, nil}).

gen/test/gleam@map_test.erl

@@ -28,7 +28,7 @@ fetch_test() ->
     M = gleam@map:from_list(Proplist),
     gleam@expect:equal(gleam@map:fetch(M, 4), {ok, 0}),
     gleam@expect:equal(gleam@map:fetch(M, 1), {ok, 1}),
-    gleam@expect:is_error(gleam@map:fetch(M, 2)).
+    gleam@expect:equal(gleam@map:fetch(M, 2), {error, nil}).
 
 put_test() ->
     gleam@expect:equal(

src/gleam/atom.gleam

@@ -1,7 +1,6 @@
 pub external type Atom;
 
-pub enum AtomNotLoaded =
-  | AtomNotLoaded
+pub enum AtomNotLoaded = | AtomNotLoaded
 
 pub external fn from_string(String) -> Result(Atom, AtomNotLoaded) =
   "gleam_stdlib" "atom_from_string";

src/gleam/float.gleam

@@ -1,10 +1,7 @@
 import gleam/iodata
 import gleam/order
 
-pub enum NotAFloat =
-  | NotAFloat
-
-pub external fn parse(String) -> Result(Float, NotAFloat) =
+pub external fn parse(String) -> Result(Float, Nil) =
   "gleam_stdlib" "parse_float";
 
 pub fn to_string(f) {

src/gleam/list.gleam

@@ -2,7 +2,7 @@ import gleam/int
 import gleam/order
 import gleam/pair
 
-pub struct LengthMismatch {}
+pub enum LengthMismatch = | LengthMismatch
 
 // Using the Erlang C BIF implementation.
 //
@@ -183,9 +183,9 @@ pub fn any(list, f) {
 
 pub fn zip(l1, l2) {
   case pair.Pair(l1, l2) {
-    | pair.Pair([], _) -> []
-    | pair.Pair(_, []) -> []
-    | pair.Pair([x1 | rest1], [x2 | rest2]) -> [ pair.Pair(x1, x2) | zip(rest1, rest2) ]
+  | pair.Pair([], _) -> []
+  | pair.Pair(_, []) -> []
+  | pair.Pair([x1 | rest1], [x2 | rest2]) -> [ pair.Pair(x1, x2) | zip(rest1, rest2) ]
   }
 }
 

src/gleam/map.gleam

@@ -3,68 +3,68 @@ import gleam/result
 import gleam/list
 import gleam/pair
 
-pub external type MapDict(key, value);
+pub external type Map(key, value);
 
-pub external fn size(MapDict(k, v)) -> Int
+pub external fn size(Map(k, v)) -> Int
   = "maps" "size"
 
-pub external fn to_list(MapDict(key, value)) -> List(pair.Pair(key, value))
+pub external fn to_list(Map(key, value)) -> List(pair.Pair(key, value))
   = "maps" "to_list"
 
-pub external fn from_list(List(pair.Pair(key, value))) -> MapDict(key, value)
+pub external fn from_list(List(pair.Pair(key, value))) -> Map(key, value)
   = "maps" "from_list"
 
-external fn is_key(key, MapDict(key, v)) -> Bool
+external fn is_key(key, Map(key, v)) -> Bool
   = "maps" "is_key"
 
 pub fn has_key(map, key) {
   is_key(key, map)
 }
 
-pub external fn new() -> MapDict(key, value)
+pub external fn new() -> Map(key, value)
   = "maps" "new"
 
-pub external fn fetch(MapDict(key, value), key) -> Result(value, Nil)
+pub external fn fetch(Map(key, value), key) -> Result(value, Nil)
   = "gleam_stdlib" "map_fetch";
 
-external fn erl_put(key, value, MapDict(key, value)) -> MapDict(key, value)
+external fn erl_put(key, value, Map(key, value)) -> Map(key, value)
   = "maps" "put";
 
 pub fn put(map, key, value) {
   erl_put(key, value, map)
 }
 
-external fn erl_map_values(fn(key, value) -> value, MapDict(key, value))
-  -> MapDict(key, value)
+external fn erl_map_values(fn(key, value) -> value, Map(key, value))
+  -> Map(key, value)
   = "maps" "map";
 
 pub fn map_values(map, fun) {
   erl_map_values(fun, map)
 }
 
-pub external fn keys(MapDict(keys, v)) -> List(keys)
+pub external fn keys(Map(keys, v)) -> List(keys)
   = "maps" "keys"
 
-pub external fn values(MapDict(k, values)) -> List(values)
+pub external fn values(Map(k, values)) -> List(values)
   = "maps" "values"
 
-external fn erl_filter(fn(key, value) -> Bool, MapDict(key, value))
-  -> MapDict(key, value)
+external fn erl_filter(fn(key, value) -> Bool, Map(key, value))
+  -> Map(key, value)
   = "maps" "filter";
 
 pub fn filter(map, fun) {
   erl_filter(fun, map)
 }
 
-external fn erl_take(List(k), MapDict(k, v)) -> MapDict(k, v) = "maps" "with"
+external fn erl_take(List(k), Map(k, v)) -> Map(k, v) = "maps" "with"
 
 pub fn take(map, keys) {
   erl_take(keys, map)
 }
 
-pub external fn merge(MapDict(k, v), MapDict(k, v)) -> MapDict(k, v) = "maps" "merge"
+pub external fn merge(Map(k, v), Map(k, v)) -> Map(k, v) = "maps" "merge"
 
-external fn erl_delete(k, MapDict(k, v)) -> MapDict(k, v) = "maps" "remove"
+external fn erl_delete(k, Map(k, v)) -> Map(k, v) = "maps" "remove"
 
 pub fn delete(map, key) {
   erl_delete(key, map)