Removing is_error from tests

17 files changed, 83 insertions, 71 deletions

diff --git a/gen/src/gleam@list.erl b/gen/src/gleam@list.erl
index f5b8f6d..291bd7f 100644
--- a/gen/src/gleam@list.erl
+++ b/gen/src/gleam@list.erl
@@ -232,7 +232,7 @@ strict_zip(L1, L2) ->
             {ok, zip(L1, L2)};
 
         false ->
-            {error, {}}
+            {error, length_mismatch}
     end.
 
 intersperse(List, Elem) ->
diff --git a/gen/test/gleam@atom_test.erl b/gen/test/gleam@atom_test.erl
index 84b361f..3c4355d 100644
--- a/gen/test/gleam@atom_test.erl
+++ b/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() ->
diff --git a/gen/test/gleam@float_test.erl b/gen/test/gleam@float_test.erl
index 403be9d..0f7e55b 100644
--- a/gen/test/gleam@float_test.erl
+++ b/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">>),
diff --git a/gen/test/gleam@int_test.erl b/gen/test/gleam@int_test.erl
index 1f13f1a..7cee67a 100644
--- a/gen/test/gleam@int_test.erl
+++ b/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">>),
diff --git a/gen/test/gleam@list_test.erl b/gen/test/gleam@list_test.erl
index dcb4ceb..ae1f786 100644
--- a/gen/test/gleam@list_test.erl
+++ b/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,14 +147,26 @@ 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]),
@@ -162,9 +174,9 @@ intersperse_test() ->
 
 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}).
diff --git a/gen/test/gleam@map_test.erl b/gen/test/gleam@map_test.erl
index 83a86f6..9ef0149 100644
--- a/gen/test/gleam@map_test.erl
+++ b/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(
diff --git a/src/gleam/atom.gleam b/src/gleam/atom.gleam
index 24b82d5..a5418d5 100644
--- a/src/gleam/atom.gleam
+++ b/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";
diff --git a/src/gleam/float.gleam b/src/gleam/float.gleam
index 9095ec4..441d9a0 100644
--- a/src/gleam/float.gleam
+++ b/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) {
diff --git a/src/gleam/list.gleam b/src/gleam/list.gleam
index 2df547c..ecc2a6c 100644
--- a/src/gleam/list.gleam
+++ b/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) ]
   }
 }
 
diff --git a/src/gleam/map.gleam b/src/gleam/map.gleam
index af49d5e..3330dcc 100644
--- a/src/gleam/map.gleam
+++ b/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)
diff --git a/src/gleam_stdlib.erl b/src/gleam_stdlib.erl
index 480518a..3bb762d 100644
--- a/src/gleam_stdlib.erl
+++ b/src/gleam_stdlib.erl
@@ -88,5 +88,5 @@ parse_float(String) ->
       {ok, Float};
 
     _ ->
-      {error, parse_error}
+      {error, nil}
   end.
diff --git a/test/gleam/any_test.gleam b/test/gleam/any_test.gleam
index 5fe0476..b8f9e65 100644
--- a/test/gleam/any_test.gleam
+++ b/test/gleam/any_test.gleam
@@ -72,6 +72,7 @@ pub fn float_test() {
   |> expect.equal(_, Error("Expected a Float, got `[]`"))
 }
 
+// TODO
 // pub fn atom_test() {
 //   make an atom here
 //     |> any.from
