JS tuple decoding

1 files changed, 374 insertions, 374 deletions

diff --git a/test/gleam/dynamic_test.gleam b/test/gleam/dynamic_test.gleam
index 3585cda..fd28f79 100644
--- a/test/gleam/dynamic_test.gleam
+++ b/test/gleam/dynamic_test.gleam
@@ -307,418 +307,418 @@ pub fn element_test() {
   |> should.equal(Error(DecodeError(expected: "Tuple", found: "Map")))
 }
 
-if erlang {
-  pub fn tuple2_test() {
-    #(1, 2)
-    |> dynamic.from
-    |> dynamic.tuple2
-    |> should.equal(Ok(#(dynamic.from(1), dynamic.from(2))))
-
-    #(1, "")
-    |> dynamic.from
-    |> dynamic.tuple2
-    |> should.equal(Ok(#(dynamic.from(1), dynamic.from(""))))
-
-    #(1, 2, 3)
-    |> dynamic.from
-    |> dynamic.tuple2
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 2 elements",
-      found: "Tuple of 3 elements",
-    )))
-
-    1
-    |> dynamic.from
-    |> dynamic.tuple2
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 2 elements",
-      found: "Int",
-    )))
-  }
+pub fn tuple2_test() {
+  #(1, 2)
+  |> dynamic.from
+  |> dynamic.tuple2
+  |> should.equal(Ok(#(dynamic.from(1), dynamic.from(2))))
 
-  pub fn typed_tuple2_test() {
-    #(1, 2)
-    |> dynamic.from
-    |> dynamic.typed_tuple2(dynamic.int, dynamic.int)
-    |> should.equal(Ok(#(1, 2)))
+  #(1, "")
+  |> dynamic.from
+  |> dynamic.tuple2
+  |> should.equal(Ok(#(dynamic.from(1), dynamic.from(""))))
 
-    #(1, "")
-    |> dynamic.from
-    |> dynamic.typed_tuple2(dynamic.int, dynamic.string)
-    |> should.equal(Ok(#(1, "")))
+  #(1, 2, 3)
+  |> dynamic.from
+  |> dynamic.tuple2
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 2 elements",
+    found: "Tuple of 3 elements",
+  )))
 
-    #(1, "")
-    |> dynamic.from
-    |> dynamic.typed_tuple2(dynamic.int, dynamic.int)
-    |> should.equal(Error(DecodeError(expected: "Int", found: "String")))
+  1
+  |> dynamic.from
+  |> dynamic.tuple2
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 2 elements",
+    found: "Int",
+  )))
+}
 
-    #(1, 2, 3)
-    |> dynamic.from
-    |> dynamic.typed_tuple2(dynamic.int, dynamic.int)
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 2 elements",
-      found: "Tuple of 3 elements",
-    )))
+pub fn typed_tuple2_test() {
+  #(1, 2)
+  |> dynamic.from
+  |> dynamic.typed_tuple2(dynamic.int, dynamic.int)
+  |> should.equal(Ok(#(1, 2)))
 
-    1
-    |> dynamic.from
-    |> dynamic.typed_tuple2(dynamic.int, dynamic.int)
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 2 elements",
-      found: "Int",
-    )))
-  }
+  #(1, "")
+  |> dynamic.from
+  |> dynamic.typed_tuple2(dynamic.int, dynamic.string)
+  |> should.equal(Ok(#(1, "")))
 
-  pub fn tuple3_test() {
-    #(1, 2, 3)
-    |> dynamic.from
-    |> dynamic.tuple3
-    |> should.equal(Ok(#(dynamic.from(1), dynamic.from(2), dynamic.from(3))))
+  #(1, "")
+  |> dynamic.from
+  |> dynamic.typed_tuple2(dynamic.int, dynamic.int)
+  |> should.equal(Error(DecodeError(expected: "Int", found: "String")))
 
-    #(1, "", 3.0)
-    |> dynamic.from
-    |> dynamic.tuple3
-    |> should.equal(Ok(#(dynamic.from(1), dynamic.from(""), dynamic.from(3.0))))
+  #(1, 2, 3)
+  |> dynamic.from
+  |> dynamic.typed_tuple2(dynamic.int, dynamic.int)
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 2 elements",
+    found: "Tuple of 3 elements",
+  )))
 
-    #(1, 2)
-    |> dynamic.from
-    |> dynamic.tuple3
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 3 elements",
-      found: "Tuple of 2 elements",
-    )))
+  1
+  |> dynamic.from
+  |> dynamic.typed_tuple2(dynamic.int, dynamic.int)
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 2 elements",
+    found: "Int",
+  )))
+}
 
