From 2c2541750ca4b7b604070c75c18d84be833c97d5 Mon Sep 17 00:00:00 2001
From: Louis Pilfold <louis@lpil.uk>
Date: Tue, 25 Jun 2019 22:48:07 +0100
Subject: stdlib namespace std -> gleam

---
 test/gleam/any_test.gleam      | 278 ++++++++++++++++++++++++++++++++
 test/gleam/atom_test.gleam     |  46 ++++++
 test/gleam/bool_test.gleam     |  61 +++++++
 test/gleam/float_test.gleam    | 118 ++++++++++++++
 test/gleam/http_test.gleam     |   1 +
 test/gleam/int_test.gleam      |  73 +++++++++
 test/gleam/iodata_test.gleam   |  90 +++++++++++
 test/gleam/list_test.gleam     | 351 +++++++++++++++++++++++++++++++++++++++++
 test/gleam/map_dict_test.gleam | 233 +++++++++++++++++++++++++++
 test/gleam/order_test.gleam    | 111 +++++++++++++
 test/gleam/result_test.gleam   |  88 +++++++++++
 test/gleam/string_test.gleam   |  50 ++++++
 test/gleam/tuple_test.gleam    |  44 ++++++
 test/std/any_test.gleam        | 278 --------------------------------
 test/std/atom_test.gleam       |  46 ------
 test/std/bool_test.gleam       |  61 -------
 test/std/float_test.gleam      | 118 --------------
 test/std/http_test.gleam       |   1 -
 test/std/int_test.gleam        |  73 ---------
 test/std/iodata_test.gleam     |  90 -----------
 test/std/list_test.gleam       | 351 -----------------------------------------
 test/std/map_dict_test.gleam   | 233 ---------------------------
 test/std/order_test.gleam      | 111 -------------
 test/std/result_test.gleam     |  88 -----------
 test/std/string_test.gleam     |  50 ------
 test/std/tuple_test.gleam      |  44 ------
 26 files changed, 1544 insertions(+), 1544 deletions(-)
 create mode 100644 test/gleam/any_test.gleam
 create mode 100644 test/gleam/atom_test.gleam
 create mode 100644 test/gleam/bool_test.gleam
 create mode 100644 test/gleam/float_test.gleam
 create mode 100644 test/gleam/http_test.gleam
 create mode 100644 test/gleam/int_test.gleam
 create mode 100644 test/gleam/iodata_test.gleam
 create mode 100644 test/gleam/list_test.gleam
 create mode 100644 test/gleam/map_dict_test.gleam
 create mode 100644 test/gleam/order_test.gleam
 create mode 100644 test/gleam/result_test.gleam
 create mode 100644 test/gleam/string_test.gleam
 create mode 100644 test/gleam/tuple_test.gleam
 delete mode 100644 test/std/any_test.gleam
 delete mode 100644 test/std/atom_test.gleam
 delete mode 100644 test/std/bool_test.gleam
 delete mode 100644 test/std/float_test.gleam
 delete mode 100644 test/std/http_test.gleam
 delete mode 100644 test/std/int_test.gleam
 delete mode 100644 test/std/iodata_test.gleam
 delete mode 100644 test/std/list_test.gleam
 delete mode 100644 test/std/map_dict_test.gleam
 delete mode 100644 test/std/order_test.gleam
 delete mode 100644 test/std/result_test.gleam
 delete mode 100644 test/std/string_test.gleam
 delete mode 100644 test/std/tuple_test.gleam

(limited to 'test')

