Reformat to new tuple syntax

10 files changed, 189 insertions, 216 deletions

diff --git a/test/gleam/dynamic_test.gleam b/test/gleam/dynamic_test.gleam
index 50c5ac4..2cc82b1 100644
--- a/test/gleam/dynamic_test.gleam
+++ b/test/gleam/dynamic_test.gleam
@@ -273,7 +273,7 @@ pub fn field_test() {
 
 pub fn element_test() {
   let Ok(ok_atom) = atom.from_string("ok")
-  let ok_one_tuple = tuple(ok_atom, 1)
+  let ok_one_tuple = #(ok_atom, 1)
 
   ok_one_tuple
   |> dynamic.from
@@ -308,17 +308,17 @@ pub fn element_test() {
 }
 
 pub fn tuple2_test() {
-  tuple(1, 2)
+  #(1, 2)
   |> dynamic.from
   |> dynamic.tuple2
-  |> should.equal(Ok(tuple(dynamic.from(1), dynamic.from(2))))
+  |> should.equal(Ok(#(dynamic.from(1), dynamic.from(2))))
 
-  tuple(1, "")
+  #(1, "")
   |> dynamic.from
   |> dynamic.tuple2
-  |> should.equal(Ok(tuple(dynamic.from(1), dynamic.from(""))))
+  |> should.equal(Ok(#(dynamic.from(1), dynamic.from(""))))
 
-  tuple(1, 2, 3)
+  #(1, 2, 3)
   |> dynamic.from
   |> dynamic.tuple2
   |> should.equal(Error("Expected a 2 element tuple, got a 3 element tuple"))
@@ -330,22 +330,22 @@ pub fn tuple2_test() {
 }
 
 pub fn typed_tuple2_test() {
-  tuple(1, 2)
+  #(1, 2)
   |> dynamic.from
   |> dynamic.typed_tuple2(dynamic.int, dynamic.int)
-  |> should.equal(Ok(tuple(1, 2)))
+  |> should.equal(Ok(#(1, 2)))
 
-  tuple(1, "")
+  #(1, "")
   |> dynamic.from
   |> dynamic.typed_tuple2(dynamic.int, dynamic.string)
-  |> should.equal(Ok(tuple(1, "")))
+  |> should.equal(Ok(#(1, "")))
 
-  tuple(1, "")
+  #(1, "")
   |> dynamic.from
   |> dynamic.typed_tuple2(dynamic.int, dynamic.int)
   |> should.equal(Error("Expected an int, got a binary"))
 
-  tuple(1, 2, 3)
+  #(1, 2, 3)
   |> dynamic.from
   |> dynamic.typed_tuple2(dynamic.int, dynamic.int)
   |> should.equal(Error("Expected a 2 element tuple, got a 3 element tuple"))
@@ -357,17 +357,17 @@ pub fn typed_tuple2_test() {
 }
 
 pub fn tuple3_test() {
-  tuple(1, 2, 3)
+  #(1, 2, 3)
   |> dynamic.from
   |> dynamic.tuple3
-  |> should.equal(Ok(tuple(dynamic.from(1), dynamic.from(2), dynamic.from(3))))
+  |> should.equal(Ok(#(dynamic.from(1), dynamic.from(2), dynamic.from(3))))
 
-  tuple(1, "", 3.0)
+  #(1, "", 3.0)
   |> dynamic.from
   |> dynamic.tuple3
-  |> should.equal(Ok(tuple(dynamic.from(1), dynamic.from(""), dynamic.from(3.0))))
+  |> should.equal(Ok(#(dynamic.from(1), dynamic.from(""), dynamic.from(3.0))))
 
-  tuple(1, 2)
+  #(1, 2)
   |> dynamic.from
   |> dynamic.tuple3
   |> should.equal(Error("Expected a 3 element tuple, got a 2 element tuple"))
@@ -379,22 +379,22 @@ pub fn tuple3_test() {
 }
 
 pub fn typed_tuple3_test() {
-  tuple(1, 2, 3)
+  #(1, 2, 3)
   |> dynamic.from
   |> dynamic.typed_tuple3(dynamic.int, dynamic.int, dynamic.int)
-  |> should.equal(Ok(tuple(1, 2, 3)))
+  |> should.equal(Ok(#(1, 2, 3)))
 
-  tuple(1, "", 3.0)
+  #(1, "", 3.0)
   |> dynamic.from
   |> dynamic.typed_tuple3(dynamic.int, dynamic.string, dynamic.float)
-  |> should.equal(Ok(tuple(1, "", 3.0)))
+  |> should.equal(Ok(#(1, "", 3.0)))
 
-  tuple(1, 2, "")
+  #(1, 2, "")
   |> dynamic.from
   |> dynamic.typed_tuple3(dynamic.int, dynamic.int, dynamic.int)
   |> should.equal(Error("Expected an int, got a binary"))
 
-  tuple(1, 2)
+  #(1, 2)
   |> dynamic.from
   |> dynamic.typed_tuple3(dynamic.int, dynamic.int, dynamic.int)
   |> should.equal(Error("Expected a 3 element tuple, got a 2 element tuple"))
@@ -406,27 +406,27 @@ pub fn typed_tuple3_test() {
 }
 
 pub fn tuple4_test() {
-  tuple(1, 2, 3, 4)
+  #(1, 2, 3, 4)
   |> dynamic.from
   |> dynamic.tuple4
-  |> should.equal(Ok(tuple(
+  |> should.equal(Ok(#(
     dynamic.from(1),
     dynamic.from(2),
     dynamic.from(3),
     dynamic.from(4),
   )))
 
-  tuple(1, "", 3.0, 4)
+  #(1, "", 3.0, 4)
   |> dynamic.from
   |> dynamic.tuple4
-  |> should.equal(Ok(tuple(
+  |> should.equal(Ok(#(
     dynamic.from(1),
     dynamic.from(""),
     dynamic.from(3.0),
     dynamic.from(4),
   )))
 
-  tuple(1, 2)
+  #(1, 2)
   |> dynamic.from
   |> dynamic.tuple4
   |> should.equal(Error("Expected a 4 element tuple, got a 2 element tuple"))
@@ -438,12 +438,12 @@ pub fn tuple4_test() {
 }
 
 pub fn typed_tuple4_test() {
-  tuple(1, 2, 3, 4)
+  #(1, 2, 3, 4)
   |> dynamic.from
   |> dynamic.typed_tuple4(dynamic.int, dynamic.int, dynamic.int, dynamic.int)
-  |> should.equal(Ok(tuple(1, 2, 3, 4)))
+  |> should.equal(Ok(#(1, 2, 3, 4)))
 
-  tuple(1, "", 3.0, 4)
+  #(1, "", 3.0, 4)
   |> dynamic.from
   |> dynamic.typed_tuple4(
     dynamic.int,
@@ -451,14 +451,14 @@ pub fn typed_tuple4_test() {
     dynamic.float,
     dynamic.int,
   )
-  |> should.equal(Ok(tuple(1, "", 3.0, 4)))
+  |> should.equal(Ok(#(1, "", 3.0, 4)))
 
-  tuple(1, 2, 3, "")
+  #(1, 2, 3, "")
   |> dynamic.from
   |> dynamic.typed_tuple4(dynamic.int, dynamic.int, dynamic.int, dynamic.int)
   |> should.equal(Error("Expected an int, got a binary"))
 
-  tuple(1, 2)
+  #(1, 2)
   |> dynamic.from
   |> dynamic.typed_tuple4(dynamic.int, dynamic.int, dynamic.int, dynamic.int)
   |> should.equal(Error("Expected a 4 element tuple, got a 2 element tuple"))
@@ -470,10 +470,10 @@ pub fn typed_tuple4_test() {
 }
 
 pub fn tuple5_test() {
-  tuple(1, 2, 3, 4, 5)
+  #(1, 2, 3, 4, 5)
   |> dynamic.from
   |> dynamic.tuple5
-  |> should.equal(Ok(tuple(
+  |> should.equal(Ok(#(
     dynamic.from(1),
     dynamic.from(2),
     dynamic.from(3),
@@ -481,10 +481,10 @@ pub fn tuple5_test() {
     dynamic.from(5),
   )))
 
-  tuple(1, "", 3.0, 4, 5)
+  #(1, "", 3.0, 4, 5)
   |> dynamic.from
   |> dynamic.tuple5
-  |> should.equal(Ok(tuple(
+  |> should.equal(Ok(#(
     dynamic.from(1),
     dynamic.from(""),
     dynamic.from(3.0),
@@ -492,7 +492,7 @@ pub fn tuple5_test() {
     dynamic.from(5),
   )))
 
-  tuple(1, 2)
+  #(1, 2)
   |> dynamic.from
   |> dynamic.tuple5
   |> should.equal(Error("Expected a 5 element tuple, got a 2 element tuple"))
@@ -504,7 +504,7 @@ pub fn tuple5_test() {
 }
 
 pub fn typed_tuple5_test() {
-  tuple(1, 2, 3, 4, 5)
+  #(1, 2, 3, 4, 5)
   |> dynamic.from
   |> dynamic.typed_tuple5(
     dynamic.int,
@@ -513,9 +513,9 @@ pub fn typed_tuple5_test() {
     dynamic.int,
     dynamic.int,
   )
-  |> should.equal(Ok(tuple(1, 2, 3, 4, 5)))
+  |> should.equal(Ok(#(1, 2, 3, 4, 5)))
 
-  tuple(1, "", 3.0, 4, 5)
+  #(1, "", 3.0, 4, 5)
   |> dynamic.from
   |> dynamic.typed_tuple5(
     dynamic.int,
@@ -524,9 +524,9 @@ pub fn typed_tuple5_test() {
     dynamic.int,
     dynamic.int,
   )
-  |> should.equal(Ok(tuple(1, "", 3.0, 4, 5)))
+  |> should.equal(Ok(#(1, "", 3.0, 4, 5)))
 
-  tuple(1, 2, 3, 4, "")
+  #(1, 2, 3, 4, "")
   |> dynamic.from
   |> dynamic.typed_tuple5(
     dynamic.int,
@@ -537,7 +537,7 @@ pub fn typed_tuple5_test() {
   )
   |> should.equal(Error("Expected an int, got a binary"))
 
-  tuple(1, 2)
+  #(1, 2)
   |> dynamic.from
   |> dynamic.typed_tuple5(
     dynamic.int,
@@ -561,10 +561,10 @@ pub fn typed_tuple5_test() {
 }
 
 pub fn tuple6_test() {
-  tuple(1, 2, 3, 4, 5, 6)
+  #(1, 2, 3, 4, 5, 6)
   |> dynamic.from
   |> dynamic.tuple6
-  |> should.equal(Ok(tuple(
+  |> should.equal(Ok(#(
     dynamic.from(1),
     dynamic.from(2),
     dynamic.from(3),
@@ -573,10 +573,10 @@ pub fn tuple6_test() {
     dynamic.from(6),
   )))
 
-  tuple(1, "", 3.0, 4, 5, 6)
+  #(1, "", 3.0, 4, 5, 6)
   |> dynamic.from
   |> dynamic.tuple6
-  |> should.equal(Ok(tuple(
+  |> should.equal(Ok(#(
     dynamic.from(1),
     dynamic.from(""),
     dynamic.from(3.0),
@@ -585,7 +585,7 @@ pub fn tuple6_test() {
     dynamic.from(6),
   )))
 
-  tuple(1, 2)
+  #(1, 2)
   |> dynamic.from
   |> dynamic.tuple6
   |> should.equal(Error("Expected a 6 element tuple, got a 2 element tuple"))
@@ -597,7 +597,7 @@ pub fn tuple6_test() {
 }
 
 pub fn typed_tuple6_test() {
-  tuple(1, 2, 3, 4, 5, 6)
+  #(1, 2, 3, 4, 5, 6)
   |> dynamic.from
   |> dynamic.typed_tuple6(
     dynamic.int,
@@ -607,9 +607,9 @@ pub fn typed_tuple6_test() {
     dynamic.int,
     dynamic.int,
   )
-  |> should.equal(Ok(tuple(1, 2, 3, 4, 5, 6)))
+  |> should.equal(Ok(#(1, 2, 3, 4, 5, 6)))
 
-  tuple(1, "", 3.0, 4, 5, 6)
+  #(1, "", 3.0, 4, 5, 6)
   |> dynamic.from
   |> dynamic.typed_tuple6(
     dynamic.int,
@@ -619,9 +619,9 @@ pub fn typed_tuple6_test() {
     dynamic.int,
     dynamic.int,
   )
-  |> should.equal(Ok(tuple(1, "", 3.0, 4, 5, 6)))
+  |> should.equal(Ok(#(1, "", 3.0, 4, 5, 6)))
 
-  tuple(1, 2, 3, 4, 5, "")
+  #(1, 2, 3, 4, 5, "")
   |> dynamic.from
   |> dynamic.typed_tuple6(
     dynamic.int,
@@ -633,7 +633,7 @@ pub fn typed_tuple6_test() {
   )
   |> should.equal(Error("Expected an int, got a binary"))
 
-  tuple(1, 2)
+  #(1, 2)
   |> dynamic.from
   |> dynamic.typed_tuple6(
     dynamic.int,
@@ -710,7 +710,7 @@ pub fn result_test() {
 
   let tag = atom.create_from_string("bad")
 
-  tuple(tag, "value")
+  #(tag, "value")
   |> dynamic.from
   |> dynamic.result
   |> should.equal(Error("Expected a tag of \"ok\" or \"error\", got \"bad\""))
diff --git a/test/gleam/function_test.gleam b/test/gleam/function_test.gleam
index c9ef8ad..721d10d 100644
--- a/test/gleam/function_test.gleam
+++ b/test/gleam/function_test.gleam
@@ -103,9 +103,9 @@ pub fn identity_test() {
   |> function.identity
   |> should.equal([])
 
-  tuple(1, 2.0)
+  #(1, 2.0)
   |> function.identity
-  |> should.equal(tuple(1, 2.0))
+  |> should.equal(#(1, 2.0))
 }
 
 external fn throw(a) -> Nil =
diff --git a/test/gleam/iterator_test.gleam b/test/gleam/iterator_test.gleam
index 8d426e9..0fb7143 100644
--- a/test/gleam/iterator_test.gleam
+++ b/test/gleam/iterator_test.gleam
@@ -261,7 +261,7 @@ pub fn index_test() {
   iterator.from_list(["a", "b", "c"])
   |> iterator.index
   |> iterator.to_list
-  |> should.equal([tuple(0, "a"), tuple(1, "b"), tuple(2, "c")])
+  |> should.equal([#(0, "a"), #(1, "b"), #(2, "c")])
 }
 
 pub fn iterate_test() {
@@ -297,7 +297,7 @@ pub fn zip_test() {
   iterator.from_list(["a", "b", "c"])
   |> iterator.zip(iterator.range(20, 30))
   |> iterator.to_list
-  |> should.equal([tuple("a", 20), tuple("b", 21), tuple("c", 22)])
+  |> should.equal([#("a", 20), #("b", 21), #("c", 22)])
 }
 
 pub fn chunk_test() {
@@ -367,11 +367,7 @@ pub fn all_test() {
 pub fn group_test() {
   iterator.from_list([1, 2, 3, 4, 5, 6])
   |> iterator.group(by: fn(n) { n % 3 })
-  |> should.equal(map.from_list([
-    tuple(0, [3, 6]),
-    tuple(1, [1, 4]),
-    tuple(2, [2, 5]),
-  ]))
+  |> should.equal(map.from_list([#(0, [3, 6]), #(1, [1, 4]), #(2, [2, 5])]))
 }
 
 pub fn reduce_test() {
diff --git a/test/gleam/list_test.gleam b/test/gleam/list_test.gleam
index 16abd0a..1e90583 100644
--- a/test/gleam/list_test.gleam
+++ b/test/gleam/list_test.gleam
@@ -101,8 +101,8 @@ pub fn map_test() {
 
 pub fn map_fold_test() {
   [1, 2, 3, 4]
-  |> list.map_fold(from: 0, with: fn(i, acc) { tuple(i * 2, acc + i) })
-  |> should.equal(tuple([2, 4, 6, 8], 10))
+  |> list.map_fold(from: 0, with: fn(i, acc) { #(i * 2, acc + i) })
+  |> should.equal(#([2, 4, 6, 8], 10))
 }
 
 pub fn try_map_test() {
@@ -179,8 +179,8 @@ pub fn fold_right_test() {
 
 pub fn index_fold_test() {
   ["a", "b", "c"]
-  |> list.index_fold([], fn(ix, i, acc) { [tuple(ix, i), ..acc] })
-  |> should.equal([tuple(2, "c"), tuple(1, "b"), tuple(0, "a")])
+  |> list.index_fold([], fn(ix, i, acc) { [#(ix, i), ..acc] })
+  |> should.equal([#(2, "c"), #(1, "b"), #(0, "a")])
 }
 
 pub fn fold_until_test() {
@@ -290,13 +290,13 @@ pub fn zip_test() {
   |> should.equal([])
 
   list.zip([1, 2, 3], [4, 5, 6])
-  |> should.equal([tuple(1, 4), tuple(2, 5), tuple(3, 6)])
+  |> should.equal([#(1, 4), #(2, 5), #(3, 6)])
 
   list.zip([5, 6], [1, 2, 3])
-  |> should.equal([tuple(5, 1), tuple(6, 2)])
+  |> should.equal([#(5, 1), #(6, 2)])
 
   list.zip([5, 6, 7], [1, 2])
-  |> should.equal([tuple(5, 1), tuple(6, 2)])
+  |> should.equal([#(5, 1), #(6, 2)])
 }
 
 pub fn strict_zip_test() {
@@ -307,7 +307,7 @@ pub fn strict_zip_test() {
   |> should.equal(Error(list.LengthMismatch))
 
   list.strict_zip([1, 2, 3], [4, 5, 6])
-  |> should.equal(Ok([tuple(1, 4), tuple(2, 5), tuple(3, 6)]))
+  |> should.equal(Ok([#(1, 4), #(2, 5), #(3, 6)]))
 
   list.strict_zip([5, 6], [1, 2, 3])
   |> should.equal(Error(list.LengthMismatch))
@@ -317,11 +317,11 @@ pub fn strict_zip_test() {
 }
 
 pub fn unzip_test() {
-  list.unzip([tuple(1, 2), tuple(3, 4)])
-  |> should.equal(tuple([1, 3], [2, 4]))
+  list.unzip([#(1, 2), #(3, 4)])
+  |> should.equal(#([1, 3], [2, 4]))
 
   list.unzip([])
-  |> should.equal(tuple([], []))
+  |> should.equal(#([], []))
 }
 
 pub fn intersperse_test() {
@@ -379,8 +379,8 @@ pub fn sort_test() {
 }
 
 pub fn index_map_test() {
-  list.index_map([3, 4, 5], fn(i, x) { tuple(i, x) })
-  |> should.equal([tuple(0, 3), tuple(1, 4), tuple(2, 5)])
+  list.index_map([3, 4, 5], fn(i, x) { #(i, x) })
+  |> should.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)
@@ -424,53 +424,53 @@ pub fn repeat_test() {
 pub fn split_test() {
   []
   |> list.split(0)
-  |> should.equal(tuple([], []))
+  |> should.equal(#([], []))
 
   [0, 1, 2, 3, 4]
   |> list.split(0)
-  |> should.equal(tuple([], [0, 1, 2, 3, 4]))
+  |> should.equal(#([], [0, 1, 2, 3, 4]))
 
   [0, 1, 2, 3, 4]
   |> list.split(-2)
-  |> should.equal(tuple([], [0, 1, 2, 3, 4]))
+  |> should.equal(#([], [0, 1, 2, 3, 4]))
 
   [0, 1, 2, 3, 4]
   |> list.split(1)
-  |> should.equal(tuple([0], [1, 2, 3, 4]))
+  |> should.equal(#([0], [1, 2, 3, 4]))
 
   [0, 1, 2, 3, 4]
   |> list.split(3)
-  |> should.equal(tuple([0, 1, 2], [3, 4]))
+  |> should.equal(#([0, 1, 2], [3, 4]))
 
   [0, 1, 2, 3, 4]
   |> list.split(9)
-  |> should.equal(tuple([0, 1, 2, 3, 4], []))
+  |> should.equal(#([0, 1, 2, 3, 4], []))
 }
 
 pub fn split_while_test() {
   []
   |> list.split_while(fn(x) { x <= 5 })
-  |> should.equal(tuple([], []))
+  |> should.equal(#([], []))
 
   [1, 2, 3, 4, 5]
   |> list.split_while(fn(x) { x <= 5 })
-  |> should.equal(tuple([1, 2, 3, 4, 5], []))
+  |> should.equal(#([1, 2, 3, 4, 5], []))
 
   [1, 2, 3, 4, 5]
   |> list.split_while(fn(x) { x == 2 })
-  |> should.equal(tuple([], [1, 2, 3, 4, 5]))
+  |> should.equal(#([], [1, 2, 3, 4, 5]))
 
   [1, 2, 3, 4, 5]
   |> list.split_while(fn(x) { x <= 3 })
-  |> should.equal(tuple([1, 2, 3], [4, 5]))
+  |> should.equal(#([1, 2, 3], [4, 5]))
 
   [1, 2, 3, 4, 5]
   |> list.split_while(fn(x) { x <= -3 })
-  |> should.equal(tuple([], [1, 2, 3, 4, 5]))
+  |> should.equal(#([], [1, 2, 3, 4, 5]))
 }
 
 pub fn key_find_test() {
-  let proplist = [tuple(0, "1"), tuple(1, "2")]
+  let proplist = [#(0, "1"), #(1, "2")]
 
   proplist
   |> list.key_find(0)
@@ -487,7 +487,7 @@ pub fn key_find_test() {
 
 pub fn pop_test() {
   list.pop([1, 2, 3], fn(x) { x > 2 })
-  |> should.equal(Ok(tuple(3, [1, 2])))
+  |> should.equal(Ok(#(3, [1, 2])))
 
   list.pop([1, 2, 3], fn(x) { x > 4 })
   |> should.equal(Error(Nil))
@@ -498,7 +498,7 @@ pub fn pop_test() {
 
 pub fn pop_map_test() {
   list.pop_map(["foo", "2", "3"], int.parse)
-  |> should.equal(Ok(tuple(2, ["foo", "3"])))
+  |> should.equal(Ok(#(2, ["foo", "3"])))
 
   list.pop_map(["foo", "bar"], int.parse)
   |> should.equal(Error(Nil))
@@ -508,30 +508,30 @@ pub fn pop_map_test() {
 }
 
 pub fn key_pop_test() {
-  list.key_pop([tuple("a", 0), tuple("b", 1)], "a")
-  |> should.equal(Ok(tuple(0, [tuple("b", 1)])))
+  list.key_pop([#("a", 0), #("b", 1)], "a")
+  |> should.equal(Ok(#(0, [#("b", 1)])))
 
-  list.key_pop([tuple("a", 0), tuple("b", 1)], "b")
-  |> should.equal(Ok(tuple(1, [tuple("a", 0)])))
+  list.key_pop([#("a", 0), #("b", 1)], "b")
+  |> should.equal(Ok(#(1, [#("a", 0)])))
 
-  list.key_pop([tuple("a", 0), tuple("b", 1)], "c")
+  list.key_pop([#("a", 0), #("b", 1)], "c")
   |> should.equal(Error(Nil))
 }
 
 pub fn key_set_test() {
-  [tuple(5, 0), tuple(4, 1)]
+  [#(5, 0), #(4, 1)]
   |> list.key_set(4, 100)
-  |> should.equal([tuple(5, 0), tuple(4, 100)])
+  |> should.equal([#(5, 0), #(4, 100)])
 
-  [tuple(5, 0), tuple(4, 1)]
+  [#(5, 0), #(4, 1)]
   |> list.key_set(1, 100)
-  |> should.equal([tuple(5, 0), tuple(4, 1), tuple(1, 100)])
+  |> should.equal([#(5, 0), #(4, 1), #(1, 100)])
 }
 
 pub fn partition_test() {
   [1, 2, 3, 4, 5, 6, 7]
   |> list.partition(int.is_odd)
-  |> should.equal(tuple([1, 3, 5, 7], [2, 4, 6]))
+  |> should.equal(#([1, 3, 5, 7], [2, 4, 6]))
 }
 
 pub fn permutations_test() {
@@ -578,7 +578,7 @@ pub fn window_test() {
 pub fn window_by_2_test() {
   [1, 2, 3, 4]
   |> list.window_by_2
-  |> should.equal([tuple(1, 2), tuple(2, 3), tuple(3, 4)])
+  |> should.equal([#(1, 2), #(2, 3), #(3, 4)])
 
   [1]
   |> list.window_by_2
@@ -679,18 +679,11 @@ pub fn combination_pairs_test() {
   |> should.equal([])
 
   list.combination_pairs([1, 2])
-  |> should.equal([tuple(1, 2)])
+  |> should.equal([#(1, 2)])
 
   list.combination_pairs([1, 2, 3])
-  |> should.equal([tuple(1, 2), tuple(1, 3), tuple(2, 3)])
+  |> should.equal([#(1, 2), #(1, 3), #(2, 3)])
 
   list.combination_pairs([1, 2, 3, 4])
-  |> should.equal([
-    tuple(1, 2),
-    tuple(1, 3),
-    tuple(1, 4),
-    tuple(2, 3),
-    tuple(2, 4),
-    tuple(3, 4),
-  ])
+  |> should.equal([#(1, 2), #(1, 3), #(1, 4), #(2, 3), #(2, 4), #(3, 4)])
 }
diff --git a/test/gleam/map_test.gleam b/test/gleam/map_test.gleam
index 74641e2..e393a7f 100644
--- a/test/gleam/map_test.gleam
+++ b/test/gleam/map_test.gleam
@@ -3,14 +3,14 @@ import gleam/should
 import gleam/map
 
 pub fn from_list_test() {
-  [tuple(4, 0), tuple(1, 0)]
+  [#(4, 0), #(1, 0)]
   |> map.from_list
   |> map.size
   |> should.equal(2)
 
-  [tuple(1, 0), tuple(1, 1)]
+  [#(1, 0), #(1, 1)]
   |> map.from_list
-  |> should.equal(map.from_list([tuple(1, 1)]))
+  |> should.equal(map.from_list([#(1, 1)]))
 }
 
 pub fn has_key_test() {
@@ -19,17 +19,17 @@ pub fn has_key_test() {
   |> map.has_key(1)
   |> should.be_false
 
-  [tuple(1, 0)]
+  [#(1, 0)]
   |> map.from_list
   |> map.has_key(1)
   |> should.be_true
 
-  [tuple(4, 0), tuple(1, 0)]
+  [#(4, 0), #(1, 0)]
   |> map.from_list
   |> map.has_key(1)
   |> should.be_true
 
-  [tuple(4, 0), tuple(1, 0)]
+  [#(4, 0), #(1, 0)]
   |> map.from_list
   |> map.has_key(0)
   |> should.be_false
@@ -46,7 +46,7 @@ pub fn new_test() {
 }
 
 pub fn get_test() {
-  let proplist = [tuple(4, 0), tuple(1, 1)]
+  let proplist = [#(4, 0), #(1, 1)]
   let m = map.from_list(proplist)
 
   m
@@ -67,76 +67,66 @@ pub fn insert_test() {
   |> map.insert("a", 0)
   |> map.insert("b", 1)
   |> map.insert("c", 2)
-  |> should.equal(map.from_list([tuple("a", 0), tuple("b", 1), tuple("c", 2)]))
+  |> should.equal(map.from_list([#("a", 0), #("b", 1), #("c", 2)]))
 }
 
 pub fn map_values_test() {
-  [tuple(1, 0), tuple(2, 1), tuple(3, 2)]
+  [#(1, 0), #(2, 1), #(3, 2)]
   |> map.from_list
   |> map.map_values(fn(k, v) { k + v })
-  |> should.equal(map.from_list([tuple(1, 1), tuple(2, 3), tuple(3, 5)]))
+  |> should.equal(map.from_list([#(1, 1), #(2, 3), #(3, 5)]))
 }
 
 pub fn keys_test() {
-  [tuple("a", 0), tuple("b", 1), tuple("c", 2)]
+  [#("a", 0), #("b", 1), #("c", 2)]
   |> map.from_list
   |> map.keys
   |> should.equal(["a", "b", "c"])
 }
 
 pub fn values_test() {
-  [tuple("a", 0), tuple("b", 1), tuple("c", 2)]
+  [#("a", 0), #("b", 1), #("c", 2)]
   |> map.from_list
   |> map.values
   |> should.equal([0, 1, 2])
 }
 
 pub fn take_test() {
-  [tuple("a", 0), tuple("b", 1), tuple("c", 2)]
+  [#("a", 0), #("b", 1), #("c", 2)]
   |> map.from_list
   |> map.take(["a", "b", "d"])
-  |> should.equal(map.from_list([tuple("a", 0), tuple("b", 1)]))
+  |> should.equal(map.from_list([#("a", 0), #("b", 1)]))
 }
 
 pub fn drop_test() {
-  [tuple("a", 0), tuple("b", 1), tuple("c", 2)]
+  [#("a", 0), #("b", 1), #("c", 2)]
   |> map.from_list
   |> map.drop(["a", "b", "d"])
-  |> should.equal(map.from_list([tuple("c", 2)]))
+  |> should.equal(map.from_list([#("c", 2)]))
 }
 
 pub fn merge_test() {
-  let a = map.from_list([tuple("a", 2), tuple("c", 4), tuple("d", 3)])
+  let a = map.from_list([#("a", 2), #("c", 4), #("d", 3)])
 
-  let b = map.from_list([tuple("a", 0), tuple("b", 1), tuple("c", 2)])
+  let b = map.from_list([#("a", 0), #("b", 1), #("c", 2)])
 
   map.merge(a, b)
-  |> should.equal(map.from_list([
-    tuple("a", 0),
-    tuple("b", 1),
-    tuple("c", 2),
-    tuple("d", 3),
-  ]))
+  |> should.equal(map.from_list([#("a", 0), #("b", 1), #("c", 2), #("d", 3)]))
 
   map.merge(b, a)
-  |> should.equal(map.from_list([
-    tuple("a", 2),
-    tuple("b", 1),
-    tuple("c", 4),
-    tuple("d", 3),
-  ]))
+  |> should.equal(map.from_list([#("a", 2), #("b", 1), #("c", 4), #("d", 3)]))
 }
 
 pub fn delete_test() {
-  [tuple("a", 0), tuple("b", 1), tuple("c", 2)]
+  [#("a", 0), #("b", 1), #("c", 2)]
   |> map.from_list
   |> map.delete("a")
   |> map.delete("d")
-  |> should.equal(map.from_list([tuple("b", 1), tuple("c", 2)]))
+  |> should.equal(map.from_list([#("b", 1), #("c", 2)]))
 }
 
 pub fn update_test() {
-  let dict = map.from_list([tuple("a", 0), tuple("b", 1), tuple("c", 2)])
+  let dict = map.from_list([#("a", 0), #("b", 1), #("c", 2)])
 
   let inc_or_zero = fn(x) {
     case x {
@@ -147,25 +137,19 @@ pub fn update_test() {
 
   dict
   |> map.update("a", inc_or_zero)
-  |> should.equal(map.from_list([tuple("a", 1), tuple("b", 1), tuple("c", 2)]))
+  |> should.equal(map.from_list([#("a", 1), #("b", 1), #("c", 2)]))
 
   dict
   |> map.update("b", inc_or_zero)
-  |> should.equal(map.from_list([tuple("a", 0), tuple("b", 2), tuple("c", 2)]))
+  |> should.equal(map.from_list([#("a", 0), #("b", 2), #("c", 2)]))
 
   dict
   |> map.update("z", inc_or_zero)
-  |> should.equal(map.from_list([
-    tuple("a", 0),
-    tuple("b", 1),
-    tuple("c", 2),
-    tuple("z", 0),
-  ]))
+  |> should.equal(map.from_list([#("a", 0), #("b", 1), #("c", 2), #("z", 0)]))
 }
 
 pub fn fold_test() {
-  let dict =
-    map.from_list([tuple("a", 0), tuple("b", 1), tuple("c", 2), tuple("d", 3)])
+  let dict = map.from_list([#("a", 0), #("b", 1), #("c", 2), #("d", 3)])
 
   let add = fn(_, v, acc) { v + acc }
 
diff --git a/test/gleam/os_test.gleam b/test/gleam/os_test.gleam
index 815a9e0..6385453 100644
--- a/test/gleam/os_test.gleam
+++ b/test/gleam/os_test.gleam
@@ -30,7 +30,7 @@ pub fn system_time_test() {
 pub fn erlang_timestamp_test() {
   // in microseconds
   let june_12_2020 = 1591966971000000
-  let tuple(mega_seconds, seconds, micro_seconds) = os.erlang_timestamp()
+  let #(mega_seconds, seconds, micro_seconds) = os.erlang_timestamp()
 
   let stamp_as_micro =
     { mega_seconds * 1_000_000 + seconds } * 1_000_000 + micro_seconds
diff --git a/test/gleam/pair_test.gleam b/test/gleam/pair_test.gleam
index 6b88887..1950929 100644
--- a/test/gleam/pair_test.gleam
+++ b/test/gleam/pair_test.gleam
@@ -2,57 +2,57 @@ import gleam/should
 import gleam/pair
 
 pub fn first_test() {
-  tuple(1, 2)
+  #(1, 2)
   |> pair.first
   |> should.equal(1)
 
-  tuple("abc", [])
+  #("abc", [])
   |> pair.first
   |> should.equal("abc")
 }
 
 pub fn second_test() {
-  tuple(1, 2)
+  #(1, 2)
   |> pair.second
   |> should.equal(2)
 
-  tuple("abc", [])
+  #("abc", [])
   |> pair.second
   |> should.equal([])
 }
 
 pub fn swap_test() {
-  tuple(1, "2")
+  #(1, "2")
   |> pair.swap
-  |> should.equal(tuple("2", 1))
+  |> should.equal(#("2", 1))
 }
 
 pub fn map_first_test() {
   let inc = fn(a) { a + 1 }
-  pair.map_first(tuple(1, 2), inc)
-  |> should.equal(tuple(2, 2))
+  pair.map_first(#(1, 2), inc)
+  |> should.equal(#(2, 2))
 
-  pair.map_first(tuple(8, 2), inc)
-  |> should.equal(tuple(9, 2))
+  pair.map_first(#(8, 2), inc)
+  |> should.equal(#(9, 2))
 
-  pair.map_first(tuple(0, -2), inc)
-  |> should.equal(tuple(1, -2))
+  pair.map_first(#(0, -2), inc)
+  |> should.equal(#(1, -2))
 
-  pair.map_first(tuple(-10, 20), inc)
-  |> should.equal(tuple(-9, 20))
+  pair.map_first(#(-10, 20), inc)
+  |> should.equal(#(-9, 20))
 }
 
 pub fn map_second_test() {
   let dec = fn(a) { a - 1 }
-  pair.map_second(tuple(1, 2), dec)
-  |> should.equal(tuple(1, 1))
+  pair.map_second(#(1, 2), dec)
+  |> should.equal(#(1, 1))
 
-  pair.map_second(tuple(8, 2), dec)
-  |> should.equal(tuple(8, 1))
+  pair.map_second(#(8, 2), dec)
+  |> should.equal(#(8, 1))
 
-  pair.map_second(tuple(0, -2), dec)
-  |> should.equal(tuple(0, -3))
+  pair.map_second(#(0, -2), dec)
+  |> should.equal(#(0, -3))
 
-  pair.map_second(tuple(-10, 20), dec)
-  |> should.equal(tuple(-10, 19))
+  pair.map_second(#(-10, 20), dec)
+  |> should.equal(#(-10, 19))
 }
diff --git a/test/gleam/result_test.gleam b/test/gleam/result_test.gleam
index 2036eae..5eb8a37 100644
--- a/test/gleam/result_test.gleam
+++ b/test/gleam/result_test.gleam
@@ -37,8 +37,8 @@ pub fn map_error_test() {
   |> should.equal(Ok(1))
 
   Error(1)
-  |> result.map_error(fn(x) { tuple("ok", x + 1) })
-  |> should.equal(Error(tuple("ok", 2)))
+  |> result.map_error(fn(x) { #("ok", x + 1) })
+  |> should.equal(Error(#("ok", 2)))
 }
 
 pub fn flatten_test() {
diff --git a/test/gleam/string_test.gleam b/test/gleam/string_test.gleam
index 3b1db57..805f3ae 100644
--- a/test/gleam/string_test.gleam
+++ b/test/gleam/string_test.gleam
@@ -41,7 +41,7 @@ pub fn split_test() {
 pub fn split_once_test() {
   "Gleam,Erlang,Elixir"
   |> string.split_once(",")
-  |> should.equal(Ok(tuple("Gleam", "Erlang,Elixir")))
+  |> should.equal(Ok(#("Gleam", "Erlang,Elixir")))
 
   "Gleam"
   |> string.split_once(",")
@@ -292,11 +292,11 @@ pub fn pad_right_test() {
 pub fn pop_grapheme_test() {
   "gleam"
   |> string.pop_grapheme()
-  |> should.equal(Ok(tuple("g", "leam")))
+  |> should.equal(Ok(#("g", "leam")))
 
   "g"
   |> string.pop_grapheme()
-  |> should.equal(Ok(tuple("g", "")))
+  |> should.equal(Ok(#("g", "")))
 
   ""
   |> string.pop_grapheme()
diff --git a/test/gleam/uri_test.gleam b/test/gleam/uri_test.gleam
index f0c4eb5..c0ee595 100644
--- a/test/gleam/uri_test.gleam
+++ b/test/gleam/uri_test.gleam
@@ -66,13 +66,13 @@ pub fn path_only_uri_to_string_test() {
 
 pub fn parse_query_string_test() {
   assert Ok(parsed) = uri.parse_query("foo+bar=1&city=%C3%B6rebro")
-  should.equal(parsed, [tuple("foo bar", "1"), tuple("city", "örebro")])
+  should.equal(parsed, [#("foo bar", "1"), #("city", "örebro")])
 
   // Duplicates keys not overridden
   assert Ok(parsed) = uri.parse_query("a[]=1&a[]=2")
 
   parsed
-  |> should.equal([tuple("a[]", "1"), tuple("a[]", "2")])
+  |> should.equal([#("a[]", "1"), #("a[]", "2")])
 }
 
 pub fn parse_empty_query_string_test() {
@@ -82,7 +82,7 @@ pub fn parse_empty_query_string_test() {
 
 pub fn parse_query_string_with_empty_test() {
   uri.parse_query("present")
-  |> should.equal(Ok([tuple("present", "")]))
+  |> should.equal(Ok([#("present", "")]))
 }
 
 pub fn error_parsing_query_test() {
@@ -91,7 +91,7 @@ pub fn error_parsing_query_test() {
 
 pub fn query_to_string_test() {
   let query_string =
-    uri.query_to_string([tuple("foo bar", "1"), tuple("city", "örebro")])
+    uri.query_to_string([#("foo bar", "1"), #("city", "örebro")])
   should.equal(query_string, "foo+bar=1&city=%C3%B6rebro")
 }
 
@@ -102,37 +102,37 @@ pub fn empty_query_to_string_test() {
 
 fn percent_codec_fixtures() {
   [
-    tuple(" ", "+"),
-    tuple(",", "%2C"),
-    tuple(";", "%3B"),
-    tuple(":", "%3A"),
-    tuple("!", "%21"),
-    tuple("?", "%3F"),
-    tuple("'", "%27"),
-    tuple("(", "%28"),
-    tuple(")", "%29"),
-    tuple("[", "%5B"),
-    tuple("@", "%40"),
-    tuple("/", "%2F"),
-    tuple("\\", "%5C"),
-    tuple("&", "%26"),
-    tuple("#", "%23"),
-    tuple("=", "%3D"),
-    tuple("~", "%7E"),
-    tuple("ñ", "%C3%B1"),
+    #(" ", "+"),
+    #(",", "%2C"),
+    #(";", "%3B"),
+    #(":", "%3A"),
+    #("!", "%21"),
+    #("?", "%3F"),
+    #("'", "%27"),
+    #("(", "%28"),
+    #(")", "%29"),
+    #("[", "%5B"),
+    #("@", "%40"),
+    #("/", "%2F"),
+    #("\\", "%5C"),
+    #("&", "%26"),
+    #("#", "%23"),
+    #("=", "%3D"),
+    #("~", "%7E"),
+    #("ñ", "%C3%B1"),
     // Allowed chars
-    tuple("-", "-"),
-    tuple("_", "_"),
-    tuple(".", "."),
-    tuple("*", "*"),
-    tuple("100% great", "100%25+great"),
+    #("-", "-"),
+    #("_", "_"),
+    #(".", "."),
+    #("*", "*"),
+    #("100% great", "100%25+great"),
   ]
 }
 
 pub fn percent_encode_test() {
   percent_codec_fixtures()
   |> list.map(fn(t) {
-    let tuple(a, b) = t
+    let #(a, b) = t
     uri.percent_encode(a)
     |> should.equal(b)
   })
@@ -142,7 +142,7 @@ pub fn percent_encode_consistency_test() {
   let k = "foo bar[]"
   let v = "ñaña (,:*~)"
 
-  let query_string = uri.query_to_string([tuple(k, v)])
+  let query_string = uri.query_to_string([#(k, v)])
 
   let encoded_key = uri.percent_encode(k)
   let encoded_value = uri.percent_encode(v)
@@ -154,7 +154,7 @@ pub fn percent_encode_consistency_test() {
 pub fn percent_decode_test() {
   percent_codec_fixtures()
   |> list.map(fn(t) {
-    let tuple(a, b) = t
+    let #(a, b) = t
     uri.percent_decode(b)
     |> should.equal(Ok(a))
   })
@@ -169,7 +169,7 @@ pub fn percent_decode_consistency_test() {
   assert Ok(decoded_key) = uri.percent_decode(k)
   assert Ok(decoded_value) = uri.percent_decode(v)
 
-  should.equal(parsed, [tuple(decoded_key, decoded_value)])
+  should.equal(parsed, [#(decoded_key, decoded_value)])
 }
 
 pub fn parse_segments_test() {