diff --git a/test/gleam/atom_test.gleam b/test/gleam/atom_test.gleam
index 861758f..1f24336 100644
--- a/test/gleam/atom_test.gleam
+++ b/test/gleam/atom_test.gleam
@@ -12,9 +12,7 @@ pub fn from_string_test() {
 
   "this is not an atom we have seen before"
   |> atom.from_string
-  // TODO
-  // |> expect.equal(_, Error(AtomNotLoaded))
-  |> expect.is_error
+  |> expect.equal(_, Error(atom.AtomNotLoaded))
 }
 
 pub fn create_from_string_test() {
diff --git a/test/gleam/float_test.gleam b/test/gleam/float_test.gleam
index a020cec..c416808 100644
--- a/test/gleam/float_test.gleam
+++ b/test/gleam/float_test.gleam
@@ -17,15 +17,15 @@ pub fn parse_test() {
 
   ""
   |> float.parse
-  |> expect.is_error
+  |> expect.equal(_, Error(Nil))
 
   "what"
   |> float.parse
-  |> expect.is_error
+  |> expect.equal(_, Error(Nil))
 
   "1"
   |> float.parse
-  |> expect.is_error
+  |> expect.equal(_, Error(Nil))
 }
 
 pub fn to_string_test() {
diff --git a/test/gleam/int_test.gleam b/test/gleam/int_test.gleam
index 3034e3b..dcfece7 100644
--- a/test/gleam/int_test.gleam
+++ b/test/gleam/int_test.gleam
@@ -31,15 +31,15 @@ pub fn parse() {
 
   ""
   |> int.parse
-  |> expect.is_error
+  |> expect.equal(_, Error(Nil))
 
   "what"
   |> int.parse
-  |> expect.is_error
+  |> expect.equal(_, Error(Nil))
 
   "1.23"
   |> int.parse
-  |> expect.is_error
+  |> expect.equal(_, Error(Nil))
 }
 
 pub fn to_base_string() {
diff --git a/test/gleam/list_test.gleam b/test/gleam/list_test.gleam
index cdb7a8d..4be1795 100644
--- a/test/gleam/list_test.gleam
+++ b/test/gleam/list_test.gleam
@@ -33,7 +33,7 @@ pub fn head_test() {
     |> expect.equal(_, Ok(0))
 
   list.head([])
-    |> expect.is_error
+    |> expect.equal(_, Error(Nil))
 }
 
 pub fn tail_test() {
@@ -44,7 +44,7 @@ pub fn tail_test() {
     |> expect.equal(_, Ok([]))
 
   list.tail([])
-    |> expect.is_error
+    |> expect.equal(_, Error(Nil))
 }
 
 pub fn filter_test() {
@@ -164,7 +164,7 @@ pub fn find_test() {
 
   [1, 3]
   |> list.find(_, f)
-  |> expect.is_error
+  |> expect.equal(_, Error(Nil))
 }
 
 pub fn all_test() {
@@ -208,19 +208,23 @@ pub fn zip_test() {
 
 pub fn strict_zip_test() {
   list.strict_zip([], [1, 2, 3])
-  |> expect.is_error
+  |> expect.equal(_, Error(list.LengthMismatch))
 
   list.strict_zip([1, 2], [])
-  |> expect.is_error
+  |> expect.equal(_, Error(list.LengthMismatch))
 
   list.strict_zip([1, 2, 3], [4, 5, 6])
-  |> expect.equal(_, Ok([pair.Pair(1, 4), pair.Pair(2, 5), pair.Pair(3, 6)]))
+  |> expect.equal(_, Ok([
+    pair.Pair(1, 4),
+    pair.Pair(2, 5),
+    pair.Pair(3, 6),
+  ]))
 
   list.strict_zip([5, 6], [1, 2, 3])
-  |> expect.is_error
+  |> expect.equal(_, Error(list.LengthMismatch))
 
   list.strict_zip([5, 6, 7], [1, 2])
-  |> expect.is_error
+  |> expect.equal(_, Error(list.LengthMismatch))
 }
 
 pub fn intersperse_test() {
@@ -236,13 +240,13 @@ pub fn at_test() {
   |> expect.equal(_, Ok(3))
 
   list.at([1, 2, 3], 5)
-  |> expect.is_error
+  |> expect.equal(_, Error(Nil))
 
   list.at([], 0)
-  |> expect.is_error
+  |> expect.equal(_, Error(Nil))
 
   list.at([1, 2, 3, 4, 5, 6], -1)
-  |> expect.is_error
+  |> expect.equal(_, Error(Nil))
 }
 
 pub fn unique_test() {
@@ -373,5 +377,5 @@ pub fn key_find_test() {
 
   proplist
   |> list.key_find(_, 2)
-  |> expect.is_error
+  |> expect.equal(_, Error(Nil))
 }
diff --git a/test/gleam/map_test.gleam b/test/gleam/map_test.gleam
index 96d648f..20e7999 100644
--- a/test/gleam/map_test.gleam
+++ b/test/gleam/map_test.gleam
@@ -70,7 +70,7 @@ pub fn fetch_test() {
 
   m
   |> map.fetch(_, 2)
-  |> expect.is_error
+  |> expect.equal(_, Error(Nil))
 }
 
 pub fn put_test() {