-    1
-    |> dynamic.from
-    |> dynamic.tuple3
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 3 elements",
-      found: "Int",
-    )))
-  }
+pub fn tuple3_test() {
+  #(1, 2, 3)
+  |> dynamic.from
+  |> dynamic.tuple3
+  |> should.equal(Ok(#(dynamic.from(1), dynamic.from(2), dynamic.from(3))))
 
-  pub fn typed_tuple3_test() {
-    #(1, 2, 3)
-    |> dynamic.from
-    |> dynamic.typed_tuple3(dynamic.int, dynamic.int, dynamic.int)
-    |> should.equal(Ok(#(1, 2, 3)))
+  #(1, "", 3.0)
+  |> dynamic.from
+  |> dynamic.tuple3
+  |> should.equal(Ok(#(dynamic.from(1), dynamic.from(""), dynamic.from(3.0))))
 
-    #(1, "", 3.0)
-    |> dynamic.from
-    |> dynamic.typed_tuple3(dynamic.int, dynamic.string, dynamic.float)
-    |> should.equal(Ok(#(1, "", 3.0)))
+  #(1, 2)
+  |> dynamic.from
+  |> dynamic.tuple3
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 3 elements",
+    found: "Tuple of 2 elements",
+  )))
 
-    #(1, 2, "")
-    |> dynamic.from
-    |> dynamic.typed_tuple3(dynamic.int, dynamic.int, dynamic.int)
-    |> should.equal(Error(DecodeError(expected: "Int", found: "String")))
+  1
+  |> dynamic.from
+  |> dynamic.tuple3
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 3 elements",
+    found: "Int",
+  )))
+}
 
-    #(1, 2)
-    |> dynamic.from
-    |> dynamic.typed_tuple3(dynamic.int, dynamic.int, dynamic.int)
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 3 elements",
-      found: "Tuple of 2 elements",
-    )))
+pub fn typed_tuple3_test() {
+  #(1, 2, 3)
+  |> dynamic.from
+  |> dynamic.typed_tuple3(dynamic.int, dynamic.int, dynamic.int)
+  |> should.equal(Ok(#(1, 2, 3)))
 
-    1
-    |> dynamic.from
-    |> dynamic.typed_tuple3(dynamic.int, dynamic.int, dynamic.int)
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 3 elements",
-      found: "Int",
-    )))
-  }
+  #(1, "", 3.0)
+  |> dynamic.from
+  |> dynamic.typed_tuple3(dynamic.int, dynamic.string, dynamic.float)
+  |> should.equal(Ok(#(1, "", 3.0)))
 
-  pub fn tuple4_test() {
-    #(1, 2, 3, 4)
-    |> dynamic.from
-    |> dynamic.tuple4
-    |> should.equal(Ok(#(
-      dynamic.from(1),
-      dynamic.from(2),
-      dynamic.from(3),
-      dynamic.from(4),
-    )))
+  #(1, 2, "")
+  |> dynamic.from
+  |> dynamic.typed_tuple3(dynamic.int, dynamic.int, dynamic.int)
+  |> should.equal(Error(DecodeError(expected: "Int", found: "String")))
 
-    #(1, "", 3.0, 4)
-    |> dynamic.from
-    |> dynamic.tuple4
-    |> should.equal(Ok(#(
-      dynamic.from(1),
-      dynamic.from(""),
-      dynamic.from(3.0),
-      dynamic.from(4),
-    )))
+  #(1, 2)
+  |> dynamic.from
+  |> dynamic.typed_tuple3(dynamic.int, dynamic.int, dynamic.int)
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 3 elements",
+    found: "Tuple of 2 elements",
+  )))
 
-    #(1, 2)
-    |> dynamic.from
-    |> dynamic.tuple4
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 4 elements",
-      found: "Tuple of 2 elements",
-    )))
+  1
+  |> dynamic.from
+  |> dynamic.typed_tuple3(dynamic.int, dynamic.int, dynamic.int)
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 3 elements",
+    found: "Int",
+  )))
+}
 
