Rename gleam/expect to gleam/should (#27)

32 files changed, 842 insertions, 840 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5d42a67..bc60f65 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- The `expect` module has been renamed to `should`. Functions in the module
+  starting with `is_` have been changed to `be_`.
 - The `string.replace` and `iodata.replace` `all` arguement label has been
   changed to `each`.
 - The `string` module gains `is_empty`, `join` and `concat` functions.
diff --git a/gen/src/gleam@expect.erl b/gen/src/gleam@expect.erl
deleted file mode 100644
index eb1c3d4..0000000
--- a/gen/src/gleam@expect.erl
+++ /dev/null
@@ -1,25 +0,0 @@
--module(gleam@expect).
--compile(no_auto_import).
-
--export([equal/2, not_equal/2, true/1, false/1, is_ok/1, is_error/1, fail/0]).
-
-equal(A, B) ->
-    gleam_stdlib:expect_equal(A, B).
-
-not_equal(A, B) ->
-    gleam_stdlib:expect_not_equal(A, B).
-
-true(A) ->
-    gleam_stdlib:expect_true(A).
-
-false(A) ->
-    gleam_stdlib:expect_false(A).
-
-is_ok(A) ->
-    gleam_stdlib:expect_is_ok(A).
-
-is_error(A) ->
-    gleam_stdlib:expect_is_error(A).
-
-fail() ->
-    true(false).
diff --git a/gen/src/gleam@should.erl b/gen/src/gleam@should.erl
new file mode 100644
index 0000000..21acbdf
--- /dev/null
+++ b/gen/src/gleam@should.erl
@@ -0,0 +1,25 @@
+-module(gleam@should).
+-compile(no_auto_import).
+
+-export([equal/2, not_equal/2, be_true/1, be_false/1, be_ok/1, be_error/1, fail/0]).
+
+equal(A, B) ->
+    gleam_stdlib:should_equal(A, B).
+
+not_equal(A, B) ->
+    gleam_stdlib:should_not_equal(A, B).
+
+be_true(A) ->
+    gleam_stdlib:should_be_true(A).
+
+be_false(A) ->
+    gleam_stdlib:should_be_false(A).
+
+be_ok(A) ->
+    gleam_stdlib:should_be_ok(A).
+
+be_error(A) ->
+    gleam_stdlib:should_be_error(A).
+
+fail() ->
+    be_true(false).
diff --git a/gen/test/gleam@atom_test.erl b/gen/test/gleam@atom_test.erl
index 3c4355d..da1f699 100644
--- a/gen/test/gleam@atom_test.erl
+++ b/gen/test/gleam@atom_test.erl
@@ -4,23 +4,23 @@
 -export([from_string_test/0, create_from_string_test/0, to_string_test/0]).
 
 from_string_test() ->
-    gleam@expect:is_ok(gleam@atom:from_string(<<"ok">>)),
-    gleam@expect:is_ok(gleam@atom:from_string(<<"expect">>)),
-    gleam@expect:equal(
+    gleam@should:be_ok(gleam@atom:from_string(<<"ok">>)),
+    gleam@should:be_ok(gleam@atom:from_string(<<"expect">>)),
+    gleam@should:equal(
         gleam@atom:from_string(<<"this is not an atom we have seen before">>),
         {error, atom_not_loaded}
     ).
 
 create_from_string_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         {ok, gleam@atom:create_from_string(<<"ok">>)},
         gleam@atom:from_string(<<"ok">>)
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         {ok, gleam@atom:create_from_string(<<"expect">>)},
         gleam@atom:from_string(<<"expect">>)
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         {ok,
          gleam@atom:create_from_string(
              <<"this is another atom we have not seen before">>
@@ -31,11 +31,11 @@ create_from_string_test() ->
     ).
 
 to_string_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@atom:to_string(gleam@atom:create_from_string(<<"ok">>)),
         <<"ok">>
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@atom:to_string(gleam@atom:create_from_string(<<"expect">>)),
         <<"expect">>
     ).
diff --git a/gen/test/gleam@bool_test.erl b/gen/test/gleam@bool_test.erl
index 2a47516..8f31a9d 100644
--- a/gen/test/gleam@bool_test.erl
+++ b/gen/test/gleam@bool_test.erl
@@ -4,27 +4,27 @@
 -export([negate_test/0, compare_test/0, max_test/0, min_test/0, to_int_test/0]).
 
 negate_test() ->
-    gleam@expect:false(gleam@bool:negate(true)),
-    gleam@expect:true(gleam@bool:negate(false)).
+    gleam@should:be_false(gleam@bool:negate(true)),
+    gleam@should:be_true(gleam@bool:negate(false)).
 
 compare_test() ->
-    gleam@expect:equal(gleam@bool:compare(true, true), eq),
-    gleam@expect:equal(gleam@bool:compare(true, false), gt),
-    gleam@expect:equal(gleam@bool:compare(false, false), eq),
-    gleam@expect:equal(gleam@bool:compare(false, true), lt).
+    gleam@should:equal(gleam@bool:compare(true, true), eq),
+    gleam@should:equal(gleam@bool:compare(true, false), gt),
+    gleam@should:equal(gleam@bool:compare(false, false), eq),
+    gleam@should:equal(gleam@bool:compare(false, true), lt).
 
 max_test() ->
-    gleam@expect:equal(gleam@bool:max(true, true), true),
-    gleam@expect:equal(gleam@bool:max(true, false), true),
-    gleam@expect:equal(gleam@bool:max(false, false), false),
-    gleam@expect:equal(gleam@bool:max(false, true), true).
+    gleam@should:equal(gleam@bool:max(true, true), true),
+    gleam@should:equal(gleam@bool:max(true, false), true),
+    gleam@should:equal(gleam@bool:max(false, false), false),
+    gleam@should:equal(gleam@bool:max(false, true), true).
 
 min_test() ->
-    gleam@expect:equal(gleam@bool:min(true, true), true),
-    gleam@expect:equal(gleam@bool:min(true, false), false),
-    gleam@expect:equal(gleam@bool:min(false, false), false),
-    gleam@expect:equal(gleam@bool:min(false, true), false).
+    gleam@should:equal(gleam@bool:min(true, true), true),
+    gleam@should:equal(gleam@bool:min(true, false), false),
+    gleam@should:equal(gleam@bool:min(false, false), false),
+    gleam@should:equal(gleam@bool:min(false, true), false).
 
 to_int_test() ->
-    gleam@expect:equal(gleam@bool:to_int(true), 1),
-    gleam@expect:equal(gleam@bool:to_int(false), 0).
+    gleam@should:equal(gleam@bool:to_int(true), 1),
+    gleam@should:equal(gleam@bool:to_int(false), 0).
diff --git a/gen/test/gleam@dynamic_test.erl b/gen/test/gleam@dynamic_test.erl
index 6f99980..7cd1ba4 100644
--- a/gen/test/gleam@dynamic_test.erl
+++ b/gen/test/gleam@dynamic_test.erl
@@ -4,113 +4,113 @@
 -export([string_test/0, int_test/0, float_test/0, thunk_test/0, bool_test/0, atom_test/0, list_test/0, field_test/0, element_test/0]).
 
 string_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:string(gleam@dynamic:from(<<"">>)),
         {ok, <<"">>}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:string(gleam@dynamic:from(<<"Hello">>)),
         {ok, <<"Hello">>}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:string(gleam@dynamic:from(1)),
         {error, <<"Expected a String, got `1`">>}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:string(gleam@dynamic:from([])),
         {error, <<"Expected a String, got `[]`">>}
     ).
 
 int_test() ->
-    gleam@expect:equal(gleam@dynamic:int(gleam@dynamic:from(1)), {ok, 1}),
-    gleam@expect:equal(gleam@dynamic:int(gleam@dynamic:from(2)), {ok, 2}),
-    gleam@expect:equal(
+    gleam@should:equal(gleam@dynamic:int(gleam@dynamic:from(1)), {ok, 1}),
+    gleam@should:equal(gleam@dynamic:int(gleam@dynamic:from(2)), {ok, 2}),
+    gleam@should:equal(
         gleam@dynamic:int(gleam@dynamic:from(1.0)),
         {error, <<"Expected an Int, got `1.0`">>}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:int(gleam@dynamic:from([])),
         {error, <<"Expected an Int, got `[]`">>}
     ).
 
 float_test() ->
-    gleam@expect:equal(gleam@dynamic:float(gleam@dynamic:from(1.0)), {ok, 1.0}),
-    gleam@expect:equal(gleam@dynamic:float(gleam@dynamic:from(2.2)), {ok, 2.2}),
-    gleam@expect:equal(
+    gleam@should:equal(gleam@dynamic:float(gleam@dynamic:from(1.0)), {ok, 1.0}),
+    gleam@should:equal(gleam@dynamic:float(gleam@dynamic:from(2.2)), {ok, 2.2}),
+    gleam@should:equal(
         gleam@dynamic:float(gleam@dynamic:from(1)),
         {error, <<"Expected a Float, got `1`">>}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:float(gleam@dynamic:from([])),
         {error, <<"Expected a Float, got `[]`">>}
     ).
 
 thunk_test() ->
-    gleam@expect:is_ok(gleam@dynamic:thunk(gleam@dynamic:from(fun() -> 1 end))),
-    gleam@expect:equal(
+    gleam@should:be_ok(gleam@dynamic:thunk(gleam@dynamic:from(fun() -> 1 end))),
+    gleam@should:equal(
         gleam@result:map(
             gleam@dynamic:thunk(gleam@dynamic:from(fun() -> 1 end)),
             fun(F) -> F() end
         ),
         {ok, gleam@dynamic:from(1)}
     ),
-    gleam@expect:is_error(
+    gleam@should:be_error(
         gleam@dynamic:thunk(gleam@dynamic:from(fun(X) -> X end))
     ),
-    gleam@expect:is_error(gleam@dynamic:thunk(gleam@dynamic:from(1))),
-    gleam@expect:is_error(gleam@dynamic:thunk(gleam@dynamic:from([]))).
+    gleam@should:be_error(gleam@dynamic:thunk(gleam@dynamic:from(1))),
+    gleam@should:be_error(gleam@dynamic:thunk(gleam@dynamic:from([]))).
 
 bool_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:bool(gleam@dynamic:from(true)),
         {ok, true}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:bool(gleam@dynamic:from(false)),
         {ok, false}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:bool(gleam@dynamic:from(1)),
         {error, <<"Expected a Bool, got `1`">>}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:bool(gleam@dynamic:from([])),
         {error, <<"Expected a Bool, got `[]`">>}
     ).
 
 atom_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:atom(
             gleam@dynamic:from(gleam@atom:create_from_string(<<"">>))
         ),
         {ok, gleam@atom:create_from_string(<<"">>)}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:atom(
             gleam@dynamic:from(gleam@atom:create_from_string(<<"ok">>))
         ),
         {ok, gleam@atom:create_from_string(<<"ok">>)}
     ),
-    gleam@expect:is_error(gleam@dynamic:atom(gleam@dynamic:from(1))),
-    gleam@expect:is_error(gleam@dynamic:atom(gleam@dynamic:from([]))).
+    gleam@should:be_error(gleam@dynamic:atom(gleam@dynamic:from(1))),
+    gleam@should:be_error(gleam@dynamic:atom(gleam@dynamic:from([]))).
 
 list_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:list(gleam@dynamic:from([]), fun gleam@dynamic:string/1),
         {ok, []}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:list(gleam@dynamic:from([]), fun gleam@dynamic:int/1),
         {ok, []}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:list(
             gleam@dynamic:from([1, 2, 3]),
             fun gleam@dynamic:int/1
         ),
         {ok, [1, 2, 3]}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:list(
             gleam@dynamic:from([[1], [2], [3]]),
             fun(Capture1) ->
@@ -119,19 +119,19 @@ list_test() ->
         ),
         {ok, [[1], [2], [3]]}
     ),
-    gleam@expect:is_error(
+    gleam@should:be_error(
         gleam@dynamic:list(gleam@dynamic:from(1), fun gleam@dynamic:string/1)
     ),
-    gleam@expect:is_error(
+    gleam@should:be_error(
         gleam@dynamic:list(gleam@dynamic:from(1.0), fun gleam@dynamic:int/1)
     ),
-    gleam@expect:is_error(
+    gleam@should:be_error(
         gleam@dynamic:list(
             gleam@dynamic:from([<<"">>]),
             fun gleam@dynamic:int/1
         )
     ),
-    gleam@expect:is_error(
+    gleam@should:be_error(
         gleam@dynamic:list(
             gleam@dynamic:from(
                 [gleam@dynamic:from(1), gleam@dynamic:from(<<"not an int">>)]
@@ -143,14 +143,14 @@ list_test() ->
 field_test() ->
     {ok, OkAtom} = gleam@atom:from_string(<<"ok">>),
     {ok, ErrorAtom} = gleam@atom:from_string(<<"error">>),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:field(
             gleam@dynamic:from(gleam@map:insert(gleam@map:new(), OkAtom, 1)),
             OkAtom
         ),
         {ok, gleam@dynamic:from(1)}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:field(
             gleam@dynamic:from(
                 gleam@map:insert(
@@ -163,31 +163,31 @@ field_test() ->
         ),
         {ok, gleam@dynamic:from(3)}
     ),
-    gleam@expect:is_error(
+    gleam@should:be_error(
         gleam@dynamic:field(gleam@dynamic:from(gleam@map:new()), OkAtom)
     ),
-    gleam@expect:is_error(gleam@dynamic:field(gleam@dynamic:from(1), OkAtom)),
-    gleam@expect:is_error(gleam@dynamic:field(gleam@dynamic:from([]), [])).
+    gleam@should:be_error(gleam@dynamic:field(gleam@dynamic:from(1), OkAtom)),
+    gleam@should:be_error(gleam@dynamic:field(gleam@dynamic:from([]), [])).
 
 element_test() ->
     {ok, OkAtom} = gleam@atom:from_string(<<"ok">>),
     OkOneTuple = {OkAtom, 1},
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:element(gleam@dynamic:from(OkOneTuple), 0),
         {ok, gleam@dynamic:from(OkAtom)}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@dynamic:element(gleam@dynamic:from(OkOneTuple), 1),
         {ok, gleam@dynamic:from(1)}
     ),
-    gleam@expect:is_error(
+    gleam@should:be_error(
         gleam@dynamic:element(gleam@dynamic:from(OkOneTuple), 2)
     ),
-    gleam@expect:is_error(
+    gleam@should:be_error(
         gleam@dynamic:element(gleam@dynamic:from(OkOneTuple), -1)
     ),
-    gleam@expect:is_error(gleam@dynamic:element(gleam@dynamic:from(1), 0)),
-    gleam@expect:is_error(
+    gleam@should:be_error(gleam@dynamic:element(gleam@dynamic:from(1), 0)),
+    gleam@should:be_error(
         gleam@dynamic:element(
             gleam@dynamic:from(gleam@map:insert(gleam@map:new(), 1, OkAtom)),
             0
diff --git a/gen/test/gleam@float_test.erl b/gen/test/gleam@float_test.erl
index 8926ce1..f84f468 100644
--- a/gen/test/gleam@float_test.erl
+++ b/gen/test/gleam@float_test.erl
@@ -4,65 +4,65 @@
 -export([parse_test/0, to_string_test/0, compare_test/0, ceiling_test/0, floor_test/0, round_test/0, truncate_test/0, min_test/0, max_test/0]).
 
 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:equal(gleam@float:parse(<<"">>), {error, nil}),
-    gleam@expect:equal(gleam@float:parse(<<"what">>), {error, nil}),
-    gleam@expect:equal(gleam@float:parse(<<"1">>), {error, nil}).
+    gleam@should:equal(gleam@float:parse(<<"1.23">>), {ok, 1.23}),
+    gleam@should:equal(gleam@float:parse(<<"5.0">>), {ok, 5.0}),
+    gleam@should:equal(gleam@float:parse(<<"0.123456789">>), {ok, 0.123456789}),
+    gleam@should:equal(gleam@float:parse(<<"">>), {error, nil}),
+    gleam@should:equal(gleam@float:parse(<<"what">>), {error, nil}),
+    gleam@should:equal(gleam@float:parse(<<"1">>), {error, nil}).
 
 to_string_test() ->
-    gleam@expect:equal(gleam@float:to_string(123.0), <<"123.0">>),
-    gleam@expect:equal(gleam@float:to_string(-8.1), <<"-8.1">>).
+    gleam@should:equal(gleam@float:to_string(123.0), <<"123.0">>),
+    gleam@should:equal(gleam@float:to_string(-8.1), <<"-8.1">>).
 
 compare_test() ->
-    gleam@expect:equal(gleam@float:compare(0.0, 0.0), eq),
-    gleam@expect:equal(gleam@float:compare(0.1, 0.1), eq),
-    gleam@expect:equal(gleam@float:compare(0.0, 0.1), lt),
-    gleam@expect:equal(gleam@float:compare(-2.0, -1.9), lt),
-    gleam@expect:equal(gleam@float:compare(2.0, 1.9), gt),
-    gleam@expect:equal(gleam@float:compare(-1.9, -2.0), gt).
+    gleam@should:equal(gleam@float:compare(0.0, 0.0), eq),
+    gleam@should:equal(gleam@float:compare(0.1, 0.1), eq),
+    gleam@should:equal(gleam@float:compare(0.0, 0.1), lt),
+    gleam@should:equal(gleam@float:compare(-2.0, -1.9), lt),
+    gleam@should:equal(gleam@float:compare(2.0, 1.9), gt),
+    gleam@should:equal(gleam@float:compare(-1.9, -2.0), gt).
 
 ceiling_test() ->
-    gleam@expect:equal(gleam@float:ceiling(8.1), 9.0),
-    gleam@expect:equal(gleam@float:ceiling(-8.1), -8.0),
-    gleam@expect:equal(gleam@float:ceiling(-8.0), -8.0).
+    gleam@should:equal(gleam@float:ceiling(8.1), 9.0),
+    gleam@should:equal(gleam@float:ceiling(-8.1), -8.0),
+    gleam@should:equal(gleam@float:ceiling(-8.0), -8.0).
 
 floor_test() ->
-    gleam@expect:equal(gleam@float:floor(8.1), 8.0),
-    gleam@expect:equal(gleam@float:floor(-8.1), -9.0),
-    gleam@expect:equal(gleam@float:floor(-8.0), -8.0).
+    gleam@should:equal(gleam@float:floor(8.1), 8.0),
+    gleam@should:equal(gleam@float:floor(-8.1), -9.0),
+    gleam@should:equal(gleam@float:floor(-8.0), -8.0).
 
 round_test() ->
-    gleam@expect:equal(gleam@float:round(8.1), 8),
-    gleam@expect:equal(gleam@float:round(8.4), 8),
-    gleam@expect:equal(gleam@float:round(8.499), 8),
-    gleam@expect:equal(gleam@float:round(8.5), 9),
-    gleam@expect:equal(gleam@float:round(-8.1), -8),
-    gleam@expect:equal(gleam@float:round(-7.5), -8).
+    gleam@should:equal(gleam@float:round(8.1), 8),
+    gleam@should:equal(gleam@float:round(8.4), 8),
+    gleam@should:equal(gleam@float:round(8.499), 8),
+    gleam@should:equal(gleam@float:round(8.5), 9),
+    gleam@should:equal(gleam@float:round(-8.1), -8),
+    gleam@should:equal(gleam@float:round(-7.5), -8).
 
 truncate_test() ->
-    gleam@expect:equal(gleam@float:truncate(8.1), 8),
-    gleam@expect:equal(gleam@float:truncate(8.4), 8),
-    gleam@expect:equal(gleam@float:truncate(8.499), 8),
-    gleam@expect:equal(gleam@float:truncate(8.5), 8),
-    gleam@expect:equal(gleam@float:truncate(-8.1), -8),
-    gleam@expect:equal(gleam@float:truncate(-7.5), -7).
+    gleam@should:equal(gleam@float:truncate(8.1), 8),
+    gleam@should:equal(gleam@float:truncate(8.4), 8),
+    gleam@should:equal(gleam@float:truncate(8.499), 8),
+    gleam@should:equal(gleam@float:truncate(8.5), 8),
+    gleam@should:equal(gleam@float:truncate(-8.1), -8),
+    gleam@should:equal(gleam@float:truncate(-7.5), -7).
 
 min_test() ->
-    gleam@expect:equal(gleam@float:min(0.0, 0.0), 0.0),
-    gleam@expect:equal(gleam@float:min(0.3, 1.5), 0.3),
-    gleam@expect:equal(gleam@float:min(1.0, 0.0), 0.0),
-    gleam@expect:equal(gleam@float:min(-1.7, 2.5), -1.7),
-    gleam@expect:equal(gleam@float:min(-2.2, -2.2), -2.2),
-    gleam@expect:equal(gleam@float:min(-1.0, -1.0), -1.0),
-    gleam@expect:equal(gleam@float:min(-1.1, -1.0), -1.1).
+    gleam@should:equal(gleam@float:min(0.0, 0.0), 0.0),
+    gleam@should:equal(gleam@float:min(0.3, 1.5), 0.3),
+    gleam@should:equal(gleam@float:min(1.0, 0.0), 0.0),
+    gleam@should:equal(gleam@float:min(-1.7, 2.5), -1.7),
+    gleam@should:equal(gleam@float:min(-2.2, -2.2), -2.2),
+    gleam@should:equal(gleam@float:min(-1.0, -1.0), -1.0),
+    gleam@should:equal(gleam@float:min(-1.1, -1.0), -1.1).
 
 max_test() ->
-    gleam@expect:equal(gleam@float:max(0.0, 0.0), 0.0),
-    gleam@expect:equal(gleam@float:max(0.3, 1.5), 1.5),
-    gleam@expect:equal(gleam@float:max(1.0, 0.0), 1.0),
-    gleam@expect:equal(gleam@float:max(-1.7, 2.5), 2.5),
-    gleam@expect:equal(gleam@float:max(-2.2, -2.2), -2.2),
-    gleam@expect:equal(gleam@float:max(-1.0, -1.0), -1.0),
-    gleam@expect:equal(gleam@float:max(-1.1, -1.0), -1.0).
+    gleam@should:equal(gleam@float:max(0.0, 0.0), 0.0),
+    gleam@should:equal(gleam@float:max(0.3, 1.5), 1.5),
+    gleam@should:equal(gleam@float:max(1.0, 0.0), 1.0),
+    gleam@should:equal(gleam@float:max(-1.7, 2.5), 2.5),
+    gleam@should:equal(gleam@float:max(-2.2, -2.2), -2.2),
+    gleam@should:equal(gleam@float:max(-1.0, -1.0), -1.0),
+    gleam@should:equal(gleam@float:max(-1.1, -1.0), -1.0).
diff --git a/gen/test/gleam@function_test.erl b/gen/test/gleam@function_test.erl
index 58f6a57..ecac21f 100644
--- a/gen/test/gleam@function_test.erl
+++ b/gen/test/gleam@function_test.erl
@@ -7,7 +7,7 @@ compose_test() ->
     AddTwo = fun(Int) -> Int + 2 end,
     AddThree = fun(Int1) -> Int1 + 3 end,
     AddFive = gleam@function:compose(AddTwo, AddThree),
-    gleam@expect:equal(AddFive(1), 6),
+    gleam@should:equal(AddFive(1), 6),
     HeadToString = gleam@function:compose(
         gleam@function:compose(
             fun gleam@list:head/1,
@@ -15,8 +15,8 @@ compose_test() ->
         ),
         fun gleam@int:to_string/1
     ),
-    gleam@expect:equal(HeadToString([1]), <<"1">>),
-    gleam@expect:equal(HeadToString([]), <<"0">>).
+    gleam@should:equal(HeadToString([1]), <<"1">>),
+    gleam@should:equal(HeadToString([]), <<"0">>).
 
 flip_test() ->
     Fun = fun(S, I) ->
@@ -32,14 +32,14 @@ flip_test() ->
         )
     end,
     FlippedFun = gleam@function:flip(Fun),
-    gleam@expect:equal(Fun(<<"Bob">>, 1), <<"String: 'Bob', Int: '1'">>),
-    gleam@expect:equal(
+    gleam@should:equal(Fun(<<"Bob">>, 1), <<"String: 'Bob', Int: '1'">>),
+    gleam@should:equal(
         FlippedFun(2, <<"Alice">>),
         <<"String: 'Alice', Int: '2'">>
     ).
 
 identity_test() ->
-    gleam@expect:equal(gleam@function:identity(1), 1),
-    gleam@expect:equal(gleam@function:identity(<<"">>), <<"">>),
-    gleam@expect:equal(gleam@function:identity([]), []),
-    gleam@expect:equal(gleam@function:identity({1, 2.0}), {1, 2.0}).
+    gleam@should:equal(gleam@function:identity(1), 1),
+    gleam@should:equal(gleam@function:identity(<<"">>), <<"">>),
+    gleam@should:equal(gleam@function:identity([]), []),
+    gleam@should:equal(gleam@function:identity({1, 2.0}), {1, 2.0}).
diff --git a/gen/test/gleam@int_test.erl b/gen/test/gleam@int_test.erl
index 83f946b..1a6c8c2 100644
--- a/gen/test/gleam@int_test.erl
+++ b/gen/test/gleam@int_test.erl
@@ -4,60 +4,60 @@
 -export([to_string/0, parse/0, to_base_string/0, compare_test/0, min_test/0, max_test/0, is_even_test/0, is_odd_test/0]).
 
 to_string() ->
-    gleam@expect:equal(gleam@int:to_string(123), <<"123">>),
-    gleam@expect:equal(gleam@int:to_string(-123), <<"-123">>),
-    gleam@expect:equal(gleam@int:to_string(123), <<"123">>).
+    gleam@should:equal(gleam@int:to_string(123), <<"123">>),
+    gleam@should:equal(gleam@int:to_string(-123), <<"-123">>),
+    gleam@should:equal(gleam@int:to_string(123), <<"123">>).
 
 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: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}).
+    gleam@should:equal(gleam@int:parse(<<"123">>), {ok, 123}),
+    gleam@should:equal(gleam@int:parse(<<"-123">>), {ok, -123}),
+    gleam@should:equal(gleam@int:parse(<<"0123">>), {ok, 123}),
+    gleam@should:equal(gleam@int:parse(<<"">>), {error, nil}),
+    gleam@should:equal(gleam@int:parse(<<"what">>), {error, nil}),
+    gleam@should:equal(gleam@int:parse(<<"1.23">>), {error, nil}).
 
 to_base_string() ->
-    gleam@expect:equal(gleam@int:to_base_string(100, 16), <<"64">>),
-    gleam@expect:equal(gleam@int:to_base_string(-100, 16), <<"-64">>).
+    gleam@should:equal(gleam@int:to_base_string(100, 16), <<"64">>),
+    gleam@should:equal(gleam@int:to_base_string(-100, 16), <<"-64">>).
 
 compare_test() ->
-    gleam@expect:equal(gleam@int:compare(0, 0), eq),
-    gleam@expect:equal(gleam@int:compare(1, 1), eq),
-    gleam@expect:equal(gleam@int:compare(0, 1), lt),
-    gleam@expect:equal(gleam@int:compare(-2, -1), lt),
-    gleam@expect:equal(gleam@int:compare(2, 1), gt),
-    gleam@expect:equal(gleam@int:compare(-1, -2), gt).
+    gleam@should:equal(gleam@int:compare(0, 0), eq),
+    gleam@should:equal(gleam@int:compare(1, 1), eq),
+    gleam@should:equal(gleam@int:compare(0, 1), lt),
+    gleam@should:equal(gleam@int:compare(-2, -1), lt),
+    gleam@should:equal(gleam@int:compare(2, 1), gt),
+    gleam@should:equal(gleam@int:compare(-1, -2), gt).
 
 min_test() ->
-    gleam@expect:equal(gleam@int:min(0, 0), 0),
-    gleam@expect:equal(gleam@int:min(0, 1), 0),
-    gleam@expect:equal(gleam@int:min(1, 0), 0),
-    gleam@expect:equal(gleam@int:min(-1, 2), -1),
-    gleam@expect:equal(gleam@int:min(2, -2), -2),
-    gleam@expect:equal(gleam@int:min(-1, -1), -1).
+    gleam@should:equal(gleam@int:min(0, 0), 0),
+    gleam@should:equal(gleam@int:min(0, 1), 0),
+    gleam@should:equal(gleam@int:min(1, 0), 0),
+    gleam@should:equal(gleam@int:min(-1, 2), -1),
+    gleam@should:equal(gleam@int:min(2, -2), -2),
+    gleam@should:equal(gleam@int:min(-1, -1), -1).
 
 max_test() ->
-    gleam@expect:equal(gleam@int:max(0, 0), 0),
-    gleam@expect:equal(gleam@int:max(0, 1), 1),
-    gleam@expect:equal(gleam@int:max(1, 0), 1),
-    gleam@expect:equal(gleam@int:max(-1, 2), 2),
-    gleam@expect:equal(gleam@int:max(2, -2), 2),
-    gleam@expect:equal(gleam@int:max(-1, -1), -1).
+    gleam@should:equal(gleam@int:max(0, 0), 0),
+    gleam@should:equal(gleam@int:max(0, 1), 1),
+    gleam@should:equal(gleam@int:max(1, 0), 1),
+    gleam@should:equal(gleam@int:max(-1, 2), 2),
+    gleam@should:equal(gleam@int:max(2, -2), 2),
+    gleam@should:equal(gleam@int:max(-1, -1), -1).
 
 is_even_test() ->
-    gleam@expect:true(gleam@int:is_even(0)),
-    gleam@expect:true(gleam@int:is_even(2)),
-    gleam@expect:true(gleam@int:is_even(-2)),
-    gleam@expect:true(gleam@int:is_even(10006)),
-    gleam@expect:false(gleam@int:is_even(1)),
-    gleam@expect:false(gleam@int:is_even(-3)),
-    gleam@expect:false(gleam@int:is_even(10005)).
+    gleam@should:be_true(gleam@int:is_even(0)),
+    gleam@should:be_true(gleam@int:is_even(2)),
+    gleam@should:be_true(gleam@int:is_even(-2)),
+    gleam@should:be_true(gleam@int:is_even(10006)),
+    gleam@should:be_false(gleam@int:is_even(1)),
+    gleam@should:be_false(gleam@int:is_even(-3)),
+    gleam@should:be_false(gleam@int:is_even(10005)).
 
 is_odd_test() ->
-    gleam@expect:false(gleam@int:is_odd(0)),
-    gleam@expect:false(gleam@int:is_odd(2)),
-    gleam@expect:false(gleam@int:is_odd(-2)),
-    gleam@expect:false(gleam@int:is_odd(10006)),
-    gleam@expect:true(gleam@int:is_odd(1)),
-    gleam@expect:true(gleam@int:is_odd(-3)),
-    gleam@expect:true(gleam@int:is_odd(10005)).
+    gleam@should:be_false(gleam@int:is_odd(0)),
+    gleam@should:be_false(gleam@int:is_odd(2)),
+    gleam@should:be_false(gleam@int:is_odd(-2)),
+    gleam@should:be_false(gleam@int:is_odd(10006)),
+    gleam@should:be_true(gleam@int:is_odd(1)),
+    gleam@should:be_true(gleam@int:is_odd(-3)),
+    gleam@should:be_true(gleam@int:is_odd(10005)).
diff --git a/gen/test/gleam@iodata_test.erl b/gen/test/gleam@iodata_test.erl
index 8d8e989..63cec0b 100644
--- a/gen/test/gleam@iodata_test.erl
+++ b/gen/test/gleam@iodata_test.erl
@@ -11,8 +11,8 @@ iodata_test() ->
         ),
         <<"H">>
     ),
-    gleam@expect:equal(gleam@iodata:to_string(Data), <<"Hello, world!">>),
-    gleam@expect:equal(gleam@iodata:byte_size(Data), 13),
+    gleam@should:equal(gleam@iodata:to_string(Data), <<"Hello, world!">>),
+    gleam@should:equal(gleam@iodata:byte_size(Data), 13),
     Data1 = gleam@iodata:prepend_iodata(
         gleam@iodata:append_iodata(
             gleam@iodata:append_iodata(
@@ -25,11 +25,11 @@ iodata_test() ->
         ),
         gleam@iodata:new(<<"H">>)
     ),
-    gleam@expect:equal(gleam@iodata:to_string(Data1), <<"Hello, world!">>),
-    gleam@expect:equal(gleam@iodata:byte_size(Data1), 13).
+    gleam@should:equal(gleam@iodata:to_string(Data1), <<"Hello, world!">>),
+    gleam@should:equal(gleam@iodata:byte_size(Data1), 13).
 
 lowercase_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@iodata:to_string(
             gleam@iodata:lowercase(
                 gleam@iodata:from_strings([<<"Gleam">>, <<"Gleam">>])
@@ -39,7 +39,7 @@ lowercase_test() ->
     ).
 
 uppercase_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@iodata:to_string(
             gleam@iodata:uppercase(
                 gleam@iodata:from_strings([<<"Gleam">>, <<"Gleam">>])
@@ -49,13 +49,13 @@ uppercase_test() ->
     ).
 
 split_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@iodata:split(gleam@iodata:new(<<"Gleam,Erlang,Elixir">>), <<",">>),
         [gleam@iodata:new(<<"Gleam">>),
          gleam@iodata:new(<<"Erlang">>),
          gleam@iodata:new(<<"Elixir">>)]
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@iodata:split(
             gleam@iodata:from_strings([<<"Gleam, Erl">>, <<"ang,Elixir">>]),
             <<", ">>
@@ -65,19 +65,19 @@ split_test() ->
     ).
 
 is_equal_test() ->
-    gleam@expect:true(
+    gleam@should:be_true(
         gleam@iodata:is_equal(
             gleam@iodata:new(<<"12">>),
             gleam@iodata:from_strings([<<"1">>, <<"2">>])
         )
     ),
-    gleam@expect:true(
+    gleam@should:be_true(
         gleam@iodata:is_equal(
             gleam@iodata:new(<<"12">>),
             gleam@iodata:new(<<"12">>)
         )
     ),
-    gleam@expect:false(
+    gleam@should:be_false(
         gleam@iodata:is_equal(
             gleam@iodata:new(<<"12">>),
             gleam@iodata:new(<<"2">>)
@@ -85,9 +85,9 @@ is_equal_test() ->
     ).
 
 is_empty_test() ->
-    gleam@expect:true(gleam@iodata:is_empty(gleam@iodata:new(<<"">>))),
-    gleam@expect:false(gleam@iodata:is_empty(gleam@iodata:new(<<"12">>))),
-    gleam@expect:true(gleam@iodata:is_empty(gleam@iodata:from_strings([]))),
-    gleam@expect:true(
+    gleam@should:be_true(gleam@iodata:is_empty(gleam@iodata:new(<<"">>))),
+    gleam@should:be_false(gleam@iodata:is_empty(gleam@iodata:new(<<"12">>))),
+    gleam@should:be_true(gleam@iodata:is_empty(gleam@iodata:from_strings([]))),
+    gleam@should:be_true(
         gleam@iodata:is_empty(gleam@iodata:from_strings([<<"">>, <<"">>]))
     ).
diff --git a/gen/test/gleam@list_test.erl b/gen/test/gleam@list_test.erl
index 99f6ec0..5f6fcfb 100644
--- a/gen/test/gleam@list_test.erl
+++ b/gen/test/gleam@list_test.erl
@@ -4,51 +4,51 @@
 -export([length_test/0, reverse_test/0, is_empty_test/0, contains_test/0, head_test/0, tail_test/0, filter_test/0, map_test/0, traverse_test/0, drop_test/0, take_test/0, new_test/0, append_test/0, flatten_test/0, fold_test/0, fold_right_test/0, find_map_test/0, find_test/0, all_test/0, any_test/0, zip_test/0, strict_zip_test/0, intersperse_test/0, at_test/0, unique_test/0, sort_test/0, index_map_test/0, range_test/0, repeat_test/0, split_test/0, split_while_test/0, key_find_test/0]).
 
 length_test() ->
-    gleam@expect:equal(gleam@list:length([]), 0),
-    gleam@expect:equal(gleam@list:length([1]), 1),
-    gleam@expect:equal(gleam@list:length([1, 1]), 2),
-    gleam@expect:equal(gleam@list:length([1, 1, 1]), 3).
+    gleam@should:equal(gleam@list:length([]), 0),
+    gleam@should:equal(gleam@list:length([1]), 1),
+    gleam@should:equal(gleam@list:length([1, 1]), 2),
+    gleam@should:equal(gleam@list:length([1, 1, 1]), 3).
 
 reverse_test() ->
-    gleam@expect:equal(gleam@list:reverse([]), []),
-    gleam@expect:equal(gleam@list:reverse([1, 2, 3, 4, 5]), [5, 4, 3, 2, 1]).
+    gleam@should:equal(gleam@list:reverse([]), []),
+    gleam@should:equal(gleam@list:reverse([1, 2, 3, 4, 5]), [5, 4, 3, 2, 1]).
 
 is_empty_test() ->
-    gleam@expect:true(gleam@list:is_empty([])),
-    gleam@expect:false(gleam@list:is_empty([1])).
+    gleam@should:be_true(gleam@list:is_empty([])),
+    gleam@should:be_false(gleam@list:is_empty([1])).
 
 contains_test() ->
-    gleam@expect:true(gleam@list:contains([0, 4, 5, 1], 1)),
-    gleam@expect:false(gleam@list:contains([0, 4, 5, 7], 1)),
-    gleam@expect:false(gleam@list:contains([], 1)).
+    gleam@should:be_true(gleam@list:contains([0, 4, 5, 1], 1)),
+    gleam@should:be_false(gleam@list:contains([0, 4, 5, 7], 1)),
+    gleam@should:be_false(gleam@list:contains([], 1)).
 
 head_test() ->
-    gleam@expect:equal(gleam@list:head([0, 4, 5, 7]), {ok, 0}),
-    gleam@expect:equal(gleam@list:head([]), {error, nil}).
+    gleam@should:equal(gleam@list:head([0, 4, 5, 7]), {ok, 0}),
+    gleam@should: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:equal(gleam@list:tail([]), {error, nil}).
+    gleam@should:equal(gleam@list:tail([0, 4, 5, 7]), {ok, [4, 5, 7]}),
+    gleam@should:equal(gleam@list:tail([0]), {ok, []}),
+    gleam@should:equal(gleam@list:tail([]), {error, nil}).
 
 filter_test() ->
-    gleam@expect:equal(gleam@list:filter([], fun(_) -> true end), []),
-    gleam@expect:equal(
+    gleam@should:equal(gleam@list:filter([], fun(_) -> true end), []),
+    gleam@should:equal(
         gleam@list:filter([0, 4, 5, 7, 3], fun(_) -> true end),
         [0, 4, 5, 7, 3]
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:filter([0, 4, 5, 7, 3], fun(X) -> X > 4 end),
         [5, 7]
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:filter([0, 4, 5, 7, 3], fun(X1) -> X1 < 4 end),
         [0, 3]
     ).
 
 map_test() ->
-    gleam@expect:equal(gleam@list:map([], fun(X) -> X * 2 end), []),
-    gleam@expect:equal(
+    gleam@should:equal(gleam@list:map([], fun(X) -> X * 2 end), []),
+    gleam@should:equal(
         gleam@list:map([0, 4, 5, 7, 3], fun(X1) -> X1 * 2 end),
         [0, 8, 10, 14, 6]
     ).
@@ -61,43 +61,43 @@ traverse_test() ->
             false ->
                 {error, X}
         end end,
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:traverse([5, 6, 5, 6], Fun),
         {ok, [10, 12, 10, 12]}
     ),
-    gleam@expect:equal(gleam@list:traverse([4, 6, 5, 7, 3], Fun), {error, 7}).
+    gleam@should:equal(gleam@list:traverse([4, 6, 5, 7, 3], Fun), {error, 7}).
 
 drop_test() ->
-    gleam@expect:equal(gleam@list:drop([], 5), []),
-    gleam@expect:equal(gleam@list:drop([1, 2, 3, 4, 5, 6, 7, 8], 5), [6, 7, 8]).
+    gleam@should:equal(gleam@list:drop([], 5), []),
+    gleam@should:equal(gleam@list:drop([1, 2, 3, 4, 5, 6, 7, 8], 5), [6, 7, 8]).
 
 take_test() ->
-    gleam@expect:equal(gleam@list:take([], 5), []),
-    gleam@expect:equal(
+    gleam@should:equal(gleam@list:take([], 5), []),
+    gleam@should:equal(
         gleam@list:take([1, 2, 3, 4, 5, 6, 7, 8], 5),
         [1, 2, 3, 4, 5]
     ).
 
 new_test() ->
-    gleam@expect:equal(gleam@list:new(), []).
+    gleam@should:equal(gleam@list:new(), []).
 
 append_test() ->
-    gleam@expect:equal(gleam@list:append([1], [2, 3]), [1, 2, 3]).
+    gleam@should:equal(gleam@list:append([1], [2, 3]), [1, 2, 3]).
 
 flatten_test() ->
-    gleam@expect:equal(gleam@list:flatten([]), []),
-    gleam@expect:equal(gleam@list:flatten([[]]), []),
-    gleam@expect:equal(gleam@list:flatten([[], [], []]), []),
-    gleam@expect:equal(gleam@list:flatten([[1, 2], [], [3, 4]]), [1, 2, 3, 4]).
+    gleam@should:equal(gleam@list:flatten([]), []),
+    gleam@should:equal(gleam@list:flatten([[]]), []),
+    gleam@should:equal(gleam@list:flatten([[], [], []]), []),
+    gleam@should:equal(gleam@list:flatten([[1, 2], [], [3, 4]]), [1, 2, 3, 4]).
 
 fold_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:fold([1, 2, 3], [], fun(X, Acc) -> [X | Acc] end),
         [3, 2, 1]
     ).
 
 fold_right_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:fold_right([1, 2, 3], [], fun(X, Acc) -> [X | Acc] end),
         [1, 2, 3]
     ).
@@ -110,182 +110,182 @@ find_map_test() ->
             _ ->
                 {error, nil}
         end end,
-    gleam@expect:equal(gleam@list:find_map([1, 2, 3], F), {ok, 4}),
-    gleam@expect:equal(gleam@list:find_map([1, 3, 2], F), {ok, 4}),
-    gleam@expect:equal(gleam@list:find_map([1, 3], F), {error, nil}).
+    gleam@should:equal(gleam@list:find_map([1, 2, 3], F), {ok, 4}),
+    gleam@should:equal(gleam@list:find_map([1, 3, 2], F), {ok, 4}),
+    gleam@should:equal(gleam@list:find_map([1, 3], F), {error, nil}).
 
 find_test() ->
     IsTwo = fun(X) -> X =:= 2 end,
-    gleam@expect:equal(gleam@list:find([1, 2, 3], IsTwo), {ok, 2}),
-    gleam@expect:equal(gleam@list:find([1, 3, 2], IsTwo), {ok, 2}),
-    gleam@expect:equal(gleam@list:find([1, 3], IsTwo), {error, nil}).
+    gleam@should:equal(gleam@list:find([1, 2, 3], IsTwo), {ok, 2}),
+    gleam@should:equal(gleam@list:find([1, 3, 2], IsTwo), {ok, 2}),
+    gleam@should:equal(gleam@list:find([1, 3], IsTwo), {error, nil}).
 
 all_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:all([1, 2, 3, 4, 5], fun(X) -> X > 0 end),
         true
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:all([1, 2, 3, 4, 5], fun(X1) -> X1 < 0 end),
         false
     ),
-    gleam@expect:equal(gleam@list:all([], fun(_) -> false end), true).
+    gleam@should:equal(gleam@list:all([], fun(_) -> false end), true).
 
 any_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:any([1, 2, 3, 4, 5], fun(X) -> X =:= 2 end),
         true
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:any([1, 2, 3, 4, 5], fun(X1) -> X1 < 0 end),
         false
     ),
-    gleam@expect:equal(gleam@list:any([], fun(_) -> false end), false).
+    gleam@should:equal(gleam@list:any([], fun(_) -> false end), false).
 
 zip_test() ->
-    gleam@expect:equal(gleam@list:zip([], [1, 2, 3]), []),
-    gleam@expect:equal(gleam@list:zip([1, 2], []), []),
-    gleam@expect:equal(
+    gleam@should:equal(gleam@list:zip([], [1, 2, 3]), []),
+    gleam@should:equal(gleam@list:zip([1, 2], []), []),
+    gleam@should:equal(
         gleam@list:zip([1, 2, 3], [4, 5, 6]),
         [{1, 4}, {2, 5}, {3, 6}]
     ),
-    gleam@expect:equal(gleam@list:zip([5, 6], [1, 2, 3]), [{5, 1}, {6, 2}]),
-    gleam@expect:equal(gleam@list:zip([5, 6, 7], [1, 2]), [{5, 1}, {6, 2}]).
+    gleam@should:equal(gleam@list:zip([5, 6], [1, 2, 3]), [{5, 1}, {6, 2}]),
+    gleam@should:equal(gleam@list:zip([5, 6, 7], [1, 2]), [{5, 1}, {6, 2}]).
 
 strict_zip_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:strict_zip([], [1, 2, 3]),
         {error, length_mismatch}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:strict_zip([1, 2], []),
         {error, length_mismatch}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:strict_zip([1, 2, 3], [4, 5, 6]),
         {ok, [{1, 4}, {2, 5}, {3, 6}]}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:strict_zip([5, 6], [1, 2, 3]),
         {error, length_mismatch}
     ),
-    gleam@expect:equal(
+    gleam@should: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), []).
+    gleam@should:equal(gleam@list:intersperse([1, 2, 3], 4), [1, 4, 2, 4, 3]),
+    gleam@should:equal(gleam@list:intersperse([], 2), []).
 
 at_test() ->
-    gleam@expect:equal(gleam@list:at([1, 2, 3], 2), {ok, 3}),
-    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}).
+    gleam@should:equal(gleam@list:at([1, 2, 3], 2), {ok, 3}),
+    gleam@should:equal(gleam@list:at([1, 2, 3], 5), {error, nil}),
+    gleam@should:equal(gleam@list:at([], 0), {error, nil}),
+    gleam@should:equal(gleam@list:at([1, 2, 3, 4, 5, 6], -1), {error, nil}).
 
 unique_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:unique([1, 1, 2, 3, 4, 4, 4, 5, 6]),
         [1, 2, 3, 4, 5, 6]
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:unique([7, 1, 45, 6, 2, 47, 2, 7, 5]),
         [7, 1, 45, 6, 2, 47, 5]
     ),
-    gleam@expect:equal(gleam@list:unique([3, 4, 5]), [3, 4, 5]),
-    gleam@expect:equal(gleam@list:unique([]), []).
+    gleam@should:equal(gleam@list:unique([3, 4, 5]), [3, 4, 5]),
+    gleam@should:equal(gleam@list:unique([]), []).
 
 sort_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:sort([4, 3, 6, 5, 4], fun gleam@int:compare/2),
         [3, 4, 4, 5, 6]
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:sort([4, 3, 6, 5, 4, 1], fun gleam@int:compare/2),
         [1, 3, 4, 4, 5, 6]
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:sort([4.1, 3.1, 6.1, 5.1, 4.1], fun gleam@float:compare/2),
         [3.1, 4.1, 4.1, 5.1, 6.1]
     ),
-    gleam@expect:equal(gleam@list:sort([], fun gleam@int:compare/2), []).
+    gleam@should:equal(gleam@list:sort([], fun gleam@int:compare/2), []).
 
 index_map_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:index_map([3, 4, 5], fun(I, X) -> {I, X} end),
         [{0, 3}, {1, 4}, {2, 5}]
     ),
     F = fun(I1, X1) -> gleam@string:append(X1, gleam@int:to_string(I1)) end,
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:index_map([<<"a">>, <<"b">>, <<"c">>], F),
         [<<"a0">>, <<"b1">>, <<"c2">>]
     ).
 
 range_test() ->
-    gleam@expect:equal(gleam@list:range(0, 0), []),
-    gleam@expect:equal(gleam@list:range(1, 1), []),
-    gleam@expect:equal(gleam@list:range(-1, -1), []),
-    gleam@expect:equal(gleam@list:range(0, 1), [0]),
-    gleam@expect:equal(gleam@list:range(0, 5), [0, 1, 2, 3, 4]),
-    gleam@expect:equal(gleam@list:range(1, -5), [1, 0, -1, -2, -3, -4]).
+    gleam@should:equal(gleam@list:range(0, 0), []),
+    gleam@should:equal(gleam@list:range(1, 1), []),
+    gleam@should:equal(gleam@list:range(-1, -1), []),
+    gleam@should:equal(gleam@list:range(0, 1), [0]),
+    gleam@should:equal(gleam@list:range(0, 5), [0, 1, 2, 3, 4]),
+    gleam@should:equal(gleam@list:range(1, -5), [1, 0, -1, -2, -3, -4]).
 
 repeat_test() ->
-    gleam@expect:equal(gleam@list:repeat(1, -10), []),
-    gleam@expect:equal(gleam@list:repeat(1, 0), []),
-    gleam@expect:equal(gleam@list:repeat(2, 3), [2, 2, 2]),
-    gleam@expect:equal(
+    gleam@should:equal(gleam@list:repeat(1, -10), []),
+    gleam@should:equal(gleam@list:repeat(1, 0), []),
+    gleam@should:equal(gleam@list:repeat(2, 3), [2, 2, 2]),
+    gleam@should:equal(
         gleam@list:repeat(<<"x">>, 5),
         [<<"x">>, <<"x">>, <<"x">>, <<"x">>, <<"x">>]
     ).
 
 split_test() ->
-    gleam@expect:equal(gleam@list:split([], 0), {[], []}),
-    gleam@expect:equal(
+    gleam@should:equal(gleam@list:split([], 0), {[], []}),
+    gleam@should:equal(
         gleam@list:split([0, 1, 2, 3, 4], 0),
         {[], [0, 1, 2, 3, 4]}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:split([0, 1, 2, 3, 4], -2),
         {[], [0, 1, 2, 3, 4]}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:split([0, 1, 2, 3, 4], 1),
         {[0], [1, 2, 3, 4]}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:split([0, 1, 2, 3, 4], 3),
         {[0, 1, 2], [3, 4]}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:split([0, 1, 2, 3, 4], 9),
         {[0, 1, 2, 3, 4], []}
     ).
 
 split_while_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:split_while([], fun(X) -> X =< 5 end),
         {[], []}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:split_while([1, 2, 3, 4, 5], fun(X1) -> X1 =< 5 end),
         {[1, 2, 3, 4, 5], []}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:split_while([1, 2, 3, 4, 5], fun(X2) -> X2 =:= 2 end),
         {[], [1, 2, 3, 4, 5]}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:split_while([1, 2, 3, 4, 5], fun(X3) -> X3 =< 3 end),
         {[1, 2, 3], [4, 5]}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@list:split_while([1, 2, 3, 4, 5], fun(X4) -> X4 =< -3 end),
         {[], [1, 2, 3, 4, 5]}
     ).
 
 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:equal(gleam@list:key_find(Proplist, 2), {error, nil}).
+    gleam@should:equal(gleam@list:key_find(Proplist, 0), {ok, <<"1">>}),
+    gleam@should:equal(gleam@list:key_find(Proplist, 1), {ok, <<"2">>}),
+    gleam@should: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 50dba1a..7c97524 100644
--- a/gen/test/gleam@map_test.erl
+++ b/gen/test/gleam@map_test.erl
@@ -4,34 +4,34 @@
 -export([from_list_test/0, has_key_test/0, new_test/0, get_test/0, insert_test/0, map_values_test/0, keys_test/0, values_test/0, take_test/0, drop_test/0, merge_test/0, delete_test/0, update_test/0, fold_test/0]).
 
 from_list_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@map:size(gleam@map:from_list([{4, 0}, {1, 0}])),
         2
     ).
 
 has_key_test() ->
-    gleam@expect:false(gleam@map:has_key(gleam@map:from_list([]), 1)),
-    gleam@expect:true(gleam@map:has_key(gleam@map:from_list([{1, 0}]), 1)),
-    gleam@expect:true(
+    gleam@should:be_false(gleam@map:has_key(gleam@map:from_list([]), 1)),
+    gleam@should:be_true(gleam@map:has_key(gleam@map:from_list([{1, 0}]), 1)),
+    gleam@should:be_true(
         gleam@map:has_key(gleam@map:from_list([{4, 0}, {1, 0}]), 1)
     ),
-    gleam@expect:false(
+    gleam@should:be_false(
         gleam@map:has_key(gleam@map:from_list([{4, 0}, {1, 0}]), 0)
     ).
 
 new_test() ->
-    gleam@expect:equal(gleam@map:size(gleam@map:new()), 0),
-    gleam@expect:equal(gleam@map:to_list(gleam@map:new()), []).
+    gleam@should:equal(gleam@map:size(gleam@map:new()), 0),
+    gleam@should:equal(gleam@map:to_list(gleam@map:new()), []).
 
 get_test() ->
     Proplist = [{4, 0}, {1, 1}],
     M = gleam@map:from_list(Proplist),
-    gleam@expect:equal(gleam@map:get(M, 4), {ok, 0}),
-    gleam@expect:equal(gleam@map:get(M, 1), {ok, 1}),
-    gleam@expect:equal(gleam@map:get(M, 2), {error, nil}).
+    gleam@should:equal(gleam@map:get(M, 4), {ok, 0}),
+    gleam@should:equal(gleam@map:get(M, 1), {ok, 1}),
+    gleam@should:equal(gleam@map:get(M, 2), {error, nil}).
 
 insert_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@map:insert(
             gleam@map:insert(
                 gleam@map:insert(gleam@map:new(), <<"a">>, 0),
@@ -45,7 +45,7 @@ insert_test() ->
     ).
 
 map_values_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@map:map_values(
             gleam@map:from_list([{1, 0}, {2, 1}, {3, 2}]),
             fun(K, V) -> K + V end
@@ -54,7 +54,7 @@ map_values_test() ->
     ).
 
 keys_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@map:keys(
             gleam@map:from_list([{<<"a">>, 0}, {<<"b">>, 1}, {<<"c">>, 2}])
         ),
@@ -62,7 +62,7 @@ keys_test() ->
     ).
 
 values_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@map:values(
             gleam@map:from_list([{<<"a">>, 0}, {<<"b">>, 1}, {<<"c">>, 2}])
         ),
@@ -70,7 +70,7 @@ values_test() ->
     ).
 
 take_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@map:take(
             gleam@map:from_list([{<<"a">>, 0}, {<<"b">>, 1}, {<<"c">>, 2}]),
             [<<"a">>, <<"b">>, <<"d">>]
@@ -79,7 +79,7 @@ take_test() ->
     ).
 
 drop_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@map:drop(
             gleam@map:from_list([{<<"a">>, 0}, {<<"b">>, 1}, {<<"c">>, 2}]),
             [<<"a">>, <<"b">>, <<"d">>]
@@ -90,13 +90,13 @@ drop_test() ->
 merge_test() ->
     A = gleam@map:from_list([{<<"a">>, 2}, {<<"c">>, 4}, {<<"d">>, 3}]),
     B = gleam@map:from_list([{<<"a">>, 0}, {<<"b">>, 1}, {<<"c">>, 2}]),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@map:merge(A, B),
         gleam@map:from_list(
             [{<<"a">>, 0}, {<<"b">>, 1}, {<<"c">>, 2}, {<<"d">>, 3}]
         )
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@map:merge(B, A),
         gleam@map:from_list(
             [{<<"a">>, 2}, {<<"b">>, 1}, {<<"c">>, 4}, {<<"d">>, 3}]
@@ -104,7 +104,7 @@ merge_test() ->
     ).
 
 delete_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@map:delete(
             gleam@map:delete(
                 gleam@map:from_list([{<<"a">>, 0}, {<<"b">>, 1}, {<<"c">>, 2}]),
@@ -124,15 +124,15 @@ update_test() ->
             {error, _} ->
                 0
         end end,
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@map:update(Dict, <<"a">>, IncOrZero),
         gleam@map:from_list([{<<"a">>, 1}, {<<"b">>, 1}, {<<"c">>, 2}])
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@map:update(Dict, <<"b">>, IncOrZero),
         gleam@map:from_list([{<<"a">>, 0}, {<<"b">>, 2}, {<<"c">>, 2}])
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@map:update(Dict, <<"z">>, IncOrZero),
         gleam@map:from_list(
             [{<<"a">>, 0}, {<<"b">>, 1}, {<<"c">>, 2}, {<<"z">>, 0}]
@@ -144,7 +144,7 @@ fold_test() ->
         [{<<"a">>, 0}, {<<"b">>, 1}, {<<"c">>, 2}, {<<"d">>, 3}]
     ),
     Add = fun(_, V, Acc) -> V + Acc end,
-    gleam@expect:equal(gleam@map:fold(Dict, 0, Add), 6),
+    gleam@should:equal(gleam@map:fold(Dict, 0, Add), 6),
     Concat = fun(K, _, Acc1) -> gleam@string:append(Acc1, K) end,
-    gleam@expect:equal(gleam@map:fold(Dict, <<"">>, Concat), <<"abcd">>),
-    gleam@expect:equal(gleam@map:fold(gleam@map:from_list([]), 0, Add), 0).
+    gleam@should:equal(gleam@map:fold(Dict, <<"">>, Concat), <<"abcd">>),
+    gleam@should:equal(gleam@map:fold(gleam@map:from_list([]), 0, Add), 0).
diff --git a/gen/test/gleam@order_test.erl b/gen/test/gleam@order_test.erl
index d9525c6..771e72c 100644
--- a/gen/test/gleam@order_test.erl
+++ b/gen/test/gleam@order_test.erl
@@ -4,44 +4,44 @@
 -export([reverse_test/0, to_int_test/0, compare_test/0, max_test/0, min_test/0]).
 
 reverse_test() ->
-    gleam@expect:equal(gleam@order:reverse(lt), gt),
-    gleam@expect:equal(gleam@order:reverse(eq), eq),
-    gleam@expect:equal(gleam@order:reverse(gt), lt).
+    gleam@should:equal(gleam@order:reverse(lt), gt),
+    gleam@should:equal(gleam@order:reverse(eq), eq),
+    gleam@should:equal(gleam@order:reverse(gt), lt).
 
 to_int_test() ->
-    gleam@expect:equal(gleam@order:to_int(lt), -1),
-    gleam@expect:equal(gleam@order:to_int(eq), 0),
-    gleam@expect:equal(gleam@order:to_int(gt), 1).
+    gleam@should:equal(gleam@order:to_int(lt), -1),
+    gleam@should:equal(gleam@order:to_int(eq), 0),
+    gleam@should:equal(gleam@order:to_int(gt), 1).
 
 compare_test() ->
-    gleam@expect:equal(gleam@order:compare(lt, lt), eq),
-    gleam@expect:equal(gleam@order:compare(lt, eq), lt),
-    gleam@expect:equal(gleam@order:compare(lt, gt), lt),
-    gleam@expect:equal(gleam@order:compare(eq, lt), gt),
-    gleam@expect:equal(gleam@order:compare(eq, eq), eq),
-    gleam@expect:equal(gleam@order:compare(eq, gt), lt),
-    gleam@expect:equal(gleam@order:compare(gt, lt), gt),
-    gleam@expect:equal(gleam@order:compare(gt, eq), gt),
-    gleam@expect:equal(gleam@order:compare(gt, gt), eq).
+    gleam@should:equal(gleam@order:compare(lt, lt), eq),
+    gleam@should:equal(gleam@order:compare(lt, eq), lt),
+    gleam@should:equal(gleam@order:compare(lt, gt), lt),
+    gleam@should:equal(gleam@order:compare(eq, lt), gt),
+    gleam@should:equal(gleam@order:compare(eq, eq), eq),
+    gleam@should:equal(gleam@order:compare(eq, gt), lt),
+    gleam@should:equal(gleam@order:compare(gt, lt), gt),
+    gleam@should:equal(gleam@order:compare(gt, eq), gt),
+    gleam@should:equal(gleam@order:compare(gt, gt), eq).
 
 max_test() ->
-    gleam@expect:equal(gleam@order:max(lt, lt), lt),
-    gleam@expect:equal(gleam@order:max(lt, eq), eq),
-    gleam@expect:equal(gleam@order:max(lt, gt), gt),
-    gleam@expect:equal(gleam@order:max(eq, lt), eq),
-    gleam@expect:equal(gleam@order:max(eq, eq), eq),
-    gleam@expect:equal(gleam@order:max(eq, gt), gt),
-    gleam@expect:equal(gleam@order:max(gt, lt), gt),
-    gleam@expect:equal(gleam@order:max(gt, eq), gt),
-    gleam@expect:equal(gleam@order:max(gt, gt), gt).
+    gleam@should:equal(gleam@order:max(lt, lt), lt),
+    gleam@should:equal(gleam@order:max(lt, eq), eq),
+    gleam@should:equal(gleam@order:max(lt, gt), gt),
+    gleam@should:equal(gleam@order:max(eq, lt), eq),
+    gleam@should:equal(gleam@order:max(eq, eq), eq),
+    gleam@should:equal(gleam@order:max(eq, gt), gt),
+    gleam@should:equal(gleam@order:max(gt, lt), gt),
+    gleam@should:equal(gleam@order:max(gt, eq), gt),
+    gleam@should:equal(gleam@order:max(gt, gt), gt).
 
 min_test() ->
-    gleam@expect:equal(gleam@order:min(lt, lt), lt),
-    gleam@expect:equal(gleam@order:min(lt, eq), lt),
-    gleam@expect:equal(gleam@order:min(lt, gt), lt),
-    gleam@expect:equal(gleam@order:min(eq, lt), lt),
-    gleam@expect:equal(gleam@order:min(eq, eq), eq),
-    gleam@expect:equal(gleam@order:min(eq, gt), eq),
-    gleam@expect:equal(gleam@order:min(gt, lt), lt),
-    gleam@expect:equal(gleam@order:min(gt, eq), eq),
-    gleam@expect:equal(gleam@order:min(gt, gt), gt).
+    gleam@should:equal(gleam@order:min(lt, lt), lt),
+    gleam@should:equal(gleam@order:min(lt, eq), lt),
+    gleam@should:equal(gleam@order:min(lt, gt), lt),
+    gleam@should:equal(gleam@order:min(eq, lt), lt),
+    gleam@should:equal(gleam@order:min(eq, eq), eq),
+    gleam@should:equal(gleam@order:min(eq, gt), eq),
+    gleam@should:equal(gleam@order:min(gt, lt), lt),
+    gleam@should:equal(gleam@order:min(gt, eq), eq),
+    gleam@should:equal(gleam@order:min(gt, gt), gt).
diff --git a/gen/test/gleam@pair_test.erl b/gen/test/gleam@pair_test.erl
index 6a2c856..f1addd4 100644
--- a/gen/test/gleam@pair_test.erl
+++ b/gen/test/gleam@pair_test.erl
@@ -4,26 +4,26 @@
 -export([first_test/0, second_test/0, swap_test/0, map_first_test/0, map_second_test/0]).
 
 first_test() ->
-    gleam@expect:equal(gleam@pair:first({1, 2}), 1),
-    gleam@expect:equal(gleam@pair:first({<<"abc">>, []}), <<"abc">>).
+    gleam@should:equal(gleam@pair:first({1, 2}), 1),
+    gleam@should:equal(gleam@pair:first({<<"abc">>, []}), <<"abc">>).
 
 second_test() ->
-    gleam@expect:equal(gleam@pair:second({1, 2}), 2),
-    gleam@expect:equal(gleam@pair:second({<<"abc">>, []}), []).
+    gleam@should:equal(gleam@pair:second({1, 2}), 2),
+    gleam@should:equal(gleam@pair:second({<<"abc">>, []}), []).
 
 swap_test() ->
-    gleam@expect:equal(gleam@pair:swap({1, <<"2">>}), {<<"2">>, 1}).
+    gleam@should:equal(gleam@pair:swap({1, <<"2">>}), {<<"2">>, 1}).
 
 map_first_test() ->
     Inc = fun(A) -> A + 1 end,
-    gleam@expect:equal(gleam@pair:map_first({1, 2}, Inc), {2, 2}),
-    gleam@expect:equal(gleam@pair:map_first({8, 2}, Inc), {9, 2}),
-    gleam@expect:equal(gleam@pair:map_first({0, -2}, Inc), {1, -2}),
-    gleam@expect:equal(gleam@pair:map_first({-10, 20}, Inc), {-9, 20}).
+    gleam@should:equal(gleam@pair:map_first({1, 2}, Inc), {2, 2}),
+    gleam@should:equal(gleam@pair:map_first({8, 2}, Inc), {9, 2}),
+    gleam@should:equal(gleam@pair:map_first({0, -2}, Inc), {1, -2}),
+    gleam@should:equal(gleam@pair:map_first({-10, 20}, Inc), {-9, 20}).
 
 map_second_test() ->
     Dec = fun(A) -> A - 1 end,
-    gleam@expect:equal(gleam@pair:map_second({1, 2}, Dec), {1, 1}),
-    gleam@expect:equal(gleam@pair:map_second({8, 2}, Dec), {8, 1}),
-    gleam@expect:equal(gleam@pair:map_second({0, -2}, Dec), {0, -3}),
-    gleam@expect:equal(gleam@pair:map_second({-10, 20}, Dec), {-10, 19}).
+    gleam@should:equal(gleam@pair:map_second({1, 2}, Dec), {1, 1}),
+    gleam@should:equal(gleam@pair:map_second({8, 2}, Dec), {8, 1}),
+    gleam@should:equal(gleam@pair:map_second({0, -2}, Dec), {0, -3}),
+    gleam@should:equal(gleam@pair:map_second({-10, 20}, Dec), {-10, 19}).
diff --git a/gen/test/gleam@result_test.erl b/gen/test/gleam@result_test.erl
index ae6b760..4c3b270 100644
--- a/gen/test/gleam@result_test.erl
+++ b/gen/test/gleam@result_test.erl
@@ -4,61 +4,61 @@
 -export([is_ok_test/0, is_error_test/0, map_test/0, map_error_test/0, flatten_test/0, then_test/0, unwrap_test/0]).
 
 is_ok_test() ->
-    gleam@expect:true(gleam@result:is_ok({ok, 1})),
-    gleam@expect:false(gleam@result:is_ok({error, 1})).
+    gleam@should:be_true(gleam@result:is_ok({ok, 1})),
+    gleam@should:be_false(gleam@result:is_ok({error, 1})).
 
 is_error_test() ->
-    gleam@expect:false(gleam@result:is_error({ok, 1})),
-    gleam@expect:true(gleam@result:is_error({error, 1})).
+    gleam@should:be_false(gleam@result:is_error({ok, 1})),
+    gleam@should:be_true(gleam@result:is_error({error, 1})).
 
 map_test() ->
-    gleam@expect:equal(gleam@result:map({ok, 1}, fun(X) -> X + 1 end), {ok, 2}),
-    gleam@expect:equal(
+    gleam@should:equal(gleam@result:map({ok, 1}, fun(X) -> X + 1 end), {ok, 2}),
+    gleam@should:equal(
         gleam@result:map({ok, 1}, fun(_) -> <<"2">> end),
         {ok, <<"2">>}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@result:map({error, 1}, fun(X1) -> X1 + 1 end),
         {error, 1}
     ).
 
 map_error_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@result:map_error({ok, 1}, fun(X) -> X + 1 end),
         {ok, 1}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@result:map_error({error, 1}, fun(X1) -> {<<"ok">>, X1 + 1} end),
         {error, {<<"ok">>, 2}}
     ).
 
 flatten_test() ->
-    gleam@expect:equal(gleam@result:flatten({ok, {ok, 1}}), {ok, 1}),
-    gleam@expect:equal(gleam@result:flatten({ok, {error, 1}}), {error, 1}),
-    gleam@expect:equal(gleam@result:flatten({error, 1}), {error, 1}),
-    gleam@expect:equal(
+    gleam@should:equal(gleam@result:flatten({ok, {ok, 1}}), {ok, 1}),
+    gleam@should:equal(gleam@result:flatten({ok, {error, 1}}), {error, 1}),
+    gleam@should:equal(gleam@result:flatten({error, 1}), {error, 1}),
+    gleam@should:equal(
         gleam@result:flatten({error, {error, 1}}),
         {error, {error, 1}}
     ).
 
 then_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@result:then({error, 1}, fun(X) -> {ok, X + 1} end),
         {error, 1}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@result:then({ok, 1}, fun(X1) -> {ok, X1 + 1} end),
         {ok, 2}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@result:then({ok, 1}, fun(_) -> {ok, <<"type change">>} end),
         {ok, <<"type change">>}
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@result:then({ok, 1}, fun(_) -> {error, 1} end),
         {error, 1}
     ).
 
 unwrap_test() ->
-    gleam@expect:equal(gleam@result:unwrap({ok, 1}, 50), 1),
-    gleam@expect:equal(gleam@result:unwrap({error, <<"nope">>}, 50), 50).
+    gleam@should:equal(gleam@result:unwrap({ok, 1}, 50), 1),
+    gleam@should:equal(gleam@result:unwrap({error, <<"nope">>}, 50), 50).
diff --git a/gen/test/gleam@string_test.erl b/gen/test/gleam@string_test.erl
index ed4b204..b6708d3 100644
--- a/gen/test/gleam@string_test.erl
+++ b/gen/test/gleam@string_test.erl
@@ -4,60 +4,60 @@
 -export([length_test/0, lowercase_test/0, uppercase_test/0, reverse_test/0, split_test/0, replace_test/0, append_test/0, compare_test/0, concat_test/0, join_test/0]).
 
 length_test() ->
-    gleam@expect:equal(gleam@string:length(<<"ß↑e̊">>), 3),
-    gleam@expect:equal(gleam@string:length(<<"Gleam">>), 5),
-    gleam@expect:equal(gleam@string:length(<<"">>), 0).
+    gleam@should:equal(gleam@string:length(<<"ß↑e̊">>), 3),
+    gleam@should:equal(gleam@string:length(<<"Gleam">>), 5),
+    gleam@should:equal(gleam@string:length(<<"">>), 0).
 
 lowercase_test() ->
-    gleam@expect:equal(gleam@string:lowercase(<<"Gleam">>), <<"gleam">>).
+    gleam@should:equal(gleam@string:lowercase(<<"Gleam">>), <<"gleam">>).
 
 uppercase_test() ->
-    gleam@expect:equal(gleam@string:uppercase(<<"Gleam">>), <<"GLEAM">>).
+    gleam@should:equal(gleam@string:uppercase(<<"Gleam">>), <<"GLEAM">>).
 
 reverse_test() ->
-    gleam@expect:equal(gleam@string:reverse(<<"Gleam">>), <<"maelG">>).
+    gleam@should:equal(gleam@string:reverse(<<"Gleam">>), <<"maelG">>).
 
 split_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@string:split(<<"Gleam,Erlang,Elixir">>, <<",">>),
         [<<"Gleam">>, <<"Erlang">>, <<"Elixir">>]
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@string:split(<<"Gleam, Erlang,Elixir">>, <<", ">>),
         [<<"Gleam">>, <<"Erlang,Elixir">>]
     ).
 
 replace_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@string:replace(<<"Gleam,Erlang,Elixir">>, <<",">>, <<"++">>),
         <<"Gleam++Erlang++Elixir">>
     ).
 
 append_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@string:append(<<"Test">>, <<" Me">>),
         <<"Test Me">>
     ).
 
 compare_test() ->
-    gleam@expect:equal(gleam@string:compare(<<"">>, <<"">>), eq),
-    gleam@expect:equal(gleam@string:compare(<<"a">>, <<"">>), gt),
-    gleam@expect:equal(gleam@string:compare(<<"a">>, <<"A">>), gt),
-    gleam@expect:equal(gleam@string:compare(<<"A">>, <<"B">>), lt),
-    gleam@expect:equal(gleam@string:compare(<<"t">>, <<"ABC">>), gt).
+    gleam@should:equal(gleam@string:compare(<<"">>, <<"">>), eq),
+    gleam@should:equal(gleam@string:compare(<<"a">>, <<"">>), gt),
+    gleam@should:equal(gleam@string:compare(<<"a">>, <<"A">>), gt),
+    gleam@should:equal(gleam@string:compare(<<"A">>, <<"B">>), lt),
+    gleam@should:equal(gleam@string:compare(<<"t">>, <<"ABC">>), gt).
 
 concat_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@string:concat([<<"Hello">>, <<", ">>, <<"world!">>]),
         <<"Hello, world!">>
     ).
 
 join_test() ->
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@string:join([<<"Hello">>, <<"world!">>], <<", ">>),
         <<"Hello, world!">>
     ),
-    gleam@expect:equal(
+    gleam@should:equal(
         gleam@string:join([<<"Hello">>, <<"world!">>], <<"-">>),
         <<"Hello-world!">>
     ).
diff --git a/src/gleam/expect.gleam b/src/gleam/expect.gleam
deleted file mode 100644
index fb46f1e..0000000
--- a/src/gleam/expect.gleam
+++ /dev/null
@@ -1,20 +0,0 @@
-// TODO: Move this module into another package so it can be used as a
-// dep only in test.
-
-pub external type Expectation;
-
-pub external fn equal(a, a) -> Expectation = "gleam_stdlib" "expect_equal";
-
-pub external fn not_equal(a, a) -> Expectation = "gleam_stdlib" "expect_not_equal";
-
-pub external fn true(Bool) -> Expectation = "gleam_stdlib" "expect_true";
-
-pub external fn false(Bool) -> Expectation = "gleam_stdlib" "expect_false";
-
-pub external fn is_ok(Result(a, b)) -> Expectation = "gleam_stdlib" "expect_is_ok";
-
-pub external fn is_error(Result(a, b)) -> Expectation = "gleam_stdlib" "expect_is_error";
-
-pub fn fail() -> Expectation {
-  true(False)
-}
diff --git a/src/gleam/should.gleam b/src/gleam/should.gleam
new file mode 100644
index 0000000..0fbebeb
--- /dev/null
+++ b/src/gleam/should.gleam
@@ -0,0 +1,20 @@
+// TODO: Move this module into another package so it can be used as a
+// dep only in test.
+
+pub external type Expectation;
+
+pub external fn equal(a, a) -> Expectation = "gleam_stdlib" "should_equal";
+
+pub external fn not_equal(a, a) -> Expectation = "gleam_stdlib" "should_not_equal";
+
+pub external fn be_true(Bool) -> Expectation = "gleam_stdlib" "should_be_true";
+
+pub external fn be_false(Bool) -> Expectation = "gleam_stdlib" "should_be_false";
+
+pub external fn be_ok(Result(a, b)) -> Expectation = "gleam_stdlib" "should_be_ok";
+
+pub external fn be_error(Result(a, b)) -> Expectation = "gleam_stdlib" "should_be_error";
+
+pub fn fail() -> Expectation {
+  be_true(False)
+}
diff --git a/src/gleam_stdlib.erl b/src/gleam_stdlib.erl
index 9f380ef..1f1f652 100644
--- a/src/gleam_stdlib.erl
+++ b/src/gleam_stdlib.erl
@@ -1,19 +1,19 @@
 -module(gleam_stdlib).
 -include_lib("eunit/include/eunit.hrl").
 
--export([expect_equal/2, expect_not_equal/2, expect_true/1, expect_false/1,
-         expect_is_ok/1, expect_is_error/1, atom_from_string/1,
+-export([should_equal/2, should_not_equal/2, should_be_true/1, should_be_false/1,
+         should_be_ok/1, should_be_error/1, atom_from_string/1,
          atom_create_from_string/1, atom_to_string/1, map_get/2,
          iodata_append/2, iodata_prepend/2, identity/1, decode_int/1,
          decode_string/1, decode_bool/1, decode_float/1, decode_thunk/1, decode_atom/1,
          decode_list/1, decode_field/2, decode_element/2, parse_int/1, parse_float/1, compare_strings/2]).
 
-expect_equal(Actual, Expected) -> ?assertEqual(Expected, Actual).
-expect_not_equal(Actual, Expected) -> ?assertNotEqual(Expected, Actual).
-expect_true(A) -> ?assert(A).
-expect_false(A) -> ?assertNot(A).
-expect_is_ok(A) -> ?assertMatch({ok, _}, A).
-expect_is_error(A) -> ?assertMatch({error, _}, A).
+should_equal(Actual, Expected) -> ?assertEqual(Expected, Actual).
+should_not_equal(Actual, Expected) -> ?assertNotEqual(Expected, Actual).
+should_be_true(A) -> ?assert(A).
+should_be_false(A) -> ?assertNot(A).
+should_be_ok(A) -> ?assertMatch({ok, _}, A).
+should_be_error(A) -> ?assertMatch({error, _}, A).
 
 map_get(Map, Key) ->
   case maps:find(Key, Map) of
diff --git a/test/gleam/atom_test.gleam b/test/gleam/atom_test.gleam
index 1f24336..da0699a 100644
--- a/test/gleam/atom_test.gleam
+++ b/test/gleam/atom_test.gleam
@@ -1,45 +1,45 @@
 import gleam/atom
-import gleam/expect
+import gleam/should
 
 pub fn from_string_test() {
   "ok"
   |> atom.from_string
-  |> expect.is_ok
+  |> should.be_ok
 
   "expect"
   |> atom.from_string
-  |> expect.is_ok
+  |> should.be_ok
 
   "this is not an atom we have seen before"
   |> atom.from_string
-  |> expect.equal(_, Error(atom.AtomNotLoaded))
+  |> should.equal(_, Error(atom.AtomNotLoaded))
 }
 
 pub fn create_from_string_test() {
   "ok"
   |> atom.create_from_string
   |> Ok
-  |> expect.equal(_, atom.from_string("ok"))
+  |> should.equal(_, atom.from_string("ok"))
 
   "expect"
   |> atom.create_from_string
   |> Ok
-  |> expect.equal(_, atom.from_string("expect"))
+  |> should.equal(_, atom.from_string("expect"))
 
   "this is another atom we have not seen before"
   |> atom.create_from_string
   |> Ok
-  |> expect.equal(_, atom.from_string("this is another atom we have not seen before"))
+  |> should.equal(_, atom.from_string("this is another atom we have not seen before"))
 }
 
 pub fn to_string_test() {
   "ok"
   |> atom.create_from_string
   |> atom.to_string
-  |> expect.equal(_, "ok")
+  |> should.equal(_, "ok")
 
   "expect"
   |> atom.create_from_string
   |> atom.to_string
-  |> expect.equal(_, "expect")
+  |> should.equal(_, "expect")
 }
diff --git a/test/gleam/bool_test.gleam b/test/gleam/bool_test.gleam
index 8c30579..4e2b8e0 100644
--- a/test/gleam/bool_test.gleam
+++ b/test/gleam/bool_test.gleam
@@ -1,61 +1,61 @@
 import gleam/bool
 import gleam/order
-import gleam/expect
+import gleam/should
 
 pub fn negate_test() {
   bool.negate(True)
-  |> expect.false
+  |> should.be_false
 
   bool.negate(False)
-  |> expect.true
+  |> should.be_true
 }
 
 pub fn compare_test() {
   bool.compare(True, True)
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 
   bool.compare(True, False)
-  |> expect.equal(_, order.Gt)
+  |> should.equal(_, order.Gt)
 
   bool.compare(False, False)
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 
   bool.compare(False, True)
-  |> expect.equal(_, order.Lt)
+  |> should.equal(_, order.Lt)
 }
 
 pub fn max_test() {
   bool.max(True, True)
-  |> expect.equal(_, True)
+  |> should.equal(_, True)
 
   bool.max(True, False)
-  |> expect.equal(_, True)
+  |> should.equal(_, True)
 
   bool.max(False, False)
-  |> expect.equal(_, False)
+  |> should.equal(_, False)
 
   bool.max(False, True)
-  |> expect.equal(_, True)
+  |> should.equal(_, True)
 }
 
 pub fn min_test() {
   bool.min(True, True)
-  |> expect.equal(_, True)
+  |> should.equal(_, True)
 
   bool.min(True, False)
-  |> expect.equal(_, False)
+  |> should.equal(_, False)
 
   bool.min(False, False)
-  |> expect.equal(_, False)
+  |> should.equal(_, False)
 
   bool.min(False, True)
-  |> expect.equal(_, False)
+  |> should.equal(_, False)
 }
 
 pub fn to_int_test() {
   bool.to_int(True)
-  |> expect.equal(_, 1)
+  |> should.equal(_, 1)
 
   bool.to_int(False)
-  |> expect.equal(_, 0)
+  |> should.equal(_, 0)
 }
diff --git a/test/gleam/dynamic_test.gleam b/test/gleam/dynamic_test.gleam
index 2e51517..080e6e7 100644
--- a/test/gleam/dynamic_test.gleam
+++ b/test/gleam/dynamic_test.gleam
@@ -1,7 +1,7 @@
 import gleam/dynamic
 import gleam/atom
 import gleam/list
-import gleam/expect
+import gleam/should
 import gleam/result
 import gleam/map
 
@@ -9,116 +9,116 @@ pub fn string_test() {
   ""
   |> dynamic.from
   |> dynamic.string
-  |> expect.equal(_, Ok(""))
+  |> should.equal(_, Ok(""))
 
   "Hello"
   |> dynamic.from
   |> dynamic.string
-  |> expect.equal(_, Ok("Hello"))
+  |> should.equal(_, Ok("Hello"))
 
   1
   |> dynamic.from
   |> dynamic.string
-  |> expect.equal(_, Error("Expected a String, got `1`"))
+  |> should.equal(_, Error("Expected a String, got `1`"))
 
   []
   |> dynamic.from
   |> dynamic.string
-  |> expect.equal(_, Error("Expected a String, got `[]`"))
+  |> should.equal(_, Error("Expected a String, got `[]`"))
 }
 
 pub fn int_test() {
   1
   |> dynamic.from
   |> dynamic.int
-  |> expect.equal(_, Ok(1))
+  |> should.equal(_, Ok(1))
 
   2
   |> dynamic.from
   |> dynamic.int
-  |> expect.equal(_, Ok(2))
+  |> should.equal(_, Ok(2))
 
   1.0
   |> dynamic.from
   |> dynamic.int
-  |> expect.equal(_, Error("Expected an Int, got `1.0`"))
+  |> should.equal(_, Error("Expected an Int, got `1.0`"))
 
   []
   |> dynamic.from
   |> dynamic.int
-  |> expect.equal(_, Error("Expected an Int, got `[]`"))
+  |> should.equal(_, Error("Expected an Int, got `[]`"))
 }
 
 pub fn float_test() {
   1.0
   |> dynamic.from
   |> dynamic.float
-  |> expect.equal(_, Ok(1.0))
+  |> should.equal(_, Ok(1.0))
 
   2.2
   |> dynamic.from
   |> dynamic.float
-  |> expect.equal(_, Ok(2.2))
+  |> should.equal(_, Ok(2.2))
 
   1
   |> dynamic.from
   |> dynamic.float
-  |> expect.equal(_, Error("Expected a Float, got `1`"))
+  |> should.equal(_, Error("Expected a Float, got `1`"))
 
   []
   |> dynamic.from
   |> dynamic.float
-  |> expect.equal(_, Error("Expected a Float, got `[]`"))
+  |> should.equal(_, Error("Expected a Float, got `[]`"))
 }
 
 pub fn thunk_test() {
   fn() { 1 }
   |> dynamic.from
   |> dynamic.thunk
-  |> expect.is_ok
+  |> should.be_ok
 
   fn() { 1 }
   |> dynamic.from
   |> dynamic.thunk
   |> result.map(_, fn(f) { f() })
-  |> expect.equal(_, Ok(dynamic.from(1)))
+  |> should.equal(_, Ok(dynamic.from(1)))
 
   fn(x) { x }
   |> dynamic.from
   |> dynamic.thunk
-  |> expect.is_error
+  |> should.be_error
 
   1
   |> dynamic.from
   |> dynamic.thunk
-  |> expect.is_error
+  |> should.be_error
 
   []
   |> dynamic.from
   |> dynamic.thunk
-  |> expect.is_error
+  |> should.be_error
 }
 
 pub fn bool_test() {
   True
   |> dynamic.from
   |> dynamic.bool
-  |> expect.equal(_, Ok(True))
+  |> should.equal(_, Ok(True))
 
   False
   |> dynamic.from
   |> dynamic.bool
-  |> expect.equal(_, Ok(False))
+  |> should.equal(_, Ok(False))
 
   1
   |> dynamic.from
   |> dynamic.bool
-  |> expect.equal(_, Error("Expected a Bool, got `1`"))
+  |> should.equal(_, Error("Expected a Bool, got `1`"))
 
   []
   |> dynamic.from
   |> dynamic.bool
-  |> expect.equal(_, Error("Expected a Bool, got `[]`"))
+  |> should.equal(_, Error("Expected a Bool, got `[]`"))
 }
 
 pub fn atom_test() {
@@ -126,65 +126,65 @@ pub fn atom_test() {
     |> atom.create_from_string
     |> dynamic.from
     |> dynamic.atom
-    |> expect.equal(_, Ok(atom.create_from_string("")))
+    |> should.equal(_, Ok(atom.create_from_string("")))
 
   "ok"
     |> atom.create_from_string
     |> dynamic.from
     |> dynamic.atom
-    |> expect.equal(_, Ok(atom.create_from_string("ok")))
+    |> should.equal(_, Ok(atom.create_from_string("ok")))
 
   1
     |> dynamic.from
     |> dynamic.atom
-    |> expect.is_error
+    |> should.be_error
 
   []
     |> dynamic.from
     |> dynamic.atom
-    |> expect.is_error
+    |> should.be_error
 }
 
 pub fn list_test() {
   []
   |> dynamic.from
   |> dynamic.list(_, dynamic.string)
-  |> expect.equal(_, Ok([]))
+  |> should.equal(_, Ok([]))
 
   []
   |> dynamic.from
   |> dynamic.list(_, dynamic.int)
-  |> expect.equal(_, Ok([]))
+  |> should.equal(_, Ok([]))
 
   [1, 2, 3]
   |> dynamic.from
   |> dynamic.list(_, dynamic.int)
-  |> expect.equal(_, Ok([1, 2, 3]))
+  |> should.equal(_, Ok([1, 2, 3]))
 
   [[1], [2], [3]]
   |> dynamic.from
   |> dynamic.list(_, dynamic.list(_, dynamic.int))
-  |> expect.equal(_, Ok([[1], [2], [3]]))
+  |> should.equal(_, Ok([[1], [2], [3]]))
 
   1
   |> dynamic.from
   |> dynamic.list(_, dynamic.string)
-  |> expect.is_error
+  |> should.be_error
 
   1.0
   |> dynamic.from
   |> dynamic.list(_, dynamic.int)
-  |> expect.is_error
+  |> should.be_error
 
   [""]
   |> dynamic.from
   |> dynamic.list(_, dynamic.int)
-  |> expect.is_error
+  |> should.be_error
 
   [dynamic.from(1), dynamic.from("not an int")]
   |> dynamic.from
   |> dynamic.list(_, dynamic.int)
-  |> expect.is_error
+  |> should.be_error
 }
 
 pub fn field_test() {
@@ -195,29 +195,29 @@ pub fn field_test() {
   |> map.insert(_, ok_atom, 1)
   |> dynamic.from
   |> dynamic.field(_, ok_atom)
-  |> expect.equal(_, Ok(dynamic.from(1)))
+  |> should.equal(_, Ok(dynamic.from(1)))
 
   map.new()
   |> map.insert(_, ok_atom, 3)
   |> map.insert(_, error_atom, 1)
   |> dynamic.from
   |> dynamic.field(_, ok_atom)
-  |> expect.equal(_, Ok(dynamic.from(3)))
+  |> should.equal(_, Ok(dynamic.from(3)))
 
   map.new()
   |> dynamic.from
   |> dynamic.field(_, ok_atom)
-  |> expect.is_error
+  |> should.be_error
 
   1
   |> dynamic.from
   |> dynamic.field(_, ok_atom)
-  |> expect.is_error
+  |> should.be_error
 
   []
   |> dynamic.from
   |> dynamic.field(_, [])
-  |> expect.is_error
+  |> should.be_error
 }
 
 pub fn element_test() {
@@ -227,31 +227,31 @@ pub fn element_test() {
   ok_one_tuple
   |> dynamic.from
   |> dynamic.element(_, 0)
-  |> expect.equal(_, Ok(dynamic.from(ok_atom)))
+  |> should.equal(_, Ok(dynamic.from(ok_atom)))
 
   ok_one_tuple
   |> dynamic.from
   |> dynamic.element(_, 1)
-  |> expect.equal(_, Ok(dynamic.from(1)))
+  |> should.equal(_, Ok(dynamic.from(1)))
 
   ok_one_tuple
   |> dynamic.from
   |> dynamic.element(_, 2)
-  |> expect.is_error
+  |> should.be_error
 
   ok_one_tuple
   |> dynamic.from
   |> dynamic.element(_, -1)
-  |> expect.is_error
+  |> should.be_error
 
   1
   |> dynamic.from
   |> dynamic.element(_, 0)
-  |> expect.is_error
+  |> should.be_error
 
   map.new()
   |> map.insert(_, 1, ok_atom)
   |> dynamic.from
   |> dynamic.element(_, 0)
-  |> expect.is_error
+  |> should.be_error
 }
diff --git a/test/gleam/float_test.gleam b/test/gleam/float_test.gleam
index f10565c..038801a 100644
--- a/test/gleam/float_test.gleam
+++ b/test/gleam/float_test.gleam
@@ -1,185 +1,185 @@
-import gleam/expect
+import gleam/should
 import gleam/float
 import gleam/order
 
 pub fn parse_test() {
   "1.23"
   |> float.parse
-  |> expect.equal(_, Ok(1.23))
+  |> should.equal(_, Ok(1.23))
 
   "5.0"
   |> float.parse
-  |> expect.equal(_, Ok(5.0))
+  |> should.equal(_, Ok(5.0))
 
   "0.123456789"
   |> float.parse
-  |> expect.equal(_, Ok(0.123456789))
+  |> should.equal(_, Ok(0.123456789))
 
   ""
   |> float.parse
-  |> expect.equal(_, Error(Nil))
+  |> should.equal(_, Error(Nil))
 
   "what"
   |> float.parse
-  |> expect.equal(_, Error(Nil))
+  |> should.equal(_, Error(Nil))
 
   "1"
   |> float.parse
-  |> expect.equal(_, Error(Nil))
+  |> should.equal(_, Error(Nil))
 }
 
 pub fn to_string_test() {
   123.0
   |> float.to_string
-  |> expect.equal(_, "123.0")
+  |> should.equal(_, "123.0")
 
   -8.1
   |> float.to_string
-  |> expect.equal(_, "-8.1")
+  |> should.equal(_, "-8.1")
 }
 
 pub fn compare_test() {
   float.compare(0., 0.)
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 
   float.compare(0.1, 0.1)
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 
   float.compare(0., 0.1)
-  |> expect.equal(_, order.Lt)
+  |> should.equal(_, order.Lt)
 
   float.compare(-2., -1.9)
-  |> expect.equal(_, order.Lt)
+  |> should.equal(_, order.Lt)
 
   float.compare(2., 1.9)
-  |> expect.equal(_, order.Gt)
+  |> should.equal(_, order.Gt)
 
   float.compare(-1.9, -2.)
-  |> expect.equal(_, order.Gt)
+  |> should.equal(_, order.Gt)
 }
 
 pub fn ceiling_test() {
   8.1
   |> float.ceiling
-  |> expect.equal(_, 9.0)
+  |> should.equal(_, 9.0)
 
   -8.1
   |> float.ceiling
-  |> expect.equal(_, -8.0)
+  |> should.equal(_, -8.0)
 
   -8.0
   |> float.ceiling
-  |> expect.equal(_, -8.0)
+  |> should.equal(_, -8.0)
 }
 
 pub fn floor_test() {
   8.1
   |> float.floor
-  |> expect.equal(_, 8.0)
+  |> should.equal(_, 8.0)
 
   -8.1
   |> float.floor
-  |> expect.equal(_, -9.0)
+  |> should.equal(_, -9.0)
 
   -8.0
   |> float.floor
-  |> expect.equal(_, -8.0)
+  |> should.equal(_, -8.0)
 }
 
 pub fn round_test() {
   8.1
   |> float.round
-  |> expect.equal(_, 8)
+  |> should.equal(_, 8)
 
   8.4
   |> float.round
-  |> expect.equal(_, 8)
+  |> should.equal(_, 8)
 
   8.499
   |> float.round
-  |> expect.equal(_, 8)
+  |> should.equal(_, 8)
 
   8.5
   |> float.round
-  |> expect.equal(_, 9)
+  |> should.equal(_, 9)
 
   -8.1
   |> float.round
-  |> expect.equal(_, -8)
+  |> should.equal(_, -8)
 
   -7.5
   |> float.round
-  |> expect.equal(_, -8)
+  |> should.equal(_, -8)
 }
 
 pub fn truncate_test() {
   8.1
   |> float.truncate
-  |> expect.equal(_, 8)
+  |> should.equal(_, 8)
 
   8.4
   |> float.truncate
-  |> expect.equal(_, 8)
+  |> should.equal(_, 8)
 
   8.499
   |> float.truncate
-  |> expect.equal(_, 8)
+  |> should.equal(_, 8)
 
   8.5
   |> float.truncate
-  |> expect.equal(_, 8)
+  |> should.equal(_, 8)
 
   -8.1
   |> float.truncate
-  |> expect.equal(_, -8)
+  |> should.equal(_, -8)
 
   -7.5
   |> float.truncate
-  |> expect.equal(_, -7)
+  |> should.equal(_, -7)
 }
 
 pub fn min_test() {
   float.min(0., 0.)
-  |> expect.equal(_, 0.)
+  |> should.equal(_, 0.)
 
   float.min(0.3, 1.5)
-  |> expect.equal(_, 0.3)
+  |> should.equal(_, 0.3)
 
   float.min(1., 0.)
-  |> expect.equal(_, 0.)
+  |> should.equal(_, 0.)
 
   float.min(-1.7, 2.5)
-  |> expect.equal(_, -1.7)
+  |> should.equal(_, -1.7)
 
   float.min(-2.2, -2.2)
-  |> expect.equal(_, -2.2)
+  |> should.equal(_, -2.2)
 
   float.min(-1., -1.)
-  |> expect.equal(_, -1.)
+  |> should.equal(_, -1.)
 
   float.min(-1.1, -1.)
-  |> expect.equal(_, -1.1)
+  |> should.equal(_, -1.1)
 }
 
 pub fn max_test() {
   float.max(0., 0.)
-  |> expect.equal(_, 0.)
+  |> should.equal(_, 0.)
 
   float.max(0.3, 1.5)
-  |> expect.equal(_, 1.5)
+  |> should.equal(_, 1.5)
 
   float.max(1., 0.)
-  |> expect.equal(_, 1.)
+  |> should.equal(_, 1.)
 
   float.max(-1.7, 2.5)
-  |> expect.equal(_, 2.5)
+  |> should.equal(_, 2.5)
 
   float.max(-2.2, -2.2)
-  |> expect.equal(_, -2.2)
+  |> should.equal(_, -2.2)
 
   float.max(-1., -1.)
-  |> expect.equal(_, -1.)
+  |> should.equal(_, -1.)
 
   float.max(-1.1, -1.)
-  |> expect.equal(_, -1.)
+  |> should.equal(_, -1.)
 }
diff --git a/test/gleam/function_test.gleam b/test/gleam/function_test.gleam
index 1c3b4b8..ee4fc00 100644
--- a/test/gleam/function_test.gleam
+++ b/test/gleam/function_test.gleam
@@ -1,4 +1,4 @@
-import gleam/expect
+import gleam/should
 import gleam/function
 import gleam/int
 import gleam/list
@@ -13,7 +13,7 @@ pub fn compose_test() {
 
   1
   |> add_five
-  |> expect.equal(_, 6)
+  |> should.equal(_, 6)
 
   // Takes a list of ints and returns the head as a string (if there is one, or
   // else "0" if there is not)
@@ -24,11 +24,11 @@ pub fn compose_test() {
 
   [1]
   |> head_to_string
-  |> expect.equal(_, "1")
+  |> should.equal(_, "1")
 
   []
   |> head_to_string
-  |> expect.equal(_, "0")
+  |> should.equal(_, "0")
 }
 
 pub fn flip_test() {
@@ -43,26 +43,26 @@ pub fn flip_test() {
   let flipped_fun = function.flip(fun)
 
   fun("Bob", 1)
-  |> expect.equal(_, "String: 'Bob', Int: '1'")
+  |> should.equal(_, "String: 'Bob', Int: '1'")
 
   flipped_fun(2, "Alice")
-  |> expect.equal(_, "String: 'Alice', Int: '2'")
+  |> should.equal(_, "String: 'Alice', Int: '2'")
 }
 
 pub fn identity_test() {
   1
   |> function.identity
-  |> expect.equal(_, 1)
+  |> should.equal(_, 1)
 
   ""
   |> function.identity
-  |> expect.equal(_, "")
+  |> should.equal(_, "")
 
   []
   |> function.identity
-  |> expect.equal(_, [])
+  |> should.equal(_, [])
 
   tuple(1, 2.0)
   |> function.identity
-  |> expect.equal(_, tuple(1, 2.0))
+  |> should.equal(_, tuple(1, 2.0))
 }
diff --git a/test/gleam/int_test.gleam b/test/gleam/int_test.gleam
index 98428d1..267645b 100644
--- a/test/gleam/int_test.gleam
+++ b/test/gleam/int_test.gleam
@@ -1,159 +1,159 @@
-import gleam/expect
+import gleam/should
 import gleam/int
 import gleam/order
 
 pub fn to_string() {
   123
   |> int.to_string
-  |> expect.equal(_, "123")
+  |> should.equal(_, "123")
 
   -123
   |> int.to_string
-  |> expect.equal(_, "-123")
+  |> should.equal(_, "-123")
 
   0123
   |> int.to_string
-  |> expect.equal(_, "123")
+  |> should.equal(_, "123")
 }
 
 pub fn parse() {
   "123"
   |> int.parse
-  |> expect.equal(_, Ok(123))
+  |> should.equal(_, Ok(123))
 
   "-123"
   |> int.parse
-  |> expect.equal(_, Ok(-123))
+  |> should.equal(_, Ok(-123))
 
   "0123"
   |> int.parse
-  |> expect.equal(_, Ok(123))
+  |> should.equal(_, Ok(123))
 
   ""
   |> int.parse
-  |> expect.equal(_, Error(Nil))
+  |> should.equal(_, Error(Nil))
 
   "what"
   |> int.parse
-  |> expect.equal(_, Error(Nil))
+  |> should.equal(_, Error(Nil))
 
   "1.23"
   |> int.parse
-  |> expect.equal(_, Error(Nil))
+  |> should.equal(_, Error(Nil))
 }
 
 pub fn to_base_string() {
   100
   |> int.to_base_string(_, 16)
-  |> expect.equal(_, "64")
+  |> should.equal(_, "64")
 
   -100
   |> int.to_base_string(_, 16)
-  |> expect.equal(_, "-64")
+  |> should.equal(_, "-64")
 }
 
 pub fn compare_test() {
   int.compare(0, 0)
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 
   int.compare(1, 1)
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 
   int.compare(0, 1)
-  |> expect.equal(_, order.Lt)
+  |> should.equal(_, order.Lt)
 
   int.compare(-2, -1)
-  |> expect.equal(_, order.Lt)
+  |> should.equal(_, order.Lt)
 
   int.compare(2, 1)
-  |> expect.equal(_, order.Gt)
+  |> should.equal(_, order.Gt)
 
   int.compare(-1, -2)
-  |> expect.equal(_, order.Gt)
+  |> should.equal(_, order.Gt)
 }
 
 pub fn min_test() {
   int.min(0, 0)
-  |> expect.equal(_, 0)
+  |> should.equal(_, 0)
 
   int.min(0, 1)
-  |> expect.equal(_, 0)
+  |> should.equal(_, 0)
 
   int.min(1, 0)
-  |> expect.equal(_, 0)
+  |> should.equal(_, 0)
 
   int.min(-1, 2)
-  |> expect.equal(_, -1)
+  |> should.equal(_, -1)
 
   int.min(2, -2)
-  |> expect.equal(_, -2)
+  |> should.equal(_, -2)
 
   int.min(-1, -1)
-  |> expect.equal(_, -1)
+  |> should.equal(_, -1)
 }
 
 pub fn max_test() {
   int.max(0, 0)
-  |> expect.equal(_, 0)
+  |> should.equal(_, 0)
 
   int.max(0, 1)
-  |> expect.equal(_, 1)
+  |> should.equal(_, 1)
 
   int.max(1, 0)
-  |> expect.equal(_, 1)
+  |> should.equal(_, 1)
 
   int.max(-1, 2)
-  |> expect.equal(_, 2)
+  |> should.equal(_, 2)
 
   int.max(2, -2)
-  |> expect.equal(_, 2)
+  |> should.equal(_, 2)
 
   int.max(-1, -1)
-  |> expect.equal(_, -1)
+  |> should.equal(_, -1)
 }
 
 pub fn is_even_test() {
   int.is_even(0)
-  |> expect.true
+  |> should.be_true
 
   int.is_even(2)
-  |> expect.true
+  |> should.be_true
 
   int.is_even(-2)
-  |> expect.true
+  |> should.be_true
 
   int.is_even(10006)
-  |> expect.true
+  |> should.be_true
 
   int.is_even(1)
-  |> expect.false
+  |> should.be_false
 
   int.is_even(-3)
-  |> expect.false
+  |> should.be_false
 
   int.is_even(10005)
-  |> expect.false
+  |> should.be_false
 }
 
 pub fn is_odd_test() {
   int.is_odd(0)
-  |> expect.false
+  |> should.be_false
 
   int.is_odd(2)
-  |> expect.false
+  |> should.be_false
 
   int.is_odd(-2)
-  |> expect.false
+  |> should.be_false
 
   int.is_odd(10006)
-  |> expect.false
+  |> should.be_false
 
   int.is_odd(1)
-  |> expect.true
+  |> should.be_true
 
   int.is_odd(-3)
-  |> expect.true
+  |> should.be_true
 
   int.is_odd(10005)
-  |> expect.true
+  |> should.be_true
 }
diff --git a/test/gleam/iodata_test.gleam b/test/gleam/iodata_test.gleam
index 0b0e248..e9922e4 100644
--- a/test/gleam/iodata_test.gleam
+++ b/test/gleam/iodata_test.gleam
@@ -1,4 +1,4 @@
-import gleam/expect
+import gleam/should
 import gleam/iodata
 
 pub fn iodata_test() {
@@ -9,11 +9,11 @@ pub fn iodata_test() {
 
   data
   |> iodata.to_string
-  |> expect.equal(_, "Hello, world!")
+  |> should.equal(_, "Hello, world!")
 
   data
   |> iodata.byte_size
-  |> expect.equal(_, 13)
+  |> should.equal(_, 13)
 
   let data = iodata.new("ello")
     |> iodata.append_iodata(_, iodata.new(","))
@@ -22,11 +22,11 @@ pub fn iodata_test() {
 
   data
   |> iodata.to_string
-  |> expect.equal(_, "Hello, world!")
+  |> should.equal(_, "Hello, world!")
 
   data
   |> iodata.byte_size
-  |> expect.equal(_, 13)
+  |> should.equal(_, 13)
 }
 
 pub fn lowercase_test() {
@@ -34,7 +34,7 @@ pub fn lowercase_test() {
   |> iodata.from_strings
   |> iodata.lowercase
   |> iodata.to_string
-  |> expect.equal(_, "gleamgleam")
+  |> should.equal(_, "gleamgleam")
 }
 
 pub fn uppercase_test() {
@@ -42,49 +42,49 @@ pub fn uppercase_test() {
   |> iodata.from_strings
   |> iodata.uppercase
   |> iodata.to_string
-  |> expect.equal(_, "GLEAMGLEAM")
+  |> should.equal(_, "GLEAMGLEAM")
 }
 
 pub fn split_test() {
   "Gleam,Erlang,Elixir"
   |> iodata.new
   |> iodata.split(_, ",")
-  |> expect.equal(_, [iodata.new("Gleam"), iodata.new("Erlang"), iodata.new("Elixir")])
+  |> should.equal(_, [iodata.new("Gleam"), iodata.new("Erlang"), iodata.new("Elixir")])
 
   ["Gleam, Erl", "ang,Elixir"]
   |> iodata.from_strings
   |> iodata.split(_, ", ")
-  |> expect.equal(_, [iodata.new("Gleam"), iodata.from_strings(["Erl", "ang,Elixir"])])
+  |> should.equal(_, [iodata.new("Gleam"), iodata.from_strings(["Erl", "ang,Elixir"])])
 }
 
 pub fn is_equal_test() {
   iodata.new("12")
   |> iodata.is_equal(_, iodata.from_strings(["1", "2"]))
-  |> expect.true
+  |> should.be_true
 
   iodata.new("12")
   |> iodata.is_equal(_, iodata.new("12"))
-  |> expect.true
+  |> should.be_true
 
   iodata.new("12")
   |> iodata.is_equal(_, iodata.new("2"))
-  |> expect.false
+  |> should.be_false
 }
 
 pub fn is_empty_test() {
   iodata.new("")
   |> iodata.is_empty
-  |> expect.true
+  |> should.be_true
 
   iodata.new("12")
   |> iodata.is_empty
-  |> expect.false
+  |> should.be_false
 
   iodata.from_strings([])
   |> iodata.is_empty
-  |> expect.true
+  |> should.be_true
 
   iodata.from_strings(["", ""])
   |> iodata.is_empty
-  |> expect.true
+  |> should.be_true
 }
diff --git a/test/gleam/list_test.gleam b/test/gleam/list_test.gleam
index ee29ce8..d54fe8f 100644
--- a/test/gleam/list_test.gleam
+++ b/test/gleam/list_test.gleam
@@ -1,4 +1,4 @@
-import gleam/expect
+import gleam/should
 import gleam/list
 import gleam/int
 import gleam/float
@@ -7,79 +7,79 @@ import gleam/pair
 
 pub fn length_test() {
   list.length([])
-  |> expect.equal(_, 0)
+  |> should.equal(_, 0)
 
   list.length([1])
-  |> expect.equal(_, 1)
+  |> should.equal(_, 1)
 
   list.length([1, 1])
-  |> expect.equal(_, 2)
+  |> should.equal(_, 2)
 
   list.length([1, 1, 1])
-  |> expect.equal(_, 3)
+  |> should.equal(_, 3)
 }
 
 pub fn reverse_test() {
-  list.reverse([]) |> expect.equal(_, [])
-  list.reverse([1, 2, 3, 4, 5]) |> expect.equal(_, [5, 4, 3, 2, 1])
+  list.reverse([]) |> should.equal(_, [])
+  list.reverse([1, 2, 3, 4, 5]) |> should.equal(_, [5, 4, 3, 2, 1])
 }
 
 pub fn is_empty_test() {
-  list.is_empty([]) |> expect.true
-  list.is_empty([1]) |> expect.false
+  list.is_empty([]) |> should.be_true
+  list.is_empty([1]) |> should.be_false
 }
 
 pub fn contains_test() {
-  list.contains([0, 4, 5, 1], 1) |> expect.true
-  list.contains([0, 4, 5, 7], 1) |> expect.false
-  list.contains([], 1) |> expect.false
+  list.contains([0, 4, 5, 1], 1) |> should.be_true
+  list.contains([0, 4, 5, 7], 1) |> should.be_false
+  list.contains([], 1) |> should.be_false
 }
 
 pub fn head_test() {
   list.head([0, 4, 5, 7])
-    |> expect.equal(_, Ok(0))
+    |> should.equal(_, Ok(0))
 
   list.head([])
-    |> expect.equal(_, Error(Nil))
+    |> should.equal(_, Error(Nil))
 }
 
 pub fn tail_test() {
   list.tail([0, 4, 5, 7])
-    |> expect.equal(_, Ok([4, 5, 7]))
+    |> should.equal(_, Ok([4, 5, 7]))
 
   list.tail([0])
-    |> expect.equal(_, Ok([]))
+    |> should.equal(_, Ok([]))
 
   list.tail([])
-    |> expect.equal(_, Error(Nil))
+    |> should.equal(_, Error(Nil))
 }
 
 pub fn filter_test() {
   []
     |> list.filter(_, fn(_) { True })
-    |> expect.equal(_, [])
+    |> should.equal(_, [])
 
   [0, 4, 5, 7, 3]
     |> list.filter(_, fn(_) { True })
-    |> expect.equal(_, [0, 4, 5, 7, 3])
+    |> should.equal(_, [0, 4, 5, 7, 3])
 
   [0, 4, 5, 7, 3]
     |> list.filter(_, fn(x) { x > 4 })
-    |> expect.equal(_, [5, 7])
+    |> should.equal(_, [5, 7])
 
   [0, 4, 5, 7, 3]
     |> list.filter(_, fn(x) { x < 4 })
-    |> expect.equal(_, [0, 3])
+    |> should.equal(_, [0, 3])
 }
 
 pub fn map_test() {
   []
     |> list.map(_, fn(x) { x * 2 })
-    |> expect.equal(_, [])
+    |> should.equal(_, [])
 
   [0, 4, 5, 7, 3]
     |> list.map(_, fn(x) { x * 2 })
-    |> expect.equal(_, [0, 8, 10, 14, 6])
+    |> should.equal(_, [0, 8, 10, 14, 6])
 }
 
 pub fn traverse_test() {
@@ -92,65 +92,65 @@ pub fn traverse_test() {
 
   [5, 6, 5, 6]
     |> list.traverse(_, fun)
-    |> expect.equal(_, Ok([10, 12, 10, 12]))
+    |> should.equal(_, Ok([10, 12, 10, 12]))
 
   [4, 6, 5, 7, 3]
     |> list.traverse(_, fun)
-    |> expect.equal(_, Error(7))
+    |> should.equal(_, Error(7))
 }
 
 pub fn drop_test() {
   []
     |> list.drop(_, 5)
-    |> expect.equal(_, [])
+    |> should.equal(_, [])
 
   [1, 2, 3, 4, 5, 6, 7, 8]
     |> list.drop(_, 5)
-    |> expect.equal(_, [6, 7, 8])
+    |> should.equal(_, [6, 7, 8])
 }
 
 pub fn take_test() {
   []
     |> list.take(_, 5)
-    |> expect.equal(_, [])
+    |> should.equal(_, [])
   [1, 2, 3, 4, 5, 6, 7, 8]
     |> list.take(_, 5)
-    |> expect.equal(_, [1, 2, 3, 4, 5])
+    |> should.equal(_, [1, 2, 3, 4, 5])
 }
 
 pub fn new_test() {
-  list.new() |> expect.equal(_, [])
+  list.new() |> should.equal(_, [])
 }
 
 pub fn append_test() {
   list.append([1], [2, 3])
-    |> expect.equal(_, [1, 2, 3])
+    |> should.equal(_, [1, 2, 3])
 }
 
 pub fn flatten_test() {
   list.flatten([])
-    |> expect.equal(_, [])
+    |> should.equal(_, [])
 
   list.flatten([[]])
-    |> expect.equal(_, [])
+    |> should.equal(_, [])
 
   list.flatten([[], [], []])
-    |> expect.equal(_, [])
+    |> should.equal(_, [])
 
   list.flatten([[1, 2], [], [3, 4]])
-    |> expect.equal(_, [1, 2, 3, 4])
+    |> should.equal(_, [1, 2, 3, 4])
 }
 
 pub fn fold_test() {
   [1, 2, 3]
     |> list.fold(_, [], fn(x, acc) { [x | acc] })
-    |> expect.equal(_, [3, 2, 1])
+    |> should.equal(_, [3, 2, 1])
 }
 
 pub fn fold_right_test() {
   [1, 2, 3]
   |> list.fold_right(_, from: [], with: fn(x, acc) { [x | acc] })
-  |> expect.equal(_, [1, 2, 3])
+  |> should.equal(_, [1, 2, 3])
 }
 
 pub fn find_map_test() {
@@ -163,15 +163,15 @@ pub fn find_map_test() {
 
   [1, 2, 3]
   |> list.find_map(_, with: f)
-  |> expect.equal(_, Ok(4))
+  |> should.equal(_, Ok(4))
 
   [1, 3, 2]
   |> list.find_map(_, with: f)
-  |> expect.equal(_, Ok(4))
+  |> should.equal(_, Ok(4))
 
   [1, 3]
   |> list.find_map(_, with: f)
-  |> expect.equal(_, Error(Nil))
+  |> should.equal(_, Error(Nil))
 }
 
 pub fn find_test() {
@@ -181,222 +181,222 @@ pub fn find_test() {
 
   [1, 2, 3]
   |> list.find(_, one_that: is_two)
-  |> expect.equal(_, Ok(2))
+  |> should.equal(_, Ok(2))
 
   [1, 3, 2]
   |> list.find(_, one_that: is_two)
-  |> expect.equal(_, Ok(2))
+  |> should.equal(_, Ok(2))
 
   [1, 3]
   |> list.find(_, one_that: is_two)
-  |> expect.equal(_, Error(Nil))
+  |> should.equal(_, Error(Nil))
 }
 
 pub fn all_test() {
   list.all([1, 2, 3, 4, 5], fn(x) { x > 0 })
-  |> expect.equal(_, True)
+  |> should.equal(_, True)
 
   list.all([1, 2, 3, 4, 5], fn(x) { x < 0 })
-  |> expect.equal(_, False)
+  |> should.equal(_, False)
 
   list.all([], fn(_) { False })
-  |> expect.equal(_, True)
+  |> should.equal(_, True)
 }
 
 pub fn any_test() {
   list.any([1, 2, 3, 4, 5], fn(x) { x == 2 })
-  |> expect.equal(_, True)
+  |> should.equal(_, True)
 
   list.any([1, 2, 3, 4, 5], fn(x) { x < 0 })
-  |> expect.equal(_, False)
+  |> should.equal(_, False)
 
   list.any([], fn(_) { False })
-  |> expect.equal(_, False)
+  |> should.equal(_, False)
 }
 
 pub fn zip_test() {
   list.zip([], [1, 2, 3])
-  |> expect.equal(_, [])
+  |> should.equal(_, [])
 
   list.zip([1, 2], [])
-  |> expect.equal(_, [])
+  |> should.equal(_, [])
 
   list.zip([1, 2, 3], [4, 5, 6])
-  |> expect.equal(_, [tuple(1, 4), tuple(2, 5), tuple(3, 6)])
+  |> should.equal(_, [tuple(1, 4), tuple(2, 5), tuple(3, 6)])
 
   list.zip([5, 6], [1, 2, 3])
-  |> expect.equal(_, [tuple(5, 1), tuple(6, 2)])
+  |> should.equal(_, [tuple(5, 1), tuple(6, 2)])
 
   list.zip([5, 6, 7], [1, 2])
-  |> expect.equal(_, [tuple(5, 1), tuple(6, 2)])
+  |> should.equal(_, [tuple(5, 1), tuple(6, 2)])
 }
 
 pub fn strict_zip_test() {
   list.strict_zip([], [1, 2, 3])
-  |> expect.equal(_, Error(list.LengthMismatch))
+  |> should.equal(_, Error(list.LengthMismatch))
 
   list.strict_zip([1, 2], [])
-  |> expect.equal(_, Error(list.LengthMismatch))
+  |> should.equal(_, Error(list.LengthMismatch))
 
   list.strict_zip([1, 2, 3], [4, 5, 6])
-  |> expect.equal(_, Ok([
+  |> should.equal(_, Ok([
     tuple(1, 4),
     tuple(2, 5),
     tuple(3, 6),
   ]))
 
   list.strict_zip([5, 6], [1, 2, 3])
-  |> expect.equal(_, Error(list.LengthMismatch))
+  |> should.equal(_, Error(list.LengthMismatch))
 
   list.strict_zip([5, 6, 7], [1, 2])
-  |> expect.equal(_, Error(list.LengthMismatch))
+  |> should.equal(_, Error(list.LengthMismatch))
 }
 
 pub fn intersperse_test() {
   list.intersperse([1, 2, 3], 4)
-  |> expect.equal(_, [1, 4, 2, 4, 3])
+  |> should.equal(_, [1, 4, 2, 4, 3])
 
   list.intersperse([], 2)
-  |> expect.equal(_, [])
+  |> should.equal(_, [])
 }
 
 pub fn at_test() {
   list.at([1, 2, 3], 2)
-  |> expect.equal(_, Ok(3))
+  |> should.equal(_, Ok(3))
 
   list.at([1, 2, 3], 5)
-  |> expect.equal(_, Error(Nil))
+  |> should.equal(_, Error(Nil))
 
   list.at([], 0)
-  |> expect.equal(_, Error(Nil))
+  |> should.equal(_, Error(Nil))
 
   list.at([1, 2, 3, 4, 5, 6], -1)
-  |> expect.equal(_, Error(Nil))
+  |> should.equal(_, Error(Nil))
 }
 
 pub fn unique_test() {
   list.unique([1, 1, 2, 3, 4, 4, 4, 5, 6])
-  |> expect.equal(_, [1, 2, 3, 4, 5, 6])
+  |> should.equal(_, [1, 2, 3, 4, 5, 6])
 
   list.unique([7, 1, 45, 6, 2, 47, 2, 7, 5])
-  |> expect.equal(_, [7, 1, 45, 6, 2, 47, 5])
+  |> should.equal(_, [7, 1, 45, 6, 2, 47, 5])
 
   list.unique([3, 4, 5])
-  |> expect.equal(_, [3, 4, 5])
+  |> should.equal(_, [3, 4, 5])
 
   list.unique([])
-  |> expect.equal(_, [])
+  |> should.equal(_, [])
 }
 
 pub fn sort_test() {
   [4, 3, 6, 5, 4]
   |> list.sort(_, int.compare)
-  |> expect.equal(_, [3, 4, 4, 5, 6])
+  |> should.equal(_, [3, 4, 4, 5, 6])
 
   [4, 3, 6, 5, 4, 1]
   |> list.sort(_, int.compare)
-  |> expect.equal(_, [1, 3, 4, 4, 5, 6])
+  |> should.equal(_, [1, 3, 4, 4, 5, 6])
 
   [4.1, 3.1, 6.1, 5.1, 4.1]
   |> list.sort(_, float.compare)
-  |> expect.equal(_, [3.1, 4.1, 4.1, 5.1, 6.1])
+  |> should.equal(_, [3.1, 4.1, 4.1, 5.1, 6.1])
 
   []
   |> list.sort(_, int.compare)
-  |> expect.equal(_, [])
+  |> should.equal(_, [])
 }
 
 pub fn index_map_test() {
   list.index_map([3, 4, 5], fn(i, x) { tuple(i, x) })
-  |> expect.equal(_, [tuple(0, 3), tuple(1, 4), tuple(2, 5)])
+  |> should.equal(_, [tuple(0, 3), tuple(1, 4), tuple(2, 5)])
 
   let f = fn(i, x) {
     string.append(x, int.to_string(i))
   }
   list.index_map(["a", "b", "c"], f)
-  |> expect.equal(_, ["a0", "b1", "c2"])
+  |> should.equal(_, ["a0", "b1", "c2"])
 }
 
 pub fn range_test() {
   list.range(0, 0)
-  |> expect.equal(_, [])
+  |> should.equal(_, [])
 
   list.range(1, 1)
-  |> expect.equal(_, [])
+  |> should.equal(_, [])
 
   list.range(-1, -1)
-  |> expect.equal(_, [])
+  |> should.equal(_, [])
 
   list.range(0, 1)
-  |> expect.equal(_, [0])
+  |> should.equal(_, [0])
 
   list.range(0, 5)
-  |> expect.equal(_, [0, 1, 2, 3, 4])
+  |> should.equal(_, [0, 1, 2, 3, 4])
 
   list.range(1, -5)
-  |> expect.equal(_, [1, 0, -1, -2, -3, -4])
+  |> should.equal(_, [1, 0, -1, -2, -3, -4])
 }
 
 pub fn repeat_test() {
   list.repeat(1, -10)
-  |> expect.equal(_, [])
+  |> should.equal(_, [])
 
   list.repeat(1, 0)
-  |> expect.equal(_, [])
+  |> should.equal(_, [])
 
   list.repeat(2, 3)
-  |> expect.equal(_, [2, 2, 2])
+  |> should.equal(_, [2, 2, 2])
 
   list.repeat("x", 5)
-  |> expect.equal(_, ["x", "x", "x", "x", "x"])
+  |> should.equal(_, ["x", "x", "x", "x", "x"])
 }
 
 pub fn split_test() {
   []
   |> list.split(_, 0)
-  |> expect.equal(_, tuple([], []))
+  |> should.equal(_, tuple([], []))
 
   [0, 1, 2, 3, 4]
   |> list.split(_, 0)
-  |> expect.equal(_, tuple([], [0, 1, 2, 3, 4]))
+  |> should.equal(_, tuple([], [0, 1, 2, 3, 4]))
 
   [0, 1, 2, 3, 4]
   |> list.split(_, -2)
-  |> expect.equal(_, tuple([], [0, 1, 2, 3, 4]))
+  |> should.equal(_, tuple([], [0, 1, 2, 3, 4]))
 
   [0, 1, 2, 3, 4]
   |> list.split(_, 1)
-  |> expect.equal(_, tuple([0], [1, 2, 3, 4]))
+  |> should.equal(_, tuple([0], [1, 2, 3, 4]))
 
   [0, 1, 2, 3, 4]
   |> list.split(_, 3)
-  |> expect.equal(_, tuple([0, 1, 2], [3, 4]))
+  |> should.equal(_, tuple([0, 1, 2], [3, 4]))
 
   [0, 1, 2, 3, 4]
   |> list.split(_, 9)
-  |> expect.equal(_, tuple([0, 1, 2, 3, 4], []))
+  |> should.equal(_, tuple([0, 1, 2, 3, 4], []))
 }
 
 pub fn split_while_test() {
   []
   |> list.split_while(_, fn(x) { x <= 5 })
-  |> expect.equal(_, tuple([], []))
+  |> should.equal(_, tuple([], []))
 
   [1, 2, 3, 4, 5]
   |> list.split_while(_, fn(x) { x <= 5 })
-  |> expect.equal(_, tuple([1, 2, 3, 4, 5], []))
+  |> should.equal(_, tuple([1, 2, 3, 4, 5], []))
 
   [1, 2, 3, 4, 5]
   |> list.split_while(_, fn(x) { x == 2 })
-  |> expect.equal(_, tuple([], [1, 2, 3, 4, 5]))
+  |> should.equal(_, tuple([], [1, 2, 3, 4, 5]))
 
   [1, 2, 3, 4, 5]
   |> list.split_while(_, fn(x) { x <= 3 })
-  |> expect.equal(_, tuple([1, 2, 3], [4, 5]))
+  |> should.equal(_, tuple([1, 2, 3], [4, 5]))
 
   [1, 2, 3, 4, 5]
   |> list.split_while(_, fn(x) { x <= -3 })
-  |> expect.equal(_, tuple([], [1, 2, 3, 4, 5]))
+  |> should.equal(_, tuple([], [1, 2, 3, 4, 5]))
 }
 
 
@@ -405,13 +405,13 @@ pub fn key_find_test() {
 
   proplist
   |> list.key_find(_, 0)
-  |> expect.equal(_, Ok("1"))
+  |> should.equal(_, Ok("1"))
 
   proplist
   |> list.key_find(_, 1)
-  |> expect.equal(_, Ok("2"))
+  |> should.equal(_, Ok("2"))
 
   proplist
   |> list.key_find(_, 2)
-  |> expect.equal(_, Error(Nil))
+  |> should.equal(_, Error(Nil))
 }
diff --git a/test/gleam/map_test.gleam b/test/gleam/map_test.gleam
index 6dcd3a1..27e47f6 100644
--- a/test/gleam/map_test.gleam
+++ b/test/gleam/map_test.gleam
@@ -1,5 +1,5 @@
 import gleam/string
-import gleam/expect
+import gleam/should
 import gleam/map
 
 pub fn from_list_test() {
@@ -9,21 +9,21 @@ pub fn from_list_test() {
   ]
   |> map.from_list
   |> map.size
-  |> expect.equal(_, 2)
+  |> should.equal(_, 2)
 }
 
 pub fn has_key_test() {
   []
   |> map.from_list
   |> map.has_key(_, 1)
-  |> expect.false
+  |> should.be_false
 
   [
       tuple(1, 0),
   ]
   |> map.from_list
   |> map.has_key(_, 1)
-  |> expect.true
+  |> should.be_true
 
   [
       tuple(4, 0),
@@ -31,7 +31,7 @@ pub fn has_key_test() {
   ]
   |> map.from_list
   |> map.has_key(_, 1)
-  |> expect.true
+  |> should.be_true
 
   [
     tuple(4, 0),
@@ -39,17 +39,17 @@ pub fn has_key_test() {
   ]
   |> map.from_list
   |> map.has_key(_, 0)
-  |> expect.false
+  |> should.be_false
 }
 
 pub fn new_test() {
   map.new()
   |> map.size
-  |> expect.equal(_, 0)
+  |> should.equal(_, 0)
 
   map.new()
   |> map.to_list
-  |> expect.equal(_, [])
+  |> should.equal(_, [])
 }
 
 pub fn get_test() {
@@ -61,15 +61,15 @@ pub fn get_test() {
 
   m
   |> map.get(_, 4)
-  |> expect.equal(_, Ok(0))
+  |> should.equal(_, Ok(0))
 
   m
   |> map.get(_, 1)
-  |> expect.equal(_, Ok(1))
+  |> should.equal(_, Ok(1))
 
   m
   |> map.get(_, 2)
-  |> expect.equal(_, Error(Nil))
+  |> should.equal(_, Error(Nil))
 }
 
 pub fn insert_test() {
@@ -77,7 +77,7 @@ pub fn insert_test() {
   |> map.insert(_, "a", 0)
   |> map.insert(_, "b", 1)
   |> map.insert(_, "c", 2)
-  |> expect.equal(_, map.from_list([
+  |> should.equal(_, map.from_list([
     tuple("a", 0),
     tuple("b", 1),
     tuple("c", 2),
@@ -92,7 +92,7 @@ pub fn map_values_test() {
   ]
   |> map.from_list
   |> map.map_values(_, fn(k, v) { k + v })
-  |> expect.equal(_, map.from_list([
+  |> should.equal(_, map.from_list([
     tuple(1, 1),
     tuple(2, 3),
     tuple(3, 5),
@@ -107,7 +107,7 @@ pub fn keys_test() {
   ]
   |> map.from_list
   |> map.keys
-  |> expect.equal(_, ["a", "b", "c"])
+  |> should.equal(_, ["a", "b", "c"])
 }
 
 pub fn values_test() {
@@ -118,7 +118,7 @@ pub fn values_test() {
   ]
   |> map.from_list
   |> map.values
-  |> expect.equal(_, [0, 1, 2])
+  |> should.equal(_, [0, 1, 2])
 }
 
 pub fn take_test() {
@@ -129,7 +129,7 @@ pub fn take_test() {
   ]
   |> map.from_list
   |> map.take(_, ["a", "b", "d"])
-  |> expect.equal(_, map.from_list([tuple("a", 0), tuple("b", 1)]))
+  |> should.equal(_, map.from_list([tuple("a", 0), tuple("b", 1)]))
 }
 
 pub fn drop_test() {
@@ -140,7 +140,7 @@ pub fn drop_test() {
   ]
   |> map.from_list
   |> map.drop(_, ["a", "b", "d"])
-  |> expect.equal(_, map.from_list([tuple("c", 2)]))
+  |> should.equal(_, map.from_list([tuple("c", 2)]))
 }
 
 pub fn merge_test() {
@@ -156,7 +156,7 @@ pub fn merge_test() {
   ])
 
   map.merge(a, b)
-  |> expect.equal(_, map.from_list([
+  |> should.equal(_, map.from_list([
       tuple("a", 0),
       tuple("b", 1),
       tuple("c", 2),
@@ -164,7 +164,7 @@ pub fn merge_test() {
     ]))
 
   map.merge(b, a)
-  |> expect.equal(_, map.from_list([
+  |> should.equal(_, map.from_list([
       tuple("a", 2),
       tuple("b", 1),
       tuple("c", 4),
@@ -181,7 +181,7 @@ pub fn delete_test() {
   |> map.from_list
   |> map.delete(_, "a")
   |> map.delete(_, "d")
-  |> expect.equal(_, map.from_list([tuple("b", 1), tuple("c", 2)]))
+  |> should.equal(_, map.from_list([tuple("b", 1), tuple("c", 2)]))
 }
 
 pub fn update_test() {
@@ -200,7 +200,7 @@ pub fn update_test() {
 
   dict
   |> map.update(_, "a", inc_or_zero)
-  |> expect.equal(_, map.from_list([
+  |> should.equal(_, map.from_list([
     tuple("a", 1),
     tuple("b", 1),
     tuple("c", 2),
@@ -208,7 +208,7 @@ pub fn update_test() {
 
   dict
   |> map.update(_, "b", inc_or_zero)
-  |> expect.equal(_, map.from_list([
+  |> should.equal(_, map.from_list([
     tuple("a", 0),
     tuple("b", 2),
     tuple("c", 2),
@@ -216,7 +216,7 @@ pub fn update_test() {
 
   dict
   |> map.update(_, "z", inc_or_zero)
-  |> expect.equal(_, map.from_list([
+  |> should.equal(_, map.from_list([
     tuple("a", 0),
     tuple("b", 1),
     tuple("c", 2),
@@ -238,7 +238,7 @@ pub fn fold_test() {
 
   dict
   |> map.fold(_, 0, add)
-  |> expect.equal(_, 6)
+  |> should.equal(_, 6)
 
   let concat = fn(k, _, acc) {
     string.append(acc, k)
@@ -246,9 +246,9 @@ pub fn fold_test() {
 
   dict
   |> map.fold(_, "", concat)
-  |> expect.equal(_, "abcd")
+  |> should.equal(_, "abcd")
 
   map.from_list([])
   |> map.fold(_, 0, add)
-  |> expect.equal(_, 0)
+  |> should.equal(_, 0)
 }
diff --git a/test/gleam/order_test.gleam b/test/gleam/order_test.gleam
index 3d50bf1..d071775 100644
--- a/test/gleam/order_test.gleam
+++ b/test/gleam/order_test.gleam
@@ -1,111 +1,111 @@
-import gleam/expect
+import gleam/should
 import gleam/order.{Lt, Eq, Gt}
 
 pub fn reverse_test() {
   order.reverse(Lt)
-  |> expect.equal(_, Gt)
+  |> should.equal(_, Gt)
 
   order.reverse(order.Eq)
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 
   order.reverse(Gt)
-  |> expect.equal(_, Lt)
+  |> should.equal(_, Lt)
 }
 
 pub fn to_int_test() {
   order.to_int(Lt)
-  |> expect.equal(_, -1)
+  |> should.equal(_, -1)
 
   order.to_int(order.Eq)
-  |> expect.equal(_, 0)
+  |> should.equal(_, 0)
 
   order.to_int(Gt)
-  |> expect.equal(_, 1)
+  |> should.equal(_, 1)
 }
 
 pub fn compare_test() {
   order.compare(Lt, Lt)
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 
   order.compare(Lt, order.Eq)
-  |> expect.equal(_, Lt)
+  |> should.equal(_, Lt)
 
   order.compare(Lt, Gt)
-  |> expect.equal(_, Lt)
+  |> should.equal(_, Lt)
 
   order.compare(order.Eq, Lt)
-  |> expect.equal(_, Gt)
+  |> should.equal(_, Gt)
 
   order.compare(order.Eq, order.Eq)
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 
   order.compare(order.Eq, Gt)
-  |> expect.equal(_, Lt)
+  |> should.equal(_, Lt)
 
   order.compare(Gt, Lt)
-  |> expect.equal(_, Gt)
+  |> should.equal(_, Gt)
 
   order.compare(Gt, order.Eq)
-  |> expect.equal(_, Gt)
+  |> should.equal(_, Gt)
 
   order.compare(Gt, Gt)
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 }
 
 pub fn max_test() {
   order.max(Lt, Lt)
-  |> expect.equal(_, Lt)
+  |> should.equal(_, Lt)
 
   order.max(Lt, order.Eq)
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 
   order.max(Lt, Gt)
-  |> expect.equal(_, Gt)
+  |> should.equal(_, Gt)
 
   order.max(order.Eq, Lt)
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 
   order.max(order.Eq, order.Eq)
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 
   order.max(order.Eq, Gt)
-  |> expect.equal(_, Gt)
+  |> should.equal(_, Gt)
 
   order.max(Gt, Lt)
-  |> expect.equal(_, Gt)
+  |> should.equal(_, Gt)
 
   order.max(Gt, order.Eq)
-  |> expect.equal(_, Gt)
+  |> should.equal(_, Gt)
 
   order.max(Gt, Gt)
-  |> expect.equal(_, Gt)
+  |> should.equal(_, Gt)
 }
 
 pub fn min_test() {
   order.min(Lt, Lt)
-  |> expect.equal(_, Lt)
+  |> should.equal(_, Lt)
 
   order.min(Lt, order.Eq)
-  |> expect.equal(_, Lt)
+  |> should.equal(_, Lt)
 
   order.min(Lt, Gt)
-  |> expect.equal(_, Lt)
+  |> should.equal(_, Lt)
 
   order.min(order.Eq, Lt)
-  |> expect.equal(_, Lt)
+  |> should.equal(_, Lt)
 
   order.min(order.Eq, order.Eq)
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 
   order.min(order.Eq, Gt)
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 
   order.min(Gt, Lt)
-  |> expect.equal(_, Lt)
+  |> should.equal(_, Lt)
 
   order.min(Gt, order.Eq)
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 
   order.min(Gt, Gt)
-  |> expect.equal(_, Gt)
+  |> should.equal(_, Gt)
 }
diff --git a/test/gleam/pair_test.gleam b/test/gleam/pair_test.gleam
index 96b771b..d9a5eb6 100644
--- a/test/gleam/pair_test.gleam
+++ b/test/gleam/pair_test.gleam
@@ -1,30 +1,30 @@
-import gleam/expect
+import gleam/should
 import gleam/pair
 
 pub fn first_test() {
   tuple(1, 2)
   |> pair.first
-  |> expect.equal(_, 1)
+  |> should.equal(_, 1)
 
   tuple("abc", [])
   |> pair.first
-  |> expect.equal(_, "abc")
+  |> should.equal(_, "abc")
 }
 
 pub fn second_test() {
   tuple(1, 2)
   |> pair.second
-  |> expect.equal(_, 2)
+  |> should.equal(_, 2)
 
   tuple("abc", [])
   |> pair.second
-  |> expect.equal(_,[])
+  |> should.equal(_,[])
 }
 
 pub fn swap_test() {
   tuple(1, "2")
   |> pair.swap
-  |> expect.equal(_, tuple("2", 1))
+  |> should.equal(_, tuple("2", 1))
 }
 
 pub fn map_first_test() {
@@ -32,16 +32,16 @@ pub fn map_first_test() {
       a + 1
   }
   pair.map_first(tuple(1, 2), inc)
-  |> expect.equal(_, tuple(2, 2))
+  |> should.equal(_, tuple(2, 2))
 
   pair.map_first(tuple(8,2), inc)
-  |> expect.equal(_, tuple(9, 2))
+  |> should.equal(_, tuple(9, 2))
 
   pair.map_first(tuple(0,-2), inc)
-  |> expect.equal(_, tuple(1, -2))
+  |> should.equal(_, tuple(1, -2))
 
   pair.map_first(tuple(-10, 20), inc)
-  |> expect.equal(_, tuple(-9, 20))
+  |> should.equal(_, tuple(-9, 20))
 }
 
 pub fn map_second_test() {
@@ -49,14 +49,14 @@ pub fn map_second_test() {
       a - 1
   }
   pair.map_second(tuple(1, 2), dec)
-  |> expect.equal(_, tuple(1, 1))
+  |> should.equal(_, tuple(1, 1))
 
   pair.map_second(tuple(8,2), dec)
-  |> expect.equal(_, tuple(8, 1))
+  |> should.equal(_, tuple(8, 1))
 
   pair.map_second(tuple(0,-2), dec)
-  |> expect.equal(_, tuple(0, -3))
+  |> should.equal(_, tuple(0, -3))
 
   pair.map_second(tuple(-10, 20), dec)
-  |> expect.equal(_, tuple(-10, 19))
+  |> should.equal(_, tuple(-10, 19))
 }
diff --git a/test/gleam/result_test.gleam b/test/gleam/result_test.gleam
index 4fab1ad..2d2f344 100644
--- a/test/gleam/result_test.gleam
+++ b/test/gleam/result_test.gleam
@@ -1,88 +1,88 @@
-import gleam/expect
+import gleam/should
 import gleam/result
 
 pub fn is_ok_test() {
   result.is_ok(Ok(1))
-  |> expect.true
+  |> should.be_true
 
   result.is_ok(Error(1))
-  |> expect.false
+  |> should.be_false
 }
 
 pub fn is_error_test() {
   result.is_error(Ok(1))
-  |> expect.false
+  |> should.be_false
 
   result.is_error(Error(1))
-  |> expect.true
+  |> should.be_true
 }
 
 pub fn map_test() {
   Ok(1)
   |> result.map(_, fn(x) { x + 1 })
-  |> expect.equal(_, Ok(2))
+  |> should.equal(_, Ok(2))
 
   Ok(1)
   |> result.map(_, fn(_) { "2" })
-  |> expect.equal(_, Ok("2"))
+  |> should.equal(_, Ok("2"))
 
   Error(1)
   |> result.map(_, fn(x) { x + 1 })
-  |> expect.equal(_, Error(1))
+  |> should.equal(_, Error(1))
 }
 
 pub fn map_error_test() {
   Ok(1)
   |> result.map_error(_, fn(x) { x + 1 })
-  |> expect.equal(_, Ok(1))
+  |> should.equal(_, Ok(1))
 
   Error(1)
   |> result.map_error(_, fn(x) { tuple("ok", x + 1) })
-  |> expect.equal(_, Error(tuple("ok", 2)))
+  |> should.equal(_, Error(tuple("ok", 2)))
 }
 
 pub fn flatten_test() {
   Ok(Ok(1))
   |> result.flatten
-  |> expect.equal(_, Ok(1))
+  |> should.equal(_, Ok(1))
 
   Ok(Error(1))
   |> result.flatten
-  |> expect.equal(_, Error(1))
+  |> should.equal(_, Error(1))
 
   Error(1)
   |> result.flatten
-  |> expect.equal(_, Error(1))
+  |> should.equal(_, Error(1))
 
   Error(Error(1))
   |> result.flatten
-  |> expect.equal(_, Error(Error(1)))
+  |> should.equal(_, Error(Error(1)))
 }
 
 pub fn then_test() {
   Error(1)
   |> result.then(_, fn(x) { Ok(x + 1) })
-  |> expect.equal(_, Error(1))
+  |> should.equal(_, Error(1))
 
   Ok(1)
   |> result.then(_, fn(x) { Ok(x + 1) })
-  |> expect.equal(_, Ok(2))
+  |> should.equal(_, Ok(2))
 
   Ok(1)
   |> result.then(_, fn(_) { Ok("type change") })
-  |> expect.equal(_, Ok("type change"))
+  |> should.equal(_, Ok("type change"))
 
   Ok(1)
   |> result.then(_, fn(_) { Error(1) })
-  |> expect.equal(_, Error(1))
+  |> should.equal(_, Error(1))
 }
 
 pub fn unwrap_test() {
   Ok(1)
   |> result.unwrap(_, 50)
-  |> expect.equal(_, 1)
+  |> should.equal(_, 1)
 
   Error("nope")
   |> result.unwrap(_, 50)
-  |> expect.equal(_, 50)
+  |> should.equal(_, 50)
 }
diff --git a/test/gleam/string_test.gleam b/test/gleam/string_test.gleam
index 3f278f6..ae8a0e9 100644
--- a/test/gleam/string_test.gleam
+++ b/test/gleam/string_test.gleam
@@ -1,70 +1,70 @@
 import gleam/string
-import gleam/expect
+import gleam/should
 import gleam/order
 
 pub fn length_test() {
   string.length("ß↑e̊")
-  |> expect.equal(_, 3)
+  |> should.equal(_, 3)
 
   string.length("Gleam")
-  |> expect.equal(_, 5)
+  |> should.equal(_, 5)
 
   string.length("")
-  |> expect.equal(_, 0)
+  |> should.equal(_, 0)
 }
 
 pub fn lowercase_test() {
   string.lowercase("Gleam")
-  |> expect.equal(_, "gleam")
+  |> should.equal(_, "gleam")
 }
 
 pub fn uppercase_test() {
   string.uppercase("Gleam")
-  |> expect.equal(_, "GLEAM")
+  |> should.equal(_, "GLEAM")
 }
 
 pub fn reverse_test() {
   string.reverse("Gleam")
-  |> expect.equal(_, "maelG")
+  |> should.equal(_, "maelG")
 }
 
 pub fn split_test() {
   "Gleam,Erlang,Elixir"
   |> string.split(_, ",")
-  |> expect.equal(_, ["Gleam", "Erlang", "Elixir"])
+  |> should.equal(_, ["Gleam", "Erlang", "Elixir"])
 
   "Gleam, Erlang,Elixir"
   |> string.split(_, ", ")
-  |> expect.equal(_, ["Gleam", "Erlang,Elixir"])
+  |> should.equal(_, ["Gleam", "Erlang,Elixir"])
 }
 
 pub fn replace_test() {
   "Gleam,Erlang,Elixir"
   |> string.replace(_, ",", "++")
-  |> expect.equal(_, "Gleam++Erlang++Elixir")
+  |> should.equal(_, "Gleam++Erlang++Elixir")
 }
 
 pub fn append_test() {
   "Test"
   |> string.append(_, " Me")
-  |> expect.equal(_, "Test Me")
+  |> should.equal(_, "Test Me")
 }
 
 pub fn compare_test() {
   string.compare("", "")
-  |> expect.equal(_, order.Eq)
+  |> should.equal(_, order.Eq)
 
   string.compare("a", "")
-  |> expect.equal(_, order.Gt)
+  |> should.equal(_, order.Gt)
 
   string.compare("a", "A")
-  |> expect.equal(_, order.Gt)
+  |> should.equal(_, order.Gt)
 
   string.compare("A", "B")
-  |> expect.equal(_, order.Lt)
+  |> should.equal(_, order.Lt)
 
   string.compare("t", "ABC")
-  |> expect.equal(_, order.Gt)
+  |> should.equal(_, order.Gt)
 }
 
 pub fn concat_test() {
@@ -72,7 +72,7 @@ pub fn concat_test() {
     "Hello", ", ", "world!",
   ]
   |> string.concat
-  |> expect.equal(_, "Hello, world!")
+  |> should.equal(_, "Hello, world!")
 }
 
 pub fn join_test() {
@@ -80,11 +80,11 @@ pub fn join_test() {
     "Hello", "world!",
   ]
   |> string.join(_, with: ", ")
-  |> expect.equal(_, "Hello, world!")
+  |> should.equal(_, "Hello, world!")
 
   [
     "Hello", "world!",
   ]
   |> string.join(_, with: "-")
-  |> expect.equal(_, "Hello-world!")
+  |> should.equal(_, "Hello-world!")
 }