diff --git a/test/gleam/any_test.gleam b/test/gleam/any_test.gleam
new file mode 100644
index 0000000..7a968c2
--- /dev/null
+++ b/test/gleam/any_test.gleam
@@ -0,0 +1,278 @@
+import gleam/any
+import gleam/atom
+import gleam/list
+import gleam/tuple
+import gleam/expect
+import gleam/result
+
+pub fn string_test() {
+  ""
+  |> any:from
+  |> any:string
+  |> expect:equal(_, Ok(""))
+
+  "Hello"
+  |> any:from
+  |> any:string
+  |> expect:equal(_, Ok("Hello"))
+
+  1
+  |> any:from
+  |> any:string
+  |> expect:equal(_, Error("Expected a String, got `1`"))
+
+  []
+  |> any:from
+  |> any:string
+  |> expect:equal(_, Error("Expected a String, got `[]`"))
+}
+
+pub fn int_test() {
+  1
+  |> any:from
+  |> any:int
+  |> expect:equal(_, Ok(1))
+
+  2
+  |> any:from
+  |> any:int
+  |> expect:equal(_, Ok(2))
+
+  1.0
+  |> any:from
+  |> any:int
+  |> expect:equal(_, Error("Expected an Int, got `1.0`"))
+
+  []
+  |> any:from
+  |> any:int
+  |> expect:equal(_, Error("Expected an Int, got `[]`"))
+}
+
+pub fn float_test() {
+  1.0
+  |> any:from
+  |> any:float
+  |> expect:equal(_, Ok(1.0))
+
+  2.2
+  |> any:from
+  |> any:float
+  |> expect:equal(_, Ok(2.2))
+
+  1
+  |> any:from
+  |> any:float
+  |> expect:equal(_, Error("Expected a Float, got `1`"))
+
+  []
+  |> any:from
+  |> any:float
+  |> expect:equal(_, Error("Expected a Float, got `[]`"))
+}
+
+// pub fn atom_test() {
+//   make an atom here
+//     |> any:from
+//     |> atom
+//     |> expect:equal(_, Ok(""))
+
+//   make an atom here
+//     |> any:from
+//     |> atom
+//     |> expect:equal(_, Ok("ok"))
+
+//   1
+//     |> any:from
+//     |> atom
+//     |> expect:is_error
+
+//   []
+//     |> any:from
+//     |> atom
+//     |> expect:is_error
+// }
+
+pub fn thunk_test() {
+  fn() { 1 }
+  |> any:from
+  |> any:thunk
+  |> expect:is_ok
+
+  fn() { 1 }
+  |> any:from
+  |> any:thunk
+  |> result:map(_, fn(f) { f() })
+  |> expect:equal(_, Ok(any:from(1)))
+
+  fn(x) { x }
+  |> any:from
+  |> any:thunk
+  |> expect:is_error
+
+  1
+  |> any:from
+  |> any:thunk
+  |> expect:is_error
+
+  []
+  |> any:from
+  |> any:thunk
+  |> expect:is_error
+}
+
+pub fn bool_test() {
+  True
+  |> any:from
+  |> any:bool
+  |> expect:equal(_, Ok(True))
+
+  False
+  |> any:from
+  |> any:bool
+  |> expect:equal(_, Ok(False))
+
+  1
+  |> any:from
+  |> any:bool
+  |> expect:equal(_, Error("Expected a Bool, got `1`"))
+
+  []
+  |> any:from
+  |> any:bool
+  |> expect:equal(_, Error("Expected a Bool, got `[]`"))
+}
+
+pub fn atom_test() {
+  ""
+    |> atom:create_from_string
+    |> any:from
+    |> any:atom
+    |> expect:equal(_, Ok(atom:create_from_string("")))
+
+  "ok"
+    |> atom:create_from_string
+    |> any:from
+    |> any:atom
+    |> expect:equal(_, Ok(atom:create_from_string("ok")))
+
+  1
+    |> any:from
+    |> any:atom
+    |> expect:is_error
+
+  []
+    |> any:from
+    |> any:atom
+    |> expect:is_error
+}
+
+pub fn list_test() {
+  []
+  |> any:from
+  |> any:list(_, any:string)
+  |> expect:equal(_, Ok([]))
+
+  []
+  |> any:from
+  |> any:list(_, any:int)
+  |> expect:equal(_, Ok([]))
+
+  [1, 2, 3]
+  |> any:from
+  |> any:list(_, any:int)
+  |> expect:equal(_, Ok([1, 2, 3]))
+
+  [[1], [2], [3]]
+  |> any:from
+  |> any:list(_, any:list(_, any:int))
+  |> expect:equal(_, Ok([[1], [2], [3]]))
+
+  1
+  |> any:from
+  |> any:list(_, any:string)
+  |> expect:is_error
+
+  1.0
+  |> any:from
+  |> any:list(_, any:int)
+  |> expect:is_error
+
+  [""]
+  |> any:from
+  |> any:list(_, any:int)
+  |> expect:is_error
+
+  [any:from(1), any:from("not an int")]
+  |> any:from
+  |> any:list(_, any:int)
+  |> expect:is_error
+}
+
+pub fn tuple_test() {
+  {1, []}
+  |> any:from
+  |> any:tuple
+  |> expect:equal(_, Ok({any:from(1), any:from([])}))
+
+  {"ok", "ok"}
+  |> any:from
+  |> any:tuple
+  |> expect:equal(_, Ok({any:from("ok"), any:from("ok")}))
+
+  {1}
+  |> any:from
+  |> any:tuple
+  |> expect:is_error
+
+  {1, 2, 3}
+  |> any:from
+  |> any:tuple
+  |> expect:is_error
+
+  {1, 2.0}
+  |> any:from
+  |> any:tuple
+  |> result:then(_, fn(x) {
+    x
+    |> tuple:first
+    |> any:int
+    |> result:map(_, fn(f) { {f, tuple:second(x)} })
+  })
+  |> result:then(_, fn(x) {
+    x
+    |> tuple:second
+    |> any:float
+    |> result:map(_, fn(f) { {tuple:first(x), f} })
+  })
+  |> expect:equal(_, Ok({1, 2.0}))
+}
+
+pub fn field_test() {
+  let Ok(ok_atom) = atom:from_string("ok")
+
+  {ok = 1}
+  |> any:from
+  |> any:field(_, ok_atom)
+  |> expect:equal(_, Ok(any:from(1)))
+
+  {earlier = 2, ok = 3}
+  |> any:from
+  |> any:field(_, ok_atom)
+  |> expect:equal(_, Ok(any:from(3)))
+
+  {}
+  |> any:from
+  |> any:field(_, ok_atom)
+  |> expect:is_error
+
+  1
+  |> any:from
+  |> any:field(_, ok_atom)
+  |> expect:is_error
+
+  []
+  |> any:from
+  |> any:field(_, [])
+  |> expect:is_error
+}
diff --git a/test/gleam/atom_test.gleam b/test/gleam/atom_test.gleam
new file mode 100644
index 0000000..8054aaf
--- /dev/null
+++ b/test/gleam/atom_test.gleam
@@ -0,0 +1,46 @@
+import gleam/atom
+import gleam/expect
+
+pub fn from_string_test() {
+  "ok"
+  |> atom:from_string
+  |> expect:is_ok
+
+  "expect"
+  |> atom:from_string
+  |> expect:is_ok
+
+  "this is not an atom we have seen before"
+  |> atom:from_string
+  // |> expect:equal(_, Error(AtomNotLoaded))
+  |> expect:is_error
+}
+
+pub fn create_from_string_test() {
+  "ok"
+  |> atom:create_from_string
+  |> Ok
+  |> expect:equal(_, atom:from_string("ok"))
+
+  "expect"
+  |> atom:create_from_string
+  |> Ok
+  |> expect: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"))
+}
+
+pub fn to_string_test() {
+  "ok"
+  |> atom:create_from_string
+  |> atom:to_string
+  |> expect:equal(_, "ok")
+
+  "expect"
+  |> atom:create_from_string
+  |> atom:to_string
+  |> expect:equal(_, "expect")
+}
diff --git a/test/gleam/bool_test.gleam b/test/gleam/bool_test.gleam
new file mode 100644
index 0000000..1f18f71
--- /dev/null
+++ b/test/gleam/bool_test.gleam
@@ -0,0 +1,61 @@
+import gleam/bool
+import gleam/order
+import gleam/expect
+
+pub fn negate_test() {
+  bool:negate(True)
+  |> expect:false
+
+  bool:negate(False)
+  |> expect:true
+}
+
+pub fn compare_test() {
+  bool:compare(True, True)
+  |> expect:equal(_, order:Eq)
+
+  bool:compare(True, False)
+  |> expect:equal(_, order:Gt)
+
+  bool:compare(False, False)
+  |> expect:equal(_, order:Eq)
+
+  bool:compare(False, True)
+  |> expect:equal(_, order:Lt)
+}
+
+pub fn max_test() {
+  bool:max(True, True)
+  |> expect:equal(_, True)
+
+  bool:max(True, False)
+  |> expect:equal(_, True)
+
+  bool:max(False, False)
+  |> expect:equal(_, False)
+
+  bool:max(False, True)
+  |> expect:equal(_, True)
+}
+
+pub fn min_test() {
+  bool:min(True, True)
+  |> expect:equal(_, True)
+
+  bool:min(True, False)
+  |> expect:equal(_, False)
+
+  bool:min(False, False)
+  |> expect:equal(_, False)
+
+  bool:min(False, True)
+  |> expect:equal(_, False)
+}
+
+pub fn to_int_test() {
+  bool:to_int(True)
+  |> expect:equal(_, 1)
+
+  bool:to_int(False)
+  |> expect:equal(_, 0)
+}
diff --git a/test/gleam/float_test.gleam b/test/gleam/float_test.gleam
new file mode 100644
index 0000000..41b5ed1
--- /dev/null
+++ b/test/gleam/float_test.gleam
@@ -0,0 +1,118 @@
+import gleam/expect
+import gleam/float
+
+pub fn parse_test() {
+  "1.23"
+  |> float:parse
+  |> expect:equal(_, Ok(1.23))
+
+  "5.0"
+  |> float:parse
+  |> expect:equal(_, Ok(5.0))
+
+  "0.123456789"
+  |> float:parse
+  |> expect:equal(_, Ok(0.123456789))
+
+  ""
+  |> float:parse
+  |> expect:is_error
+
+  "what"
+  |> float:parse
+  |> expect:is_error
+
+  "1"
+  |> float:parse
+  |> expect:is_error
+}
+
+pub fn to_string_test() {
+  123.0
+  |> float:to_string
+  |> expect:equal(_, "123.0")
+
+  -8.1
+  |> float:to_string
+  |> expect:equal(_, "-8.1")
+}
+
+pub fn ceiling_test() {
+  8.1
+  |> float:ceiling
+  |> expect:equal(_, 9.0)
+
+  -8.1
+  |> float:ceiling
+  |> expect:equal(_, -8.0)
+
+  -8.0
+  |> float:ceiling
+  |> expect:equal(_, -8.0)
+}
+
+pub fn floor_test() {
+  8.1
+  |> float:floor
+  |> expect:equal(_, 8.0)
+
+  -8.1
+  |> float:floor
+  |> expect:equal(_, -9.0)
+
+  -8.0
+  |> float:floor
+  |> expect:equal(_, -8.0)
+}
+
+pub fn round_test() {
+  8.1
+  |> float:round
+  |> expect:equal(_, 8)
+
+  8.4
+  |> float:round
+  |> expect:equal(_, 8)
+
+  8.499
+  |> float:round
+  |> expect:equal(_, 8)
+
+  8.5
+  |> float:round
+  |> expect:equal(_, 9)
+
+  -8.1
+  |> float:round
+  |> expect:equal(_, -8)
+
+  -7.5
+  |> float:round
+  |> expect:equal(_, -8)
+}
+
+pub fn truncate_test() {
+  8.1
+  |> float:truncate
+  |> expect:equal(_, 8)
+
+  8.4
+  |> float:truncate
+  |> expect:equal(_, 8)
+
+  8.499
+  |> float:truncate
+  |> expect:equal(_, 8)
+
+  8.5
+  |> float:truncate
+  |> expect:equal(_, 8)
+
+  -8.1
+  |> float:truncate
+  |> expect:equal(_, -8)
+
+  -7.5
+  |> float:truncate
+  |> expect:equal(_, -7)
+}
diff --git a/test/gleam/http_test.gleam b/test/gleam/http_test.gleam
new file mode 100644
index 0000000..9941d56
--- /dev/null
+++ b/test/gleam/http_test.gleam
@@ -0,0 +1 @@
+// Nothing here yet...
diff --git a/test/gleam/int_test.gleam b/test/gleam/int_test.gleam
new file mode 100644
index 0000000..c7fe9e9
--- /dev/null
+++ b/test/gleam/int_test.gleam
@@ -0,0 +1,73 @@
+import gleam/expect
+import gleam/int
+import gleam/order
+
+pub fn to_string() {
+  123
+  |> int:to_string
+  |> expect:equal(_, "123")
+
+  -123
+  |> int:to_string
+  |> expect:equal(_, "-123")
+
+  0123
+  |> int:to_string
+  |> expect:equal(_, "123")
+}
+
+pub fn parse() {
+  "123"
+  |> int:parse
+  |> expect:equal(_, Ok(123))
+
+  "-123"
+  |> int:parse
+  |> expect:equal(_, Ok(-123))
+
+  "0123"
+  |> int:parse
+  |> expect:equal(_, Ok(123))
+
+  ""
+  |> int:parse
+  |> expect:is_error
+
+  "what"
+  |> int:parse
+  |> expect:is_error
+
+  "1.23"
+  |> int:parse
+  |> expect:is_error
+}
+
+pub fn to_base_string() {
+  100
+  |> int:to_base_string(_, 16)
+  |> expect:equal(_, "64")
+
+  -100
+  |> int:to_base_string(_, 16)
+  |> expect:equal(_, "-64")
+}
+
+pub fn compare_test() {
+  int:compare(0, 0)
+  |> expect:equal(_, order:Eq)
+
+  int:compare(1, 1)
+  |> expect:equal(_, order:Eq)
+
+  int:compare(0, 1)
+  |> expect:equal(_, order:Lt)
+
+  int:compare(-2, -1)
+  |> expect:equal(_, order:Lt)
+
+  int:compare(2, 1)
+  |> expect:equal(_, order:Gt)
+
+  int:compare(-1, -2)
+  |> expect:equal(_, order:Gt)
+}
diff --git a/test/gleam/iodata_test.gleam b/test/gleam/iodata_test.gleam
new file mode 100644
index 0000000..1684a81
--- /dev/null
+++ b/test/gleam/iodata_test.gleam
@@ -0,0 +1,90 @@
+import gleam/expect
+import gleam/iodata
+
+pub fn iodata_test() {
+  let data = iodata:new("ello")
+    |> iodata:append(_, ",")
+    |> iodata:append(_, " world!")
+    |> iodata:prepend(_, "H")
+
+  data
+  |> iodata:to_string
+  |> expect:equal(_, "Hello, world!")
+
+  data
+  |> iodata:byte_size
+  |> expect:equal(_, 13)
+
+  let data = iodata:new("ello")
+    |> iodata:append_iodata(_, iodata:new(","))
+    |> iodata:append_iodata(_, iodata:concat([iodata:new(" wo"), iodata:new("rld!")]))
+    |> iodata:prepend_iodata(_, iodata:new("H"))
+
+  data
+  |> iodata:to_string
+  |> expect:equal(_, "Hello, world!")
+
+  data
+  |> iodata:byte_size
+  |> expect:equal(_, 13)
+}
+
+pub fn lowercase_test() {
+  ["Gleam", "Gleam"]
+  |> iodata:from_strings
+  |> iodata:lowercase
+  |> iodata:to_string
+  |> expect:equal(_, "gleamgleam")
+}
+
+pub fn uppercase_test() {
+  ["Gleam", "Gleam"]
+  |> iodata:from_strings
+  |> iodata:uppercase
+  |> iodata:to_string
+  |> expect:equal(_, "GLEAMGLEAM")
+}
+
+pub fn split_test() {
+  "Gleam,Erlang,Elixir"
+  |> iodata:new
+  |> iodata:split(_, ",")
+  |> expect: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"])])
+}
+
+pub fn is_equal_test() {
+  iodata:new("12")
+  |> iodata:is_equal(_, iodata:from_strings(["1", "2"]))
+  |> expect:true
+
+  iodata:new("12")
+  |> iodata:is_equal(_, iodata:new("12"))
+  |> expect:true
+
+  iodata:new("12")
+  |> iodata:is_equal(_, iodata:new("2"))
+  |> expect:false
+}
+
+pub fn is_empty_test() {
+  iodata:new("")
+  |> iodata:is_empty
+  |> expect:true
+
+  iodata:new("12")
+  |> iodata:is_empty
+  |> expect:false
+
+  iodata:from_strings([])
+  |> iodata:is_empty
+  |> expect:true
+
+  iodata:from_strings(["", ""])
+  |> iodata:is_empty
+  |> expect:true
+}
diff --git a/test/gleam/list_test.gleam b/test/gleam/list_test.gleam
new file mode 100644
index 0000000..25028d9
--- /dev/null
+++ b/test/gleam/list_test.gleam
@@ -0,0 +1,351 @@
+import gleam/expect
+import gleam/list
+import gleam/int
+import gleam/string
+
+pub fn length_test() {
+  list:length([]) |> expect:equal(_, 0)
+  list:length([1]) |> expect:equal(_, 1)
+  list:length([1, 1]) |> expect:equal(_, 2)
+  list:length([1, 1, 1]) |> expect:equal(_, 3)
+}
+
+pub fn reverse_test() {
+  list:reverse([]) |> expect:equal(_, [])
+  list:reverse([1, 2, 3, 4, 5]) |> expect:equal(_, [5, 4, 3, 2, 1])
+}
+
+pub fn is_empty_test() {
+  list:is_empty([]) |> expect:true
+  list:is_empty([1]) |> expect: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
+}
+
+pub fn head_test() {
+  list:head([0, 4, 5, 7])
+    |> expect:equal(_, Ok(0))
+
+  list:head([])
+    |> expect:is_error
+}
+
+pub fn tail_test() {
+  list:tail([0, 4, 5, 7])
+    |> expect:equal(_, Ok([4, 5, 7]))
+
+  list:tail([0])
+    |> expect:equal(_, Ok([]))
+
+  list:tail([])
+    |> expect:is_error
+}
+
+pub fn filter_test() {
+  []
+    |> list:filter(_, fn(_) { True })
+    |> expect:equal(_, [])
+
+  [0, 4, 5, 7, 3]
+    |> list:filter(_, fn(_) { True })
+    |> expect:equal(_, [0, 4, 5, 7, 3])
+
+  [0, 4, 5, 7, 3]
+    |> list:filter(_, fn(x) { x > 4 })
+    |> expect:equal(_, [5, 7])
+
+  [0, 4, 5, 7, 3]
+    |> list:filter(_, fn(x) { x < 4 })
+    |> expect:equal(_, [0, 3])
+}
+
+pub fn map_test() {
+  []
+    |> list:map(_, fn(x) { x * 2 })
+    |> expect:equal(_, [])
+
+  [0, 4, 5, 7, 3]
+    |> list:map(_, fn(x) { x * 2 })
+    |> expect:equal(_, [0, 8, 10, 14, 6])
+}
+
+pub fn traverse_test() {
+  let fun = fn(x) {
+    case x == 6 || x == 5 || x == 4 {
+    | True -> Ok(x * 2)
+    | False -> Error(x)
+    }
+  }
+
+  [5, 6, 5, 6]
+    |> list:traverse(_, fun)
+    |> expect:equal(_, Ok([10, 12, 10, 12]))
+
+  [4, 6, 5, 7, 3]
+    |> list:traverse(_, fun)
+    |> expect:equal(_, Error(7))
+}
+
+pub fn drop_test() {
+  []
+    |> list:drop(_, 5)
+    |> expect:equal(_, [])
+
+  [1, 2, 3, 4, 5, 6, 7, 8]
+    |> list:drop(_, 5)
+    |> expect:equal(_, [6, 7, 8])
+}
+
+pub fn take_test() {
+  []
+    |> list:take(_, 5)
+    |> expect:equal(_, [])
+  [1, 2, 3, 4, 5, 6, 7, 8]
+    |> list:take(_, 5)
+    |> expect:equal(_, [1, 2, 3, 4, 5])
+}
+
+pub fn new_test() {
+  list:new() |> expect:equal(_, [])
+}
+
+pub fn append_test() {
+  list:append([1], [2, 3])
+    |> expect:equal(_, [1, 2, 3])
+}
+
+pub fn flatten_test() {
+  list:flatten([])
+    |> expect:equal(_, [])
+
+  list:flatten([[]])
+    |> expect:equal(_, [])
+
+  list:flatten([[], [], []])
+    |> expect:equal(_, [])
+
+  list:flatten([[1, 2], [], [3, 4]])
+    |> expect:equal(_, [1, 2, 3, 4])
+}
+
+pub fn fold_test() {
+  [1, 2, 3]
+    |> list:fold(_, [], fn(x, acc) { [x | acc] })
+    |> expect:equal(_, [3, 2, 1])
+}
+
+pub fn fold_right_test() {
+  [1, 2, 3]
+    |> list:fold_right(_, [], fn(x, acc) { [x | acc] })
+    |> expect:equal(_, [1, 2, 3])
+}
+
+pub fn find_test() {
+  let f = fn(x) {
+    case x {
+    | 2 -> Ok(4)
+    | _ -> Error(0)
+    }
+  }
+
+  [1, 2, 3]
+  |> list:find(_, f)
+  |> expect:equal(_, Ok(4))
+
+  [1, 3, 2]
+  |> list:find(_, f)
+  |> expect:equal(_, Ok(4))
+
+  [1, 3]
+  |> list:find(_, f)
+  |> expect:is_error
+}
+
+pub fn all_test() {
+  list:all([1, 2, 3, 4, 5], fn(x) { x > 0 })
+  |> expect:equal(_, True)
+
+  list:all([1, 2, 3, 4, 5], fn(x) { x < 0 })
+  |> expect:equal(_, False)
+
+  list:all([], fn(_) { False })
+  |> expect:equal(_, True)
+}
+
+pub fn any_test() {
+  list:any([1, 2, 3, 4, 5], fn(x) { x == 2 })
+  |> expect:equal(_, True)
+
+  list:any([1, 2, 3, 4, 5], fn(x) { x < 0 })
+  |> expect:equal(_, False)
+
+  list:any([], fn(_) { False })
+  |> expect:equal(_, False)
+}
+
+pub fn zip_test() {
+  list:zip([], [1, 2, 3])
+  |> expect:equal(_, [])
+
+  list:zip([1, 2], [])
+  |> expect:equal(_, [])
+
+  list:zip([1, 2, 3], [4, 5, 6])
+  |> expect:equal(_, [{1, 4}, {2, 5}, {3, 6}])
+
+  list:zip([5, 6], [1, 2, 3])
+  |> expect:equal(_, [{5, 1}, {6, 2}])
+
+  list:zip([5, 6, 7], [1, 2])
+  |> expect:equal(_, [{5, 1}, {6, 2}])
+}
+
+pub fn strict_zip_test() {
+  list:strict_zip([], [1, 2, 3])
+  |> expect:is_error
+
+  list:strict_zip([1, 2], [])
+  |> expect:is_error
+
+  list:strict_zip([1, 2, 3], [4, 5, 6])
+  |> expect:equal(_, Ok([{1, 4}, {2, 5}, {3, 6}]))
+
+  list:strict_zip([5, 6], [1, 2, 3])
+  |> expect:is_error
+
+  list:strict_zip([5, 6, 7], [1, 2])
+  |> expect:is_error
+}
+
+pub fn intersperse_test() {
+  list:intersperse([1, 2, 3], 4)
+  |> expect:equal(_, [1, 4, 2, 4, 3])
+
+  list:intersperse([], 2)
+  |> expect:equal(_, [])
+}
+
+pub fn at_test() {
+  list:at([1, 2, 3], 2)
+  |> expect:equal(_, Ok(3))
+
+  list:at([1, 2, 3], 5)
+  |> expect:is_error
+
+  list:at([], 0)
+  |> expect:is_error
+
+  list:at([1, 2, 3, 4, 5, 6], -1)
+  |> expect:is_error
+}
+
+pub fn unique_test() {
+  list:unique([1, 1, 2, 3, 4, 4, 4, 5, 6])
+  |> expect: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])
+
+  list:unique([3, 4, 5])
+  |> expect:equal(_, [3, 4, 5])
+
+  list:unique([])
+  |> expect:equal(_, [])
+}
+
+pub fn sort_test() {
+  list:sort([4, 3, 6, 5, 4])
+  |> expect:equal(_, [3, 4, 4, 5, 6])
+
+  list:sort([])
+  |> expect:equal(_, [])
+
+  list:sort([{1, 2}, {4, 5}, {3, 2}])
+  |> expect:equal(_, [{1, 2}, {3, 2}, {4, 5}])
+}
+
+pub fn index_map_test() {
+  list:index_map([3, 4, 5], fn(i, x) { {i, x} })
+  |> expect:equal(_, [{0, 3}, {1, 4}, {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"])
+}
+
+pub fn range_test() {
+  list:range(0, 0)
+  |> expect:equal(_, [])
+
+  list:range(1, 1)
+  |> expect:equal(_, [])
+
+  list:range(-1, -1)
+  |> expect:equal(_, [])
+
+  list:range(0, 1)
+  |> expect:equal(_, [0])
+
+  list:range(0, 5)
+  |> expect:equal(_, [0, 1, 2, 3, 4])
+
+  list:range(1, -5)
+  |> expect:equal(_, [1, 0, -1, -2, -3, -4])
+}
+
+pub fn repeat_test() {
+  list:repeat(1, -10)
+  |> expect:equal(_, [])
+
+  list:repeat(1, 0)
+  |> expect:equal(_, [])
+
+  list:repeat(2, 3)
+  |> expect:equal(_, [2, 2, 2])
+
+  list:repeat("x", 5)
+  |> expect:equal(_, ["x", "x", "x", "x", "x"])
+}
+
+pub fn split_test() {
+  list:split([], 0)
+  |> expect:equal(_, {[], []})
+
+  list:split([0, 1, 2, 3, 4], 0)
+  |> expect:equal(_, {[], [0, 1, 2, 3, 4]})
+
+  list:split([0, 1, 2, 3, 4], -2)
+  |> expect:equal(_, {[], [0, 1, 2, 3, 4]})
+
+  list:split([0, 1, 2, 3, 4], 1)
+  |> expect:equal(_, {[0], [1, 2, 3, 4]})
+
+  list:split([0, 1, 2, 3, 4], 3)
+  |> expect:equal(_, {[0, 1, 2], [3, 4]})
+
+  list:split([0, 1, 2, 3, 4], 9)
+  |> expect:equal(_, {[0, 1, 2, 3, 4], []})
+}
+
+pub fn split_while_test() {
+  list:split_while([], fn(x) { x <= 5 })
+  |> expect:equal(_, {[], []})
+
+  list:split_while([1, 2, 3, 4, 5], fn(x) { x <= 5 })
+  |> expect:equal(_, {[1, 2, 3, 4, 5], []})
+
+  list:split_while([1, 2, 3, 4, 5], fn(x) { x == 2 })
+  |> expect:equal(_, {[], [1, 2, 3, 4, 5]})
+
+  list:split_while([1, 2, 3, 4, 5], fn(x) { x <= 3 })
+  |> expect:equal(_, {[1, 2, 3], [4, 5]})
+
+  list:split_while([1, 2, 3, 4, 5], fn(x) { x <= -3 })
+  |> expect:equal(_, {[], [1, 2, 3, 4, 5]})
+}
diff --git a/test/gleam/map_dict_test.gleam b/test/gleam/map_dict_test.gleam
new file mode 100644
index 0000000..778838c
--- /dev/null
+++ b/test/gleam/map_dict_test.gleam
@@ -0,0 +1,233 @@
+import gleam/string
+import gleam/expect
+import gleam/map_dict
+
+pub fn from_list_test() {
+  [
+    {4, 0},
+    {1, 0},
+  ]
+  |> map_dict:from_list
+  |> map_dict:size
+  |> expect:equal(_, 2)
+}
+
+pub fn has_key_test() {
+  []
+  |> map_dict:from_list
+  |> map_dict:has_key(_, 1)
+  |> expect:false
+
+  [
+      {1, 0},
+  ]
+  |> map_dict:from_list
+  |> map_dict:has_key(_, 1)
+  |> expect:true
+
+  [
+      {4, 0},
+      {1, 0},
+  ]
+  |> map_dict:from_list
+  |> map_dict:has_key(_, 1)
+  |> expect:true
+
+  [
+    {4, 0},
+    {1, 0},
+  ]
+  |> map_dict:from_list
+  |> map_dict:has_key(_, 0)
+  |> expect:false
+}
+
+pub fn new_test() {
+  map_dict:new()
+  |> map_dict:size
+  |> expect:equal(_, 0)
+
+  map_dict:new()
+  |> map_dict:to_list
+  |> expect:equal(_, [])
+}
+
+pub fn fetch_test() {
+  let proplist = [
+    {4, 0},
+    {1, 1},
+  ]
+  let m = map_dict:from_list(proplist)
+
+  m
+  |> map_dict:fetch(_, 4)
+  |> expect:equal(_, Ok(0))
+
+  m
+  |> map_dict:fetch(_, 1)
+  |> expect:equal(_, Ok(1))
+
+  m
+  |> map_dict:fetch(_, 2)
+  |> expect:is_error
+}
+
+pub fn put_test() {
+  map_dict:new()
+  |> map_dict:put(_, "a", 0)
+  |> map_dict:put(_, "b", 1)
+  |> map_dict:put(_, "c", 2)
+  |> expect:equal(_, map_dict:from_list([{"a", 0}, {"b", 1}, {"c", 2}]))
+}
+
+pub fn map_values_test() {
+  [
+    {1, 0},
+    {2, 1},
+    {3, 2},
+  ]
+  |> map_dict:from_list
+  |> map_dict:map_values(_, fn(k, v) { k + v })
+  |> expect:equal(_, map_dict:from_list([{1, 1}, {2, 3}, {3, 5}]))
+}
+
+pub fn keys_test() {
+  [
+    {"a", 0},
+    {"b", 1},
+    {"c", 2},
+  ]
+  |> map_dict:from_list
+  |> map_dict:keys
+  |> expect:equal(_, ["a", "b", "c"])
+}
+
+pub fn values_test() {
+  [
+    {"a", 0},
+    {"b", 1},
+    {"c", 2},
+  ]
+  |> map_dict:from_list
+  |> map_dict:values
+  |> expect:equal(_, [0, 1, 2])
+}
+
+pub fn take_test() {
+  [
+    {"a", 0},
+    {"b", 1},
+    {"c", 2},
+  ]
+  |> map_dict:from_list
+  |> map_dict:take(_, ["a", "b", "d"])
+  |> expect:equal(_, map_dict:from_list([{"a", 0}, {"b", 1}]))
+}
+
+pub fn drop_test() {
+  [
+    {"a", 0},
+    {"b", 1},
+    {"c", 2},
+  ]
+  |> map_dict:from_list
+  |> map_dict:drop(_, ["a", "b", "d"])
+  |> expect:equal(_, map_dict:from_list([{"c", 2}]))
+}
+
+pub fn merge_test() {
+  let a = map_dict:from_list([
+    {"a", 2},
+    {"c", 4},
+    {"d", 3},
+  ])
+  let b = map_dict:from_list([
+    {"a", 0},
+    {"b", 1},
+    {"c", 2},
+  ])
+
+  map_dict:merge(a, b)
+  |> expect:equal(_, map_dict:from_list([
+      {"a", 0},
+      {"b", 1},
+      {"c", 2},
+      {"d", 3},
+    ]))
+
+  map_dict:merge(b, a)
+  |> expect:equal(_, map_dict:from_list([
+      {"a", 2},
+      {"b", 1},
+      {"c", 4},
+      {"d", 3},
+    ]))
+}
+
+pub fn delete_test() {
+  [
+    {"a", 0},
+    {"b", 1},
+    {"c", 2},
+  ]
+  |> map_dict:from_list
+  |> map_dict:delete(_, "a")
+  |> map_dict:delete(_, "d")
+  |> expect:equal(_, map_dict:from_list([{"b", 1}, {"c", 2}]))
+}
+
+pub fn update_test() {
+  let dict = map_dict:from_list([
+    {"a", 0},
+    {"b", 1},
+    {"c", 2},
+  ])
+
+  let inc_or_zero = fn(x) {
+    case x {
+    | Ok(i) -> i + 1
+    | Error(_) -> 0
+    }
+  }
+
+  dict
+  |> map_dict:update(_, "a", inc_or_zero)
+  |> expect:equal(_, map_dict:from_list([{"a", 1}, {"b", 1}, {"c", 2}]))
+
+  dict
+  |> map_dict:update(_, "b", inc_or_zero)
+  |> expect:equal(_, map_dict:from_list([{"a", 0}, {"b", 2}, {"c", 2}]))
+
+  dict
+  |> map_dict:update(_, "z", inc_or_zero)
+  |> expect:equal(_, map_dict:from_list([{"a", 0}, {"b", 1}, {"c", 2}, {"z", 0}]))
+}
+
+pub fn fold_test() {
+  let dict = map_dict:from_list([
+    {"a", 0},
+    {"b", 1},
+    {"c", 2},
+    {"d", 3},
+  ])
+
+  let add = fn(_, v, acc) {
+    v + acc
+  }
+
+  dict
+  |> map_dict:fold(_, 0, add)
+  |> expect:equal(_, 6)
+
+  let concat = fn(k, _, acc) {
+    string:append(acc, k)
+  }
+
+  dict
+  |> map_dict:fold(_, "", concat)
+  |> expect:equal(_, "abcd")
+
+  map_dict:from_list([])
+  |> map_dict:fold(_, 0, add)
+  |> expect:equal(_, 0)
+}
diff --git a/test/gleam/order_test.gleam b/test/gleam/order_test.gleam
new file mode 100644
index 0000000..2127b9f
--- /dev/null
+++ b/test/gleam/order_test.gleam
@@ -0,0 +1,111 @@
+import gleam/expect
+import gleam/order
+
+pub fn reverse_test() {
+  order:reverse(order:Lt)
+  |> expect:equal(_, order:Gt)
+
+  order:reverse(order:Eq)
+  |> expect:equal(_, order:Eq)
+
+  order:reverse(order:Gt)
+  |> expect:equal(_, order:Lt)
+}
+
+pub fn to_int_test() {
+  order:to_int(order:Lt)
+  |> expect:equal(_, -1)
+
+  order:to_int(order:Eq)
+  |> expect:equal(_, 0)
+
+  order:to_int(order:Gt)
+  |> expect:equal(_, 1)
+}
+
+pub fn compare_test() {
+  order:compare(order:Lt, order:Lt)
+  |> expect:equal(_, order:Eq)
+
+  order:compare(order:Lt, order:Eq)
+  |> expect:equal(_, order:Lt)
+
+  order:compare(order:Lt, order:Gt)
+  |> expect:equal(_, order:Lt)
+
+  order:compare(order:Eq, order:Lt)
+  |> expect:equal(_, order:Gt)
+
+  order:compare(order:Eq, order:Eq)
+  |> expect:equal(_, order:Eq)
+
+  order:compare(order:Eq, order:Gt)
+  |> expect:equal(_, order:Lt)
+
+  order:compare(order:Gt, order:Lt)
+  |> expect:equal(_, order:Gt)
+
+  order:compare(order:Gt, order:Eq)
+  |> expect:equal(_, order:Gt)
+
+  order:compare(order:Gt, order:Gt)
+  |> expect:equal(_, order:Eq)
+}
+
+pub fn max_test() {
+  order:max(order:Lt, order:Lt)
+  |> expect:equal(_, order:Lt)
+
+  order:max(order:Lt, order:Eq)
+  |> expect:equal(_, order:Eq)
+
+  order:max(order:Lt, order:Gt)
+  |> expect:equal(_, order:Gt)
+
+  order:max(order:Eq, order:Lt)
+  |> expect:equal(_, order:Eq)
+
+  order:max(order:Eq, order:Eq)
+  |> expect:equal(_, order:Eq)
+
+  order:max(order:Eq, order:Gt)
+  |> expect:equal(_, order:Gt)
+
+  order:max(order:Gt, order:Lt)
+  |> expect:equal(_, order:Gt)
+
+  order:max(order:Gt, order:Eq)
+  |> expect:equal(_, order:Gt)
+
+  order:max(order:Gt, order:Gt)
+  |> expect:equal(_, order:Gt)
+}
+
+pub fn min_test() {
+  order:min(order:Lt, order:Lt)
+  |> expect:equal(_, order:Lt)
+
+  order:min(order:Lt, order:Eq)
+  |> expect:equal(_, order:Lt)
+
+  order:min(order:Lt, order:Gt)
+  |> expect:equal(_, order:Lt)
+
+  order:min(order:Eq, order:Lt)
+  |> expect:equal(_, order:Lt)
+
+  order:min(order:Eq, order:Eq)
+  |> expect:equal(_, order:Eq)
+
+  order:min(order:Eq, order:Gt)
+  |> expect:equal(_, order:Eq)
+
+  order:min(order:Gt, order:Lt)
+  |> expect:equal(_, order:Lt)
+
+  order:min(order:Gt, order:Eq)
+  |> expect:equal(_, order:Eq)
+
+  order:min(order:Gt, order:Gt)
+  |> expect:equal(_, order:Gt)
+}
diff --git a/test/gleam/result_test.gleam b/test/gleam/result_test.gleam
new file mode 100644
index 0000000..3f08014
--- /dev/null
+++ b/test/gleam/result_test.gleam
@@ -0,0 +1,88 @@
+import gleam/expect
+import gleam/result
+
+pub fn is_ok_test() {
+  result:is_ok(Ok(1))
+  |> expect:true
+
+  result:is_ok(Error(1))
+  |> expect:false
+}
+
+pub fn is_error_test() {
+  result:is_error(Ok(1))
+  |> expect:false
+
+  result:is_error(Error(1))
+  |> expect:true
+}
+
+pub fn map_test() {
+  Ok(1)
+  |> result:map(_, fn(x) { x + 1 })
+  |> expect:equal(_, Ok(2))
+
+  Ok(1)
+  |> result:map(_, fn(_) { "2" })
+  |> expect:equal(_, Ok("2"))
+
+  Error(1)
+  |> result:map(_, fn(x) { x + 1 })
+  |> expect:equal(_, Error(1))
+}
+
+pub fn map_error_test() {
+  Ok(1)
+  |> result:map_error(_, fn(x) { x + 1 })
+  |> expect:equal(_, Ok(1))
+
+  Error(1)
+  |> result:map_error(_, fn(x) { x + 1 })
+  |> expect:equal(_, Error(2))
+}
+
+pub fn flatten_test() {
+  Ok(Ok(1))
+  |> result:flatten
+  |> expect:equal(_, Ok(1))
+
+  Ok(Error(1))
+  |> result:flatten
+  |> expect:equal(_, Error(1))
+
+  Error(1)
+  |> result:flatten
+  |> expect:equal(_, Error(1))
+
+  Error(Error(1))
+  |> result:flatten
+  |> expect:equal(_, Error(Error(1)))
+}
+
+pub fn then_test() {
+  Error(1)
+  |> result:then(_, fn(x) { Ok(x + 1) })
+  |> expect:equal(_, Error(1))
+
+  Ok(1)
+  |> result:then(_, fn(x) { Ok(x + 1) })
+  |> expect:equal(_, Ok(2))
+
+  Ok(1)
+  |> result:then(_, fn(_) { Ok("type change") })
+  |> expect:equal(_, Ok("type change"))
+
+  Ok(1)
+  |> result:then(_, fn(_) { Error(1) })
+  |> expect:equal(_, Error(1))
+}
+
+pub fn unwrap_test() {
+  Ok(1)
+  |> result:unwrap(_, 50)
+  |> expect:equal(_, 1)
+
+  Error("nope")
+  |> result:unwrap(_, 50)
+  |> expect:equal(_, 50)
+}
diff --git a/test/gleam/string_test.gleam b/test/gleam/string_test.gleam
new file mode 100644
index 0000000..2a48278
--- /dev/null
+++ b/test/gleam/string_test.gleam
@@ -0,0 +1,50 @@
+import gleam/string
+import gleam/expect
+
+pub fn length_test() {
+  string:length("ß↑e̊")
+  |> expect:equal(_, 3)
+
+  string:length("Gleam")
+  |> expect:equal(_, 5)
+
+  string:length("")
+  |> expect:equal(_, 0)
+}
+
+pub fn lowercase_test() {
+  string:lowercase("Gleam")
+  |> expect:equal(_, "gleam")
+}
+
+pub fn uppercase_test() {
+  string:uppercase("Gleam")
+  |> expect:equal(_, "GLEAM")
+}
+
+pub fn reverse_test() {
+  string:reverse("Gleam")
+  |> expect:equal(_, "maelG")
+}
+
+pub fn split_test() {
+  "Gleam,Erlang,Elixir"
+  |> string:split(_, ",")
+  |> expect:equal(_, ["Gleam", "Erlang", "Elixir"])
+
+  "Gleam, Erlang,Elixir"
+  |> string:split(_, ", ")
+  |> expect:equal(_, ["Gleam", "Erlang,Elixir"])
+}
+
+pub fn replace_test() {
+  "Gleam,Erlang,Elixir"
+  |> string:replace(_, ",", "++")
+  |> expect:equal(_, "Gleam++Erlang++Elixir")
+}
+
+pub fn append_test() {
+  "Test"
+  |> string:append(_, " Me")
+  |> expect:equal(_, "Test Me")
+}
diff --git a/test/gleam/tuple_test.gleam b/test/gleam/tuple_test.gleam
new file mode 100644
index 0000000..a5530e7
--- /dev/null
+++ b/test/gleam/tuple_test.gleam
@@ -0,0 +1,44 @@
+import gleam/expect
+import gleam/tuple
+
+pub fn new_test() {
+  tuple:new(1, 2)
+  |> expect:equal(_, {1, 2})
+
+  tuple:new(2, "3")
+  |> expect:equal(_, {2, "3"})
+}
+
+pub fn first_test() {
+  {1, 2}
+  |> tuple:first
+  |> expect:equal(_, 1)
+}
+
+pub fn second_test() {
+  {1, 2}
+  |> tuple:second
+  |> expect:equal(_, 2)
+}
+
+pub fn swap_test() {
+  {1, "2"}
+  |> tuple:swap
+  |> expect:equal(_, {"2", 1})
+}
+
+pub fn fetch_test() {
+  let proplist = [{0, "1"}, {1, "2"}]
+
+  proplist
+  |> tuple:fetch(_, 0)
+  |> expect:equal(_, Ok("1"))
+
+  proplist
+  |> tuple:fetch(_, 1)
+  |> expect:equal(_, Ok("2"))
+
+  proplist
+  |> tuple:fetch(_, 2)
+  |> expect:is_error
+}
diff --git a/test/std/any_test.gleam b/test/std/any_test.gleam
deleted file mode 100644
index dce4a44..0000000
--- a/test/std/any_test.gleam
+++ /dev/null
@@ -1,278 +0,0 @@
-import std/any
-import std/atom
-import std/list
-import std/tuple
-import std/expect
-import std/result
-
-pub fn string_test() {
-  ""
-  |> any:from
-  |> any:string
-  |> expect:equal(_, Ok(""))
-
-  "Hello"
-  |> any:from
-  |> any:string
-  |> expect:equal(_, Ok("Hello"))
-
-  1
-  |> any:from
-  |> any:string
-  |> expect:equal(_, Error("Expected a String, got `1`"))
-
-  []
-  |> any:from
-  |> any:string
-  |> expect:equal(_, Error("Expected a String, got `[]`"))
-}
-
-pub fn int_test() {
-  1
-  |> any:from
-  |> any:int
-  |> expect:equal(_, Ok(1))
-
-  2
-  |> any:from
-  |> any:int
-  |> expect:equal(_, Ok(2))
-
-  1.0
-  |> any:from
-  |> any:int
-  |> expect:equal(_, Error("Expected an Int, got `1.0`"))
-
-  []
-  |> any:from
-  |> any:int
-  |> expect:equal(_, Error("Expected an Int, got `[]`"))
-}
-
-pub fn float_test() {
-  1.0
-  |> any:from
-  |> any:float
-  |> expect:equal(_, Ok(1.0))
-
-  2.2
-  |> any:from
-  |> any:float
-  |> expect:equal(_, Ok(2.2))
-
-  1
-  |> any:from
-  |> any:float
-  |> expect:equal(_, Error("Expected a Float, got `1`"))
-
-  []
-  |> any:from
-  |> any:float
-  |> expect:equal(_, Error("Expected a Float, got `[]`"))
-}
-
-// pub fn atom_test() {
-//   make an atom here
-//     |> any:from
-//     |> atom
-//     |> expect:equal(_, Ok(""))
-
-//   make an atom here
-//     |> any:from
-//     |> atom
-//     |> expect:equal(_, Ok("ok"))
-
-//   1
-//     |> any:from
-//     |> atom
-//     |> expect:is_error
-
-//   []
-//     |> any:from
-//     |> atom
-//     |> expect:is_error
-// }
-
-pub fn thunk_test() {
-  fn() { 1 }
-  |> any:from
-  |> any:thunk
-  |> expect:is_ok
-
-  fn() { 1 }
-  |> any:from
-  |> any:thunk
-  |> result:map(_, fn(f) { f() })
-  |> expect:equal(_, Ok(any:from(1)))
-
-  fn(x) { x }
-  |> any:from
-  |> any:thunk
-  |> expect:is_error
-
-  1
-  |> any:from
-  |> any:thunk
-  |> expect:is_error
-
-  []
-  |> any:from
-  |> any:thunk
-  |> expect:is_error
-}
-
-pub fn bool_test() {
-  True
-  |> any:from
-  |> any:bool
-  |> expect:equal(_, Ok(True))
-
-  False
-  |> any:from
-  |> any:bool
-  |> expect:equal(_, Ok(False))
-
-  1
-  |> any:from
-  |> any:bool
-  |> expect:equal(_, Error("Expected a Bool, got `1`"))
-
-  []
-  |> any:from
-  |> any:bool
-  |> expect:equal(_, Error("Expected a Bool, got `[]`"))
-}
-
-pub fn atom_test() {
-  ""
-    |> atom:create_from_string
-    |> any:from
-    |> any:atom
-    |> expect:equal(_, Ok(atom:create_from_string("")))
-
-  "ok"
-    |> atom:create_from_string
-    |> any:from
-    |> any:atom
-    |> expect:equal(_, Ok(atom:create_from_string("ok")))
-
-  1
-    |> any:from
-    |> any:atom
-    |> expect:is_error
-
-  []
-    |> any:from
-    |> any:atom
-    |> expect:is_error
-}
-
-pub fn list_test() {
-  []
-  |> any:from
-  |> any:list(_, any:string)
-  |> expect:equal(_, Ok([]))
-
-  []
-  |> any:from
-  |> any:list(_, any:int)
-  |> expect:equal(_, Ok([]))
-
-  [1, 2, 3]
-  |> any:from
-  |> any:list(_, any:int)
-  |> expect:equal(_, Ok([1, 2, 3]))
-
-  [[1], [2], [3]]
-  |> any:from
-  |> any:list(_, any:list(_, any:int))
-  |> expect:equal(_, Ok([[1], [2], [3]]))
-
-  1
-  |> any:from
-  |> any:list(_, any:string)
-  |> expect:is_error
-
-  1.0
-  |> any:from
-  |> any:list(_, any:int)
-  |> expect:is_error
-
-  [""]
-  |> any:from
-  |> any:list(_, any:int)
-  |> expect:is_error
-
-  [any:from(1), any:from("not an int")]
-  |> any:from
-  |> any:list(_, any:int)
-  |> expect:is_error
-}
-
-pub fn tuple_test() {
-  {1, []}
-  |> any:from
-  |> any:tuple
-  |> expect:equal(_, Ok({any:from(1), any:from([])}))
-
-  {"ok", "ok"}
-  |> any:from
-  |> any:tuple
-  |> expect:equal(_, Ok({any:from("ok"), any:from("ok")}))
-
-  {1}
-  |> any:from
-  |> any:tuple
-  |> expect:is_error
-
-  {1, 2, 3}
-  |> any:from
-  |> any:tuple
-  |> expect:is_error
-
-  {1, 2.0}
-  |> any:from
-  |> any:tuple
-  |> result:then(_, fn(x) {
-    x
-    |> tuple:first
-    |> any:int
-    |> result:map(_, fn(f) { {f, tuple:second(x)} })
-  })
-  |> result:then(_, fn(x) {
-    x
-    |> tuple:second
-    |> any:float
-    |> result:map(_, fn(f) { {tuple:first(x), f} })
-  })
-  |> expect:equal(_, Ok({1, 2.0}))
-}
-
-pub fn field_test() {
-  let Ok(ok_atom) = atom:from_string("ok")
-
-  {ok = 1}
-  |> any:from
-  |> any:field(_, ok_atom)
-  |> expect:equal(_, Ok(any:from(1)))
-
-  {earlier = 2, ok = 3}
-  |> any:from
-  |> any:field(_, ok_atom)
-  |> expect:equal(_, Ok(any:from(3)))
-
-  {}
-  |> any:from
-  |> any:field(_, ok_atom)
-  |> expect:is_error
-
-  1
-  |> any:from
-  |> any:field(_, ok_atom)
-  |> expect:is_error
-
-  []
-  |> any:from
-  |> any:field(_, [])
-  |> expect:is_error
-}
diff --git a/test/std/atom_test.gleam b/test/std/atom_test.gleam
deleted file mode 100644
index 54e88da..0000000
--- a/test/std/atom_test.gleam
+++ /dev/null
@@ -1,46 +0,0 @@
-import std/atom
-import std/expect
-
-pub fn from_string_test() {
-  "ok"
-  |> atom:from_string
-  |> expect:is_ok
-
-  "expect"
-  |> atom:from_string
-  |> expect:is_ok
-
-  "this is not an atom we have seen before"
-  |> atom:from_string
-  // |> expect:equal(_, Error(AtomNotLoaded))
-  |> expect:is_error
-}
-
-pub fn create_from_string_test() {
-  "ok"
-  |> atom:create_from_string
-  |> Ok
-  |> expect:equal(_, atom:from_string("ok"))
-
-  "expect"
-  |> atom:create_from_string
-  |> Ok
-  |> expect: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"))
-}
-
-pub fn to_string_test() {
-  "ok"
-  |> atom:create_from_string
-  |> atom:to_string
-  |> expect:equal(_, "ok")
-
-  "expect"
-  |> atom:create_from_string
-  |> atom:to_string
-  |> expect:equal(_, "expect")
-}
diff --git a/test/std/bool_test.gleam b/test/std/bool_test.gleam
deleted file mode 100644
index d2da7f9..0000000
--- a/test/std/bool_test.gleam
+++ /dev/null
@@ -1,61 +0,0 @@
-import std/bool
-import std/order
-import std/expect
-
-pub fn negate_test() {
-  bool:negate(True)
-  |> expect:false
-
-  bool:negate(False)
-  |> expect:true
-}
-
-pub fn compare_test() {
-  bool:compare(True, True)
-  |> expect:equal(_, order:Eq)
-
-  bool:compare(True, False)
-  |> expect:equal(_, order:Gt)
-
-  bool:compare(False, False)
-  |> expect:equal(_, order:Eq)
-
-  bool:compare(False, True)
-  |> expect:equal(_, order:Lt)
-}
-
-pub fn max_test() {
-  bool:max(True, True)
-  |> expect:equal(_, True)
-
-  bool:max(True, False)
-  |> expect:equal(_, True)
-
-  bool:max(False, False)
-  |> expect:equal(_, False)
-
-  bool:max(False, True)
-  |> expect:equal(_, True)
-}
-
-pub fn min_test() {
-  bool:min(True, True)
-  |> expect:equal(_, True)
-
-  bool:min(True, False)
-  |> expect:equal(_, False)
-
-  bool:min(False, False)
-  |> expect:equal(_, False)
-
-  bool:min(False, True)
-  |> expect:equal(_, False)
-}
-
-pub fn to_int_test() {
-  bool:to_int(True)
-  |> expect:equal(_, 1)
-
-  bool:to_int(False)
-  |> expect:equal(_, 0)
-}
diff --git a/test/std/float_test.gleam b/test/std/float_test.gleam
deleted file mode 100644
index 0847973..0000000
--- a/test/std/float_test.gleam
+++ /dev/null
@@ -1,118 +0,0 @@
-import std/expect
-import std/float
-
-pub fn parse_test() {
-  "1.23"
-  |> float:parse
-  |> expect:equal(_, Ok(1.23))
-
-  "5.0"
-  |> float:parse
-  |> expect:equal(_, Ok(5.0))
-
-  "0.123456789"
-  |> float:parse
-  |> expect:equal(_, Ok(0.123456789))
-
-  ""
-  |> float:parse
-  |> expect:is_error
-
-  "what"
-  |> float:parse
-  |> expect:is_error
-
-  "1"
-  |> float:parse
-  |> expect:is_error
-}
-
-pub fn to_string_test() {
-  123.0
-  |> float:to_string
-  |> expect:equal(_, "123.0")
-
-  -8.1
-  |> float:to_string
-  |> expect:equal(_, "-8.1")
-}
-
-pub fn ceiling_test() {
-  8.1
-  |> float:ceiling
-  |> expect:equal(_, 9.0)
-
-  -8.1
-  |> float:ceiling
-  |> expect:equal(_, -8.0)
-
-  -8.0
-  |> float:ceiling
-  |> expect:equal(_, -8.0)
-}
-
-pub fn floor_test() {
-  8.1
-  |> float:floor
-  |> expect:equal(_, 8.0)
-
-  -8.1
-  |> float:floor
-  |> expect:equal(_, -9.0)
-
-  -8.0
-  |> float:floor
-  |> expect:equal(_, -8.0)
-}
-
-pub fn round_test() {
-  8.1
-  |> float:round
-  |> expect:equal(_, 8)
-
-  8.4
-  |> float:round
-  |> expect:equal(_, 8)
-
-  8.499
-  |> float:round
-  |> expect:equal(_, 8)
-
-  8.5
-  |> float:round
-  |> expect:equal(_, 9)
-
-  -8.1
-  |> float:round
-  |> expect:equal(_, -8)
-
-  -7.5
-  |> float:round
-  |> expect:equal(_, -8)
-}
-
-pub fn truncate_test() {
-  8.1
-  |> float:truncate
-  |> expect:equal(_, 8)
-
-  8.4
-  |> float:truncate
-  |> expect:equal(_, 8)
-
-  8.499
-  |> float:truncate
-  |> expect:equal(_, 8)
-
-  8.5
-  |> float:truncate
-  |> expect:equal(_, 8)
-
-  -8.1
-  |> float:truncate
-  |> expect:equal(_, -8)
-
-  -7.5
-  |> float:truncate
-  |> expect:equal(_, -7)
-}
diff --git a/test/std/http_test.gleam b/test/std/http_test.gleam
deleted file mode 100644
index 9941d56..0000000
--- a/test/std/http_test.gleam
+++ /dev/null
@@ -1 +0,0 @@
-// Nothing here yet...
diff --git a/test/std/int_test.gleam b/test/std/int_test.gleam
deleted file mode 100644
index 63e9d50..0000000
--- a/test/std/int_test.gleam
+++ /dev/null
@@ -1,73 +0,0 @@
-import std/expect
-import std/int
-import std/order
-
-pub fn to_string() {
-  123
-  |> int:to_string
-  |> expect:equal(_, "123")
-
-  -123
-  |> int:to_string
-  |> expect:equal(_, "-123")
-
-  0123
-  |> int:to_string
-  |> expect:equal(_, "123")
-}
-
-pub fn parse() {
-  "123"
-  |> int:parse
-  |> expect:equal(_, Ok(123))
-
-  "-123"
-  |> int:parse
-  |> expect:equal(_, Ok(-123))
-
-  "0123"
-  |> int:parse
-  |> expect:equal(_, Ok(123))
-
-  ""
-  |> int:parse
-  |> expect:is_error
-
-  "what"
-  |> int:parse
-  |> expect:is_error
-
-  "1.23"
-  |> int:parse
-  |> expect:is_error
-}
-
-pub fn to_base_string() {
-  100
-  |> int:to_base_string(_, 16)
-  |> expect:equal(_, "64")
-
-  -100
-  |> int:to_base_string(_, 16)
-  |> expect:equal(_, "-64")
-}
-
-pub fn compare_test() {
-  int:compare(0, 0)
-  |> expect:equal(_, order:Eq)
-
-  int:compare(1, 1)
-  |> expect:equal(_, order:Eq)
-
-  int:compare(0, 1)
-  |> expect:equal(_, order:Lt)
-
-  int:compare(-2, -1)
-  |> expect:equal(_, order:Lt)
-
-  int:compare(2, 1)
-  |> expect:equal(_, order:Gt)
-
-  int:compare(-1, -2)
-  |> expect:equal(_, order:Gt)
-}
diff --git a/test/std/iodata_test.gleam b/test/std/iodata_test.gleam
deleted file mode 100644
index 1a90e51..0000000
--- a/test/std/iodata_test.gleam
+++ /dev/null
@@ -1,90 +0,0 @@
-import std/expect
-import std/iodata
-
-pub fn iodata_test() {
-  let data = iodata:new("ello")
-    |> iodata:append(_, ",")
-    |> iodata:append(_, " world!")
-    |> iodata:prepend(_, "H")
-
-  data
-  |> iodata:to_string
-  |> expect:equal(_, "Hello, world!")
-
-  data
-  |> iodata:byte_size
-  |> expect:equal(_, 13)
-
-  let data = iodata:new("ello")
-    |> iodata:append_iodata(_, iodata:new(","))
-    |> iodata:append_iodata(_, iodata:concat([iodata:new(" wo"), iodata:new("rld!")]))
-    |> iodata:prepend_iodata(_, iodata:new("H"))
-
-  data
-  |> iodata:to_string
-  |> expect:equal(_, "Hello, world!")
-
-  data
-  |> iodata:byte_size
-  |> expect:equal(_, 13)
-}
-
-pub fn lowercase_test() {
-  ["Gleam", "Gleam"]
-  |> iodata:from_strings
-  |> iodata:lowercase
-  |> iodata:to_string
-  |> expect:equal(_, "gleamgleam")
-}
-
-pub fn uppercase_test() {
-  ["Gleam", "Gleam"]
-  |> iodata:from_strings
-  |> iodata:uppercase
-  |> iodata:to_string
-  |> expect:equal(_, "GLEAMGLEAM")
-}
-
-pub fn split_test() {
-  "Gleam,Erlang,Elixir"
-  |> iodata:new
-  |> iodata:split(_, ",")
-  |> expect: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"])])
-}
-
-pub fn is_equal_test() {
-  iodata:new("12")
-  |> iodata:is_equal(_, iodata:from_strings(["1", "2"]))
-  |> expect:true
-
-  iodata:new("12")
-  |> iodata:is_equal(_, iodata:new("12"))
-  |> expect:true
-
-  iodata:new("12")
-  |> iodata:is_equal(_, iodata:new("2"))
-  |> expect:false
-}
-
-pub fn is_empty_test() {
-  iodata:new("")
-  |> iodata:is_empty
-  |> expect:true
-
-  iodata:new("12")
-  |> iodata:is_empty
-  |> expect:false
-
-  iodata:from_strings([])
-  |> iodata:is_empty
-  |> expect:true
-
-  iodata:from_strings(["", ""])
-  |> iodata:is_empty
-  |> expect:true
-}
diff --git a/test/std/list_test.gleam b/test/std/list_test.gleam
deleted file mode 100644
index 9e27d22..0000000
--- a/test/std/list_test.gleam
+++ /dev/null
@@ -1,351 +0,0 @@
-import std/expect
-import std/list
-import std/int
-import std/string
-
-pub fn length_test() {
-  list:length([]) |> expect:equal(_, 0)
-  list:length([1]) |> expect:equal(_, 1)
-  list:length([1, 1]) |> expect:equal(_, 2)
-  list:length([1, 1, 1]) |> expect:equal(_, 3)
-}
-
-pub fn reverse_test() {
-  list:reverse([]) |> expect:equal(_, [])
-  list:reverse([1, 2, 3, 4, 5]) |> expect:equal(_, [5, 4, 3, 2, 1])
-}
-
-pub fn is_empty_test() {
-  list:is_empty([]) |> expect:true
-  list:is_empty([1]) |> expect: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
-}
-
-pub fn head_test() {
-  list:head([0, 4, 5, 7])
-    |> expect:equal(_, Ok(0))
-
-  list:head([])
-    |> expect:is_error
-}
-
-pub fn tail_test() {
-  list:tail([0, 4, 5, 7])
-    |> expect:equal(_, Ok([4, 5, 7]))
-
-  list:tail([0])
-    |> expect:equal(_, Ok([]))
-
-  list:tail([])
-    |> expect:is_error
-}
-
-pub fn filter_test() {
-  []
-    |> list:filter(_, fn(_) { True })
-    |> expect:equal(_, [])
-
-  [0, 4, 5, 7, 3]
-    |> list:filter(_, fn(_) { True })
-    |> expect:equal(_, [0, 4, 5, 7, 3])
-
-  [0, 4, 5, 7, 3]
-    |> list:filter(_, fn(x) { x > 4 })
-    |> expect:equal(_, [5, 7])
-
-  [0, 4, 5, 7, 3]
-    |> list:filter(_, fn(x) { x < 4 })
-    |> expect:equal(_, [0, 3])
-}
-
-pub fn map_test() {
-  []
-    |> list:map(_, fn(x) { x * 2 })
-    |> expect:equal(_, [])
-
-  [0, 4, 5, 7, 3]
-    |> list:map(_, fn(x) { x * 2 })
-    |> expect:equal(_, [0, 8, 10, 14, 6])
-}
-
-pub fn traverse_test() {
-  let fun = fn(x) {
-    case x == 6 || x == 5 || x == 4 {
-    | True -> Ok(x * 2)
-    | False -> Error(x)
-    }
-  }
-
-  [5, 6, 5, 6]
-    |> list:traverse(_, fun)
-    |> expect:equal(_, Ok([10, 12, 10, 12]))
-
-  [4, 6, 5, 7, 3]
-    |> list:traverse(_, fun)
-    |> expect:equal(_, Error(7))
-}
-
-pub fn drop_test() {
-  []
-    |> list:drop(_, 5)
-    |> expect:equal(_, [])
-
-  [1, 2, 3, 4, 5, 6, 7, 8]
-    |> list:drop(_, 5)
-    |> expect:equal(_, [6, 7, 8])
-}
-
-pub fn take_test() {
-  []
-    |> list:take(_, 5)
-    |> expect:equal(_, [])
-  [1, 2, 3, 4, 5, 6, 7, 8]
-    |> list:take(_, 5)
-    |> expect:equal(_, [1, 2, 3, 4, 5])
-}
-
-pub fn new_test() {
-  list:new() |> expect:equal(_, [])
-}
-
-pub fn append_test() {
-  list:append([1], [2, 3])
-    |> expect:equal(_, [1, 2, 3])
-}
-
-pub fn flatten_test() {
-  list:flatten([])
-    |> expect:equal(_, [])
-
-  list:flatten([[]])
-    |> expect:equal(_, [])
-
-  list:flatten([[], [], []])
-    |> expect:equal(_, [])
-
-  list:flatten([[1, 2], [], [3, 4]])
-    |> expect:equal(_, [1, 2, 3, 4])
-}
-
-pub fn fold_test() {
-  [1, 2, 3]
-    |> list:fold(_, [], fn(x, acc) { [x | acc] })
-    |> expect:equal(_, [3, 2, 1])
-}
-
-pub fn fold_right_test() {
-  [1, 2, 3]
-    |> list:fold_right(_, [], fn(x, acc) { [x | acc] })
-    |> expect:equal(_, [1, 2, 3])
-}
-
-pub fn find_test() {
-  let f = fn(x) {
-    case x {
-    | 2 -> Ok(4)
-    | _ -> Error(0)
-    }
-  }
-
-  [1, 2, 3]
-  |> list:find(_, f)
-  |> expect:equal(_, Ok(4))
-
-  [1, 3, 2]
-  |> list:find(_, f)
-  |> expect:equal(_, Ok(4))
-
-  [1, 3]
-  |> list:find(_, f)
-  |> expect:is_error
-}
-
-pub fn all_test() {
-  list:all([1, 2, 3, 4, 5], fn(x) { x > 0 })
-  |> expect:equal(_, True)
-
-  list:all([1, 2, 3, 4, 5], fn(x) { x < 0 })
-  |> expect:equal(_, False)
-
-  list:all([], fn(_) { False })
-  |> expect:equal(_, True)
-}
-
-pub fn any_test() {
-  list:any([1, 2, 3, 4, 5], fn(x) { x == 2 })
-  |> expect:equal(_, True)
-
-  list:any([1, 2, 3, 4, 5], fn(x) { x < 0 })
-  |> expect:equal(_, False)
-
-  list:any([], fn(_) { False })
-  |> expect:equal(_, False)
-}
-
-pub fn zip_test() {
-  list:zip([], [1, 2, 3])
-  |> expect:equal(_, [])
-
-  list:zip([1, 2], [])
-  |> expect:equal(_, [])
-
-  list:zip([1, 2, 3], [4, 5, 6])
-  |> expect:equal(_, [{1, 4}, {2, 5}, {3, 6}])
-
-  list:zip([5, 6], [1, 2, 3])
-  |> expect:equal(_, [{5, 1}, {6, 2}])
-
-  list:zip([5, 6, 7], [1, 2])
-  |> expect:equal(_, [{5, 1}, {6, 2}])
-}
-
-pub fn strict_zip_test() {
-  list:strict_zip([], [1, 2, 3])
-  |> expect:is_error
-
-  list:strict_zip([1, 2], [])
-  |> expect:is_error
-
-  list:strict_zip([1, 2, 3], [4, 5, 6])
-  |> expect:equal(_, Ok([{1, 4}, {2, 5}, {3, 6}]))
-
-  list:strict_zip([5, 6], [1, 2, 3])
-  |> expect:is_error
-
-  list:strict_zip([5, 6, 7], [1, 2])
-  |> expect:is_error
-}
-
-pub fn intersperse_test() {
-  list:intersperse([1, 2, 3], 4)
-  |> expect:equal(_, [1, 4, 2, 4, 3])
-
-  list:intersperse([], 2)
-  |> expect:equal(_, [])
-}
-
-pub fn at_test() {
-  list:at([1, 2, 3], 2)
-  |> expect:equal(_, Ok(3))
-
-  list:at([1, 2, 3], 5)
-  |> expect:is_error
-
-  list:at([], 0)
-  |> expect:is_error
-
-  list:at([1, 2, 3, 4, 5, 6], -1)
-  |> expect:is_error
-}
-
-pub fn unique_test() {
-  list:unique([1, 1, 2, 3, 4, 4, 4, 5, 6])
-  |> expect: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])
-
-  list:unique([3, 4, 5])
-  |> expect:equal(_, [3, 4, 5])
-
-  list:unique([])
-  |> expect:equal(_, [])
-}
-
-pub fn sort_test() {
-  list:sort([4, 3, 6, 5, 4])
-  |> expect:equal(_, [3, 4, 4, 5, 6])
-
-  list:sort([])
-  |> expect:equal(_, [])
-
-  list:sort([{1, 2}, {4, 5}, {3, 2}])
-  |> expect:equal(_, [{1, 2}, {3, 2}, {4, 5}])
-}
-
-pub fn index_map_test() {
-  list:index_map([3, 4, 5], fn(i, x) { {i, x} })
-  |> expect:equal(_, [{0, 3}, {1, 4}, {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"])
-}
-
-pub fn range_test() {
-  list:range(0, 0)
-  |> expect:equal(_, [])
-
-  list:range(1, 1)
-  |> expect:equal(_, [])
-
-  list:range(-1, -1)
-  |> expect:equal(_, [])
-
-  list:range(0, 1)
-  |> expect:equal(_, [0])
-
-  list:range(0, 5)
-  |> expect:equal(_, [0, 1, 2, 3, 4])
-
-  list:range(1, -5)
-  |> expect:equal(_, [1, 0, -1, -2, -3, -4])
-}
-
-pub fn repeat_test() {
-  list:repeat(1, -10)
-  |> expect:equal(_, [])
-
-  list:repeat(1, 0)
-  |> expect:equal(_, [])
-
-  list:repeat(2, 3)
-  |> expect:equal(_, [2, 2, 2])
-
-  list:repeat("x", 5)
-  |> expect:equal(_, ["x", "x", "x", "x", "x"])
-}
-
-pub fn split_test() {
-  list:split([], 0)
-  |> expect:equal(_, {[], []})
-
-  list:split([0, 1, 2, 3, 4], 0)
-  |> expect:equal(_, {[], [0, 1, 2, 3, 4]})
-
-  list:split([0, 1, 2, 3, 4], -2)
-  |> expect:equal(_, {[], [0, 1, 2, 3, 4]})
-
-  list:split([0, 1, 2, 3, 4], 1)
-  |> expect:equal(_, {[0], [1, 2, 3, 4]})
-
-  list:split([0, 1, 2, 3, 4], 3)
-  |> expect:equal(_, {[0, 1, 2], [3, 4]})
-
-  list:split([0, 1, 2, 3, 4], 9)
-  |> expect:equal(_, {[0, 1, 2, 3, 4], []})
-}
-
-pub fn split_while_test() {
-  list:split_while([], fn(x) { x <= 5 })
-  |> expect:equal(_, {[], []})
-
-  list:split_while([1, 2, 3, 4, 5], fn(x) { x <= 5 })
-  |> expect:equal(_, {[1, 2, 3, 4, 5], []})
-
-  list:split_while([1, 2, 3, 4, 5], fn(x) { x == 2 })
-  |> expect:equal(_, {[], [1, 2, 3, 4, 5]})
-
-  list:split_while([1, 2, 3, 4, 5], fn(x) { x <= 3 })
-  |> expect:equal(_, {[1, 2, 3], [4, 5]})
-
-  list:split_while([1, 2, 3, 4, 5], fn(x) { x <= -3 })
-  |> expect:equal(_, {[], [1, 2, 3, 4, 5]})
-}
diff --git a/test/std/map_dict_test.gleam b/test/std/map_dict_test.gleam
deleted file mode 100644
index 892bc5d..0000000
--- a/test/std/map_dict_test.gleam
+++ /dev/null
@@ -1,233 +0,0 @@
-import std/string
-import std/expect
-import std/map_dict
-
-pub fn from_list_test() {
-  [
-    {4, 0},
-    {1, 0},
-  ]
-  |> map_dict:from_list
-  |> map_dict:size
-  |> expect:equal(_, 2)
-}
-
-pub fn has_key_test() {
-  []
-  |> map_dict:from_list
-  |> map_dict:has_key(_, 1)
-  |> expect:false
-
-  [
-      {1, 0},
-  ]
-  |> map_dict:from_list
-  |> map_dict:has_key(_, 1)
-  |> expect:true
-
-  [
-      {4, 0},
-      {1, 0},
-  ]
-  |> map_dict:from_list
-  |> map_dict:has_key(_, 1)
-  |> expect:true
-
-  [
-    {4, 0},
-    {1, 0},
-  ]
-  |> map_dict:from_list
-  |> map_dict:has_key(_, 0)
-  |> expect:false
-}
-
-pub fn new_test() {
-  map_dict:new()
-  |> map_dict:size
-  |> expect:equal(_, 0)
-
-  map_dict:new()
-  |> map_dict:to_list
-  |> expect:equal(_, [])
-}
-
-pub fn fetch_test() {
-  let proplist = [
-    {4, 0},
-    {1, 1},
-  ]
-  let m = map_dict:from_list(proplist)
-
-  m
-  |> map_dict:fetch(_, 4)
-  |> expect:equal(_, Ok(0))
-
-  m
-  |> map_dict:fetch(_, 1)
-  |> expect:equal(_, Ok(1))
-
-  m
-  |> map_dict:fetch(_, 2)
-  |> expect:is_error
-}
-
-pub fn put_test() {
-  map_dict:new()
-  |> map_dict:put(_, "a", 0)
-  |> map_dict:put(_, "b", 1)
-  |> map_dict:put(_, "c", 2)
-  |> expect:equal(_, map_dict:from_list([{"a", 0}, {"b", 1}, {"c", 2}]))
-}
-
-pub fn map_values_test() {
-  [
-    {1, 0},
-    {2, 1},
-    {3, 2},
-  ]
-  |> map_dict:from_list
-  |> map_dict:map_values(_, fn(k, v) { k + v })
-  |> expect:equal(_, map_dict:from_list([{1, 1}, {2, 3}, {3, 5}]))
-}
-
-pub fn keys_test() {
-  [
-    {"a", 0},
-    {"b", 1},
-    {"c", 2},
-  ]
-  |> map_dict:from_list
-  |> map_dict:keys
-  |> expect:equal(_, ["a", "b", "c"])
-}
-
-pub fn values_test() {
-  [
-    {"a", 0},
-    {"b", 1},
-    {"c", 2},
-  ]
-  |> map_dict:from_list
-  |> map_dict:values
-  |> expect:equal(_, [0, 1, 2])
-}
-
-pub fn take_test() {
-  [
-    {"a", 0},
-    {"b", 1},
-    {"c", 2},
-  ]
-  |> map_dict:from_list
-  |> map_dict:take(_, ["a", "b", "d"])
-  |> expect:equal(_, map_dict:from_list([{"a", 0}, {"b", 1}]))
-}
-
-pub fn drop_test() {
-  [
-    {"a", 0},
-    {"b", 1},
-    {"c", 2},
-  ]
-  |> map_dict:from_list
-  |> map_dict:drop(_, ["a", "b", "d"])
-  |> expect:equal(_, map_dict:from_list([{"c", 2}]))
-}
-
-pub fn merge_test() {
-  let a = map_dict:from_list([
-    {"a", 2},
-    {"c", 4},
-    {"d", 3},
-  ])
-  let b = map_dict:from_list([
-    {"a", 0},
-    {"b", 1},
-    {"c", 2},
-  ])
-
-  map_dict:merge(a, b)
-  |> expect:equal(_, map_dict:from_list([
-      {"a", 0},
-      {"b", 1},
-      {"c", 2},
-      {"d", 3},
-    ]))
-
-  map_dict:merge(b, a)
-  |> expect:equal(_, map_dict:from_list([
-      {"a", 2},
-      {"b", 1},
-      {"c", 4},
-      {"d", 3},
-    ]))
-}
-
-pub fn delete_test() {
-  [
-    {"a", 0},
-    {"b", 1},
-    {"c", 2},
-  ]
-  |> map_dict:from_list
-  |> map_dict:delete(_, "a")
-  |> map_dict:delete(_, "d")
-  |> expect:equal(_, map_dict:from_list([{"b", 1}, {"c", 2}]))
-}
-
-pub fn update_test() {
-  let dict = map_dict:from_list([
-    {"a", 0},
-    {"b", 1},
-    {"c", 2},
-  ])
-
-  let inc_or_zero = fn(x) {
-    case x {
-    | Ok(i) -> i + 1
-    | Error(_) -> 0
-    }
-  }
-
-  dict
-  |> map_dict:update(_, "a", inc_or_zero)
-  |> expect:equal(_, map_dict:from_list([{"a", 1}, {"b", 1}, {"c", 2}]))
-
-  dict
-  |> map_dict:update(_, "b", inc_or_zero)
-  |> expect:equal(_, map_dict:from_list([{"a", 0}, {"b", 2}, {"c", 2}]))
-
-  dict
-  |> map_dict:update(_, "z", inc_or_zero)
-  |> expect:equal(_, map_dict:from_list([{"a", 0}, {"b", 1}, {"c", 2}, {"z", 0}]))
-}
-
-pub fn fold_test() {
-  let dict = map_dict:from_list([
-    {"a", 0},
-    {"b", 1},
-    {"c", 2},
-    {"d", 3},
-  ])
-
-  let add = fn(_, v, acc) {
-    v + acc
-  }
-
-  dict
-  |> map_dict:fold(_, 0, add)
-  |> expect:equal(_, 6)
-
-  let concat = fn(k, _, acc) {
-    string:append(acc, k)
-  }
-
-  dict
-  |> map_dict:fold(_, "", concat)
-  |> expect:equal(_, "abcd")
-
-  map_dict:from_list([])
-  |> map_dict:fold(_, 0, add)
-  |> expect:equal(_, 0)
-}
diff --git a/test/std/order_test.gleam b/test/std/order_test.gleam
deleted file mode 100644
index aac0aae..0000000
--- a/test/std/order_test.gleam
+++ /dev/null
@@ -1,111 +0,0 @@
-import std/expect
-import std/order
-
-pub fn reverse_test() {
-  order:reverse(order:Lt)
-  |> expect:equal(_, order:Gt)
-
-  order:reverse(order:Eq)
-  |> expect:equal(_, order:Eq)
-
-  order:reverse(order:Gt)
-  |> expect:equal(_, order:Lt)
-}
-
-pub fn to_int_test() {
-  order:to_int(order:Lt)
-  |> expect:equal(_, -1)
-
-  order:to_int(order:Eq)
-  |> expect:equal(_, 0)
-
-  order:to_int(order:Gt)
-  |> expect:equal(_, 1)
-}
-
-pub fn compare_test() {
-  order:compare(order:Lt, order:Lt)
-  |> expect:equal(_, order:Eq)
-
-  order:compare(order:Lt, order:Eq)
-  |> expect:equal(_, order:Lt)
-
-  order:compare(order:Lt, order:Gt)
-  |> expect:equal(_, order:Lt)
-
-  order:compare(order:Eq, order:Lt)
-  |> expect:equal(_, order:Gt)
-
-  order:compare(order:Eq, order:Eq)
-  |> expect:equal(_, order:Eq)
-
-  order:compare(order:Eq, order:Gt)
-  |> expect:equal(_, order:Lt)
-
-  order:compare(order:Gt, order:Lt)
-  |> expect:equal(_, order:Gt)
-
-  order:compare(order:Gt, order:Eq)
-  |> expect:equal(_, order:Gt)
-
-  order:compare(order:Gt, order:Gt)
-  |> expect:equal(_, order:Eq)
-}
-
-pub fn max_test() {
-  order:max(order:Lt, order:Lt)
-  |> expect:equal(_, order:Lt)
-
-  order:max(order:Lt, order:Eq)
-  |> expect:equal(_, order:Eq)
-
-  order:max(order:Lt, order:Gt)
-  |> expect:equal(_, order:Gt)
-
-  order:max(order:Eq, order:Lt)
-  |> expect:equal(_, order:Eq)
-
-  order:max(order:Eq, order:Eq)
-  |> expect:equal(_, order:Eq)
-
-  order:max(order:Eq, order:Gt)
-  |> expect:equal(_, order:Gt)
-
-  order:max(order:Gt, order:Lt)
-  |> expect:equal(_, order:Gt)
-
-  order:max(order:Gt, order:Eq)
-  |> expect:equal(_, order:Gt)
-
-  order:max(order:Gt, order:Gt)
-  |> expect:equal(_, order:Gt)
-}
-
-pub fn min_test() {
-  order:min(order:Lt, order:Lt)
-  |> expect:equal(_, order:Lt)
-
-  order:min(order:Lt, order:Eq)
-  |> expect:equal(_, order:Lt)
-
-  order:min(order:Lt, order:Gt)
-  |> expect:equal(_, order:Lt)
-
-  order:min(order:Eq, order:Lt)
-  |> expect:equal(_, order:Lt)
-
-  order:min(order:Eq, order:Eq)
-  |> expect:equal(_, order:Eq)
-
-  order:min(order:Eq, order:Gt)
-  |> expect:equal(_, order:Eq)
-
-  order:min(order:Gt, order:Lt)
-  |> expect:equal(_, order:Lt)
-
-  order:min(order:Gt, order:Eq)
-  |> expect:equal(_, order:Eq)
-
-  order:min(order:Gt, order:Gt)
-  |> expect:equal(_, order:Gt)
-}
diff --git a/test/std/result_test.gleam b/test/std/result_test.gleam
deleted file mode 100644
index 41fd808..0000000
--- a/test/std/result_test.gleam
+++ /dev/null
@@ -1,88 +0,0 @@
-import std/expect
-import std/result
-
-pub fn is_ok_test() {
-  result:is_ok(Ok(1))
-  |> expect:true
-
-  result:is_ok(Error(1))
-  |> expect:false
-}
-
-pub fn is_error_test() {
-  result:is_error(Ok(1))
-  |> expect:false
-
-  result:is_error(Error(1))
-  |> expect:true
-}
-
-pub fn map_test() {
-  Ok(1)
-  |> result:map(_, fn(x) { x + 1 })
-  |> expect:equal(_, Ok(2))
-
-  Ok(1)
-  |> result:map(_, fn(_) { "2" })
-  |> expect:equal(_, Ok("2"))
-
-  Error(1)
-  |> result:map(_, fn(x) { x + 1 })
-  |> expect:equal(_, Error(1))
-}
-
-pub fn map_error_test() {
-  Ok(1)
-  |> result:map_error(_, fn(x) { x + 1 })
-  |> expect:equal(_, Ok(1))
-
-  Error(1)
-  |> result:map_error(_, fn(x) { x + 1 })
-  |> expect:equal(_, Error(2))
-}
-
-pub fn flatten_test() {
-  Ok(Ok(1))
-  |> result:flatten
-  |> expect:equal(_, Ok(1))
-
-  Ok(Error(1))
-  |> result:flatten
-  |> expect:equal(_, Error(1))
-
-  Error(1)
-  |> result:flatten
-  |> expect:equal(_, Error(1))
-
-  Error(Error(1))
-  |> result:flatten
-  |> expect:equal(_, Error(Error(1)))
-}
-
-pub fn then_test() {
-  Error(1)
-  |> result:then(_, fn(x) { Ok(x + 1) })
-  |> expect:equal(_, Error(1))
-
-  Ok(1)
-  |> result:then(_, fn(x) { Ok(x + 1) })
-  |> expect:equal(_, Ok(2))
-
-  Ok(1)
-  |> result:then(_, fn(_) { Ok("type change") })
-  |> expect:equal(_, Ok("type change"))
-
-  Ok(1)
-  |> result:then(_, fn(_) { Error(1) })
-  |> expect:equal(_, Error(1))
-}
-
-pub fn unwrap_test() {
-  Ok(1)
-  |> result:unwrap(_, 50)
-  |> expect:equal(_, 1)
-
-  Error("nope")
-  |> result:unwrap(_, 50)
-  |> expect:equal(_, 50)
-}
diff --git a/test/std/string_test.gleam b/test/std/string_test.gleam
deleted file mode 100644
index dd8a00e..0000000
--- a/test/std/string_test.gleam
+++ /dev/null
@@ -1,50 +0,0 @@
-import std/string
-import std/expect
-
-pub fn length_test() {
-  string:length("ß↑e̊")
-  |> expect:equal(_, 3)
-
-  string:length("Gleam")
-  |> expect:equal(_, 5)
-
-  string:length("")
-  |> expect:equal(_, 0)
-}
-
-pub fn lowercase_test() {
-  string:lowercase("Gleam")
-  |> expect:equal(_, "gleam")
-}
-
-pub fn uppercase_test() {
-  string:uppercase("Gleam")
-  |> expect:equal(_, "GLEAM")
-}
-
-pub fn reverse_test() {
-  string:reverse("Gleam")
-  |> expect:equal(_, "maelG")
-}
-
-pub fn split_test() {
-  "Gleam,Erlang,Elixir"
-  |> string:split(_, ",")
-  |> expect:equal(_, ["Gleam", "Erlang", "Elixir"])
-
-  "Gleam, Erlang,Elixir"
-  |> string:split(_, ", ")
-  |> expect:equal(_, ["Gleam", "Erlang,Elixir"])
-}
-
-pub fn replace_test() {
-  "Gleam,Erlang,Elixir"
-  |> string:replace(_, ",", "++")
-  |> expect:equal(_, "Gleam++Erlang++Elixir")
-}
-
-pub fn append_test() {
-  "Test"
-  |> string:append(_, " Me")
-  |> expect:equal(_, "Test Me")
-}
diff --git a/test/std/tuple_test.gleam b/test/std/tuple_test.gleam
deleted file mode 100644
index 31f1179..0000000
--- a/test/std/tuple_test.gleam
+++ /dev/null
@@ -1,44 +0,0 @@
-import std/expect
-import std/tuple
-
-pub fn new_test() {
-  tuple:new(1, 2)
-  |> expect:equal(_, {1, 2})
-
-  tuple:new(2, "3")
-  |> expect:equal(_, {2, "3"})
-}
-
-pub fn first_test() {
-  {1, 2}
-  |> tuple:first
-  |> expect:equal(_, 1)
-}
-
-pub fn second_test() {
-  {1, 2}
-  |> tuple:second
-  |> expect:equal(_, 2)
-}
-
-pub fn swap_test() {
-  {1, "2"}
-  |> tuple:swap
-  |> expect:equal(_, {"2", 1})
-}
-
-pub fn fetch_test() {
-  let proplist = [{0, "1"}, {1, "2"}]
-
-  proplist
-  |> tuple:fetch(_, 0)
-  |> expect:equal(_, Ok("1"))
-
-  proplist
-  |> tuple:fetch(_, 1)
-  |> expect:equal(_, Ok("2"))
-
-  proplist
-  |> tuple:fetch(_, 2)
-  |> expect:is_error
-}
-- 
cgit v1.2.3