-    1
-    |> dynamic.from
-    |> dynamic.tuple4
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 4 elements",
-      found: "Int",
-    )))
-  }
+pub fn tuple4_test() {
+  #(1, 2, 3, 4)
+  |> dynamic.from
+  |> dynamic.tuple4
+  |> should.equal(Ok(#(
+    dynamic.from(1),
+    dynamic.from(2),
+    dynamic.from(3),
+    dynamic.from(4),
+  )))
 
-  pub fn typed_tuple4_test() {
-    #(1, 2, 3, 4)
-    |> dynamic.from
-    |> dynamic.typed_tuple4(dynamic.int, dynamic.int, dynamic.int, dynamic.int)
-    |> should.equal(Ok(#(1, 2, 3, 4)))
+  #(1, "", 3.0, 4)
+  |> dynamic.from
+  |> dynamic.tuple4
+  |> should.equal(Ok(#(
+    dynamic.from(1),
+    dynamic.from(""),
+    dynamic.from(3.0),
+    dynamic.from(4),
+  )))
 
-    #(1, "", 3.0, 4)
-    |> dynamic.from
-    |> dynamic.typed_tuple4(
-      dynamic.int,
-      dynamic.string,
-      dynamic.float,
-      dynamic.int,
-    )
-    |> should.equal(Ok(#(1, "", 3.0, 4)))
+  #(1, 2)
+  |> dynamic.from
+  |> dynamic.tuple4
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 4 elements",
+    found: "Tuple of 2 elements",
+  )))
 
-    #(1, 2, 3, "")
-    |> dynamic.from
-    |> dynamic.typed_tuple4(dynamic.int, dynamic.int, dynamic.int, dynamic.int)
-    |> should.equal(Error(DecodeError(expected: "Int", found: "String")))
+  1
+  |> dynamic.from
+  |> dynamic.tuple4
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 4 elements",
+    found: "Int",
+  )))
+}
 
-    #(1, 2)
-    |> dynamic.from
-    |> dynamic.typed_tuple4(dynamic.int, dynamic.int, dynamic.int, dynamic.int)
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 4 elements",
-      found: "Tuple of 2 elements",
-    )))
+pub fn typed_tuple4_test() {
+  #(1, 2, 3, 4)
+  |> dynamic.from
+  |> dynamic.typed_tuple4(dynamic.int, dynamic.int, dynamic.int, dynamic.int)
+  |> should.equal(Ok(#(1, 2, 3, 4)))
 
-    1
-    |> dynamic.from
-    |> dynamic.typed_tuple4(dynamic.int, dynamic.int, dynamic.int, dynamic.int)
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 4 elements",
-      found: "Int",
-    )))
-  }
+  #(1, "", 3.0, 4)
+  |> dynamic.from
+  |> dynamic.typed_tuple4(
+    dynamic.int,
+    dynamic.string,
+    dynamic.float,
+    dynamic.int,
+  )
+  |> should.equal(Ok(#(1, "", 3.0, 4)))
+
+  #(1, 2, 3, "")
+  |> dynamic.from
+  |> dynamic.typed_tuple4(dynamic.int, dynamic.int, dynamic.int, dynamic.int)
+  |> should.equal(Error(DecodeError(expected: "Int", found: "String")))
 
-  pub fn tuple5_test() {
-    #(1, 2, 3, 4, 5)
-    |> dynamic.from
-    |> dynamic.tuple5
-    |> should.equal(Ok(#(
-      dynamic.from(1),
-      dynamic.from(2),
-      dynamic.from(3),
-      dynamic.from(4),
-      dynamic.from(5),
-    )))
+  #(1, 2)
+  |> dynamic.from
+  |> dynamic.typed_tuple4(dynamic.int, dynamic.int, dynamic.int, dynamic.int)
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 4 elements",
+    found: "Tuple of 2 elements",
+  )))
 
-    #(1, "", 3.0, 4, 5)
-    |> dynamic.from
-    |> dynamic.tuple5
-    |> should.equal(Ok(#(
-      dynamic.from(1),
-      dynamic.from(""),
-      dynamic.from(3.0),
-      dynamic.from(4),
-      dynamic.from(5),
-    )))
+  1
+  |> dynamic.from
+  |> dynamic.typed_tuple4(dynamic.int, dynamic.int, dynamic.int, dynamic.int)
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 4 elements",
+    found: "Int",
+  )))
+}
 
-    #(1, 2)
-    |> dynamic.from
-    |> dynamic.tuple5
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 5 elements",
-      found: "Tuple of 2 elements",
-    )))
+pub fn tuple5_test() {
+  #(1, 2, 3, 4, 5)
+  |> dynamic.from
+  |> dynamic.tuple5
+  |> should.equal(Ok(#(
+    dynamic.from(1),
+    dynamic.from(2),
+    dynamic.from(3),
+    dynamic.from(4),
+    dynamic.from(5),
+  )))
 
-    1
-    |> dynamic.from
-    |> dynamic.tuple5
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 5 elements",
-      found: "Int",
-    )))
-  }
+  #(1, "", 3.0, 4, 5)
+  |> dynamic.from
+  |> dynamic.tuple5
+  |> should.equal(Ok(#(
+    dynamic.from(1),
+    dynamic.from(""),
+    dynamic.from(3.0),
+    dynamic.from(4),
+    dynamic.from(5),
+  )))
 
-  pub fn typed_tuple5_test() {
-    #(1, 2, 3, 4, 5)
-    |> dynamic.from
-    |> dynamic.typed_tuple5(
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-    )
-    |> should.equal(Ok(#(1, 2, 3, 4, 5)))
-
-    #(1, "", 3.0, 4, 5)
-    |> dynamic.from
-    |> dynamic.typed_tuple5(
-      dynamic.int,
-      dynamic.string,
-      dynamic.float,
-      dynamic.int,
-      dynamic.int,
-    )
-    |> should.equal(Ok(#(1, "", 3.0, 4, 5)))
-
-    #(1, 2, 3, 4, "")
-    |> dynamic.from
-    |> dynamic.typed_tuple5(
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-    )
-    |> should.equal(Error(DecodeError(expected: "Int", found: "String")))
+  #(1, 2)
+  |> dynamic.from
+  |> dynamic.tuple5
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 5 elements",
+    found: "Tuple of 2 elements",
+  )))
 
-    #(1, 2)
-    |> dynamic.from
-    |> dynamic.typed_tuple5(
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-    )
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 5 elements",
-      found: "Tuple of 2 elements",
-    )))
+  1
+  |> dynamic.from
+  |> dynamic.tuple5
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 5 elements",
+    found: "Int",
+  )))
+}
 
-    1
-    |> dynamic.from
-    |> dynamic.typed_tuple5(
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-    )
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 5 elements",
-      found: "Int",
-    )))
-  }
+pub fn typed_tuple5_test() {
+  #(1, 2, 3, 4, 5)
+  |> dynamic.from
+  |> dynamic.typed_tuple5(
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+  )
+  |> should.equal(Ok(#(1, 2, 3, 4, 5)))
+
+  #(1, "", 3.0, 4, 5)
+  |> dynamic.from
+  |> dynamic.typed_tuple5(
+    dynamic.int,
+    dynamic.string,
+    dynamic.float,
+    dynamic.int,
+    dynamic.int,
+  )
+  |> should.equal(Ok(#(1, "", 3.0, 4, 5)))
+
+  #(1, 2, 3, 4, "")
+  |> dynamic.from
+  |> dynamic.typed_tuple5(
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+  )
+  |> should.equal(Error(DecodeError(expected: "Int", found: "String")))
+
+  #(1, 2)
+  |> dynamic.from
+  |> dynamic.typed_tuple5(
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+  )
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 5 elements",
+    found: "Tuple of 2 elements",
+  )))
 
-  pub fn tuple6_test() {
-    #(1, 2, 3, 4, 5, 6)
-    |> dynamic.from
-    |> dynamic.tuple6
-    |> should.equal(Ok(#(
-      dynamic.from(1),
-      dynamic.from(2),
-      dynamic.from(3),
-      dynamic.from(4),
-      dynamic.from(5),
-      dynamic.from(6),
-    )))
+  1
+  |> dynamic.from
+  |> dynamic.typed_tuple5(
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+  )
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 5 elements",
+    found: "Int",
+  )))
+}
 
-    #(1, "", 3.0, 4, 5, 6)
-    |> dynamic.from
-    |> dynamic.tuple6
-    |> should.equal(Ok(#(
-      dynamic.from(1),
-      dynamic.from(""),
-      dynamic.from(3.0),
-      dynamic.from(4),
-      dynamic.from(5),
-      dynamic.from(6),
-    )))
+pub fn tuple6_test() {
+  #(1, 2, 3, 4, 5, 6)
+  |> dynamic.from
+  |> dynamic.tuple6
+  |> should.equal(Ok(#(
+    dynamic.from(1),
+    dynamic.from(2),
+    dynamic.from(3),
+    dynamic.from(4),
+    dynamic.from(5),
+    dynamic.from(6),
+  )))
 
-    #(1, 2)
-    |> dynamic.from
-    |> dynamic.tuple6
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 6 elements",
-      found: "Tuple of 2 elements",
-    )))
+  #(1, "", 3.0, 4, 5, 6)
+  |> dynamic.from
+  |> dynamic.tuple6
+  |> should.equal(Ok(#(
+    dynamic.from(1),
+    dynamic.from(""),
+    dynamic.from(3.0),
+    dynamic.from(4),
+    dynamic.from(5),
+    dynamic.from(6),
+  )))
 
-    1
-    |> dynamic.from
-    |> dynamic.tuple6
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 6 elements",
-      found: "Int",
-    )))
-  }
+  #(1, 2)
+  |> dynamic.from
+  |> dynamic.tuple6
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 6 elements",
+    found: "Tuple of 2 elements",
+  )))
 
-  pub fn typed_tuple6_test() {
-    #(1, 2, 3, 4, 5, 6)
-    |> dynamic.from
-    |> dynamic.typed_tuple6(
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-    )
-    |> should.equal(Ok(#(1, 2, 3, 4, 5, 6)))
-
-    #(1, "", 3.0, 4, 5, 6)
-    |> dynamic.from
-    |> dynamic.typed_tuple6(
-      dynamic.int,
-      dynamic.string,
-      dynamic.float,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-    )
-    |> should.equal(Ok(#(1, "", 3.0, 4, 5, 6)))
-
-    #(1, 2, 3, 4, 5, "")
-    |> dynamic.from
-    |> dynamic.typed_tuple6(
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-    )
-    |> should.equal(Error(DecodeError(expected: "Int", found: "String")))
+  1
+  |> dynamic.from
+  |> dynamic.tuple6
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 6 elements",
+    found: "Int",
+  )))
+}
 
-    #(1, 2)
-    |> dynamic.from
-    |> dynamic.typed_tuple6(
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-    )
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 6 elements",
-      found: "Tuple of 2 elements",
-    )))
+pub fn typed_tuple6_test() {
+  #(1, 2, 3, 4, 5, 6)
+  |> dynamic.from
+  |> dynamic.typed_tuple6(
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+  )
+  |> should.equal(Ok(#(1, 2, 3, 4, 5, 6)))
+
+  #(1, "", 3.0, 4, 5, 6)
+  |> dynamic.from
+  |> dynamic.typed_tuple6(
+    dynamic.int,
+    dynamic.string,
+    dynamic.float,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+  )
+  |> should.equal(Ok(#(1, "", 3.0, 4, 5, 6)))
+
+  #(1, 2, 3, 4, 5, "")
+  |> dynamic.from
+  |> dynamic.typed_tuple6(
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+  )
+  |> should.equal(Error(DecodeError(expected: "Int", found: "String")))
+
+  #(1, 2)
+  |> dynamic.from
+  |> dynamic.typed_tuple6(
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+  )
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 6 elements",
+    found: "Tuple of 2 elements",
+  )))
 
-    1
-    |> dynamic.from
-    |> dynamic.typed_tuple6(
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-      dynamic.int,
-    )
-    |> should.equal(Error(DecodeError(
-      expected: "Tuple of 6 elements",
-      found: "Int",
-    )))
-  }
+  1
+  |> dynamic.from
+  |> dynamic.typed_tuple6(
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+    dynamic.int,
+  )
+  |> should.equal(Error(DecodeError(
+    expected: "Tuple of 6 elements",
+    found: "Int",
+  )))
+}
 
+if erlang {
   pub fn map_test() {
     map.new()
     |> dynamic.from