Fix coerce errors messages, js tuple from list fixes

3 files changed, 39 insertions, 36 deletions

diff --git a/src/gleam_stdlib.erl b/src/gleam_stdlib.erl
index 79ded3f..e891202 100644
--- a/src/gleam_stdlib.erl
+++ b/src/gleam_stdlib.erl
@@ -99,23 +99,23 @@ decode_tuple(Data) -> decode_error_msg(<<"Tuple">>, Data).
 
 decode_tuple2({_,_} = A) -> {ok, A};
 decode_tuple2([A,B]) -> {ok, {A,B}};
-decode_tuple2(Data) -> decode_error_msg(<<"Tuple or List of 2 elements">>, Data).
+decode_tuple2(Data) -> decode_error_msg(<<"Tuple of 2 elements">>, Data).
 
 decode_tuple3({_,_,_} = A) -> {ok, A};
 decode_tuple3([A,B,C]) -> {ok, {A,B,C}};
-decode_tuple3(Data) -> decode_error_msg(<<"Tuple or List of 3 elements">>, Data).
+decode_tuple3(Data) -> decode_error_msg(<<"Tuple of 3 elements">>, Data).
 
 decode_tuple4({_,_,_,_} = A) -> {ok, A};
 decode_tuple4([A,B,C,D]) -> {ok, {A,B,C,D}};
-decode_tuple4(Data) -> decode_error_msg(<<"Tuple or List of 4 elements">>, Data).
+decode_tuple4(Data) -> decode_error_msg(<<"Tuple of 4 elements">>, Data).
 
 decode_tuple5({_,_,_,_,_} = A) -> {ok, A};
 decode_tuple5([A,B,C,D,E]) -> {ok, {A,B,C,D,E}};
-decode_tuple5(Data) -> decode_error_msg(<<"Tuple or List of 5 elements">>, Data).
+decode_tuple5(Data) -> decode_error_msg(<<"Tuple of 5 elements">>, Data).
 
 decode_tuple6({_,_,_,_,_,_} = A) -> {ok, A};
 decode_tuple6([A,B,C,D,E,F]) -> {ok, {A,B,C,D,E,F}};
-decode_tuple6(Data) -> decode_error_msg(<<"Tuple or List of 6 elements">>, Data).
+decode_tuple6(Data) -> decode_error_msg(<<"Tuple of 6 elements">>, Data).
 
 decode_option(Term, F) ->
     Decode = fun(Inner) ->
diff --git a/src/gleam_stdlib.mjs b/src/gleam_stdlib.mjs
index d9825e7..7c41cdd 100644
--- a/src/gleam_stdlib.mjs
+++ b/src/gleam_stdlib.mjs
@@ -637,26 +637,29 @@ export function decode_tuple6(data) {
 }
 
 function decode_tupleN(data, n) {
-  let error_message = `Tuple or List of ${n} elements`;
-
-  if (!(List.isList(data) || Array.isArray(data))) {
-    return decoder_error(error_message, data);
+  if (Array.isArray(data) && data.length == n) {
+    return new Ok(data)
   }
 
-  let array = List.isList(data) ? [...data] : data; 
+  let list = decode_exact_length_list(data, n)
+  if (list) return new Ok(list)
 
-  let i = 0;
-  for (; i < n; i++) {
-    if (array[i] === undefined) {
-      return decoder_error(error_message, data);
-    }
-  }
+  return decoder_error(`Tuple of ${n} elements`, data);
+}
 
-  if (array[i] === undefined) {
-    return new Ok(array);
-  } else {
-    return decoder_error(error_message, data);
+function decode_exact_length_list(data, n) {
+  if (!List.isList(data)) return;
+
+  let elements = []
+  let current = data
+
+  for (let i = 0; i < n; i++) {
+    if (current.isEmpty()) break;
+    elements.push(current.head)
+    current = current.tail
   }
+
+  if (elements.length === n && current.isEmpty()) return elements
 }
 
 export function tuple_get(data, index) {
diff --git a/test/gleam/dynamic_test.gleam b/test/gleam/dynamic_test.gleam
index 936be49..fbe750f 100644
--- a/test/gleam/dynamic_test.gleam
+++ b/test/gleam/dynamic_test.gleam
@@ -511,7 +511,7 @@ pub fn tuple2_test() {
   |> should.equal(Error([
     DecodeError(
       path: [],
-      expected: "Tuple or List of 2 elements",
+      expected: "Tuple of 2 elements",
       found: "Tuple of 3 elements",
     ),
   ]))
@@ -520,7 +520,7 @@ pub fn tuple2_test() {
   |> dynamic.from
   |> dynamic.tuple2(dynamic.int, dynamic.int)
   |> should.equal(Error([
-    DecodeError(path: [], expected: "Tuple or List of 2 elements", found: "Int"),
+    DecodeError(path: [], expected: "Tuple of 2 elements", found: "Int"),
   ]))
 
   [1, 2]
@@ -547,7 +547,7 @@ pub fn tuple2_test() {
   |> should.equal(Error([
     DecodeError(
       path: [],
-      expected: "Tuple or List of 2 elements",
+      expected: "Tuple of 2 elements",
       found: "List",
     ),
   ]))
@@ -558,7 +558,7 @@ pub fn tuple2_test() {
   |> should.equal(Error([
     DecodeError(
       path: [],
-      expected: "Tuple or List of 2 elements",
+      expected: "Tuple of 2 elements",
       found: "List",
     ),
   ]))
@@ -607,7 +607,7 @@ pub fn tuple3_test() {
   |> should.equal(Error([
     DecodeError(
       path: [],
-      expected: "Tuple or List of 3 elements",
+      expected: "Tuple of 3 elements",
       found: "Tuple of 2 elements",
     ),
   ]))
@@ -627,7 +627,7 @@ pub fn tuple3_test() {
   |> should.equal(Error([
     DecodeError(
       path: [],
-      expected: "Tuple or List of 3 elements",
+      expected: "Tuple of 3 elements",
       found: "List",
     ),
   ]))
@@ -636,7 +636,7 @@ pub fn tuple3_test() {
   |> dynamic.from
   |> dynamic.tuple3(dynamic.int, dynamic.int, dynamic.int)
   |> should.equal(Error([
-    DecodeError(path: [], expected: "Tuple or List of 3 elements", found: "Int"),
+    DecodeError(path: [], expected: "Tuple of 3 elements", found: "Int"),
   ]))
 }
 
@@ -684,7 +684,7 @@ pub fn tuple4_test() {
   |> should.equal(Error([
     DecodeError(
       path: [],
-      expected: "Tuple or List of 4 elements",
+      expected: "Tuple of 4 elements",
       found: "Tuple of 2 elements",
     ),
   ]))
@@ -705,7 +705,7 @@ pub fn tuple4_test() {
   |> should.equal(Error([
     DecodeError(
       path: [],
-      expected: "Tuple or List of 4 elements",
+      expected: "Tuple of 4 elements",
       found: "List",
     ),
   ]))
@@ -714,7 +714,7 @@ pub fn tuple4_test() {
   |> dynamic.from
   |> dynamic.tuple4(dynamic.int, dynamic.int, dynamic.int, dynamic.int)
   |> should.equal(Error([
-    DecodeError(path: [], expected: "Tuple or List of 4 elements", found: "Int"),
+    DecodeError(path: [], expected: "Tuple of 4 elements", found: "Int"),
   ]))
 }
 
@@ -811,7 +811,7 @@ pub fn tuple5_test() {
   |> should.equal(Error([
     DecodeError(
       path: [],
-      expected: "Tuple or List of 5 elements",
+      expected: "Tuple of 5 elements",
       found: "Tuple of 2 elements",
     ),
   ]))
@@ -845,7 +845,7 @@ pub fn tuple5_test() {
   |> should.equal(Error([
     DecodeError(
       path: [],
-      expected: "Tuple or List of 5 elements",
+      expected: "Tuple of 5 elements",
       found: "List",
     ),
   ]))
@@ -860,7 +860,7 @@ pub fn tuple5_test() {
     dynamic.int,
   )
   |> should.equal(Error([
-    DecodeError(path: [], expected: "Tuple or List of 5 elements", found: "Int"),
+    DecodeError(path: [], expected: "Tuple of 5 elements", found: "Int"),
   ]))
 }
 
@@ -966,7 +966,7 @@ pub fn tuple6_test() {
   |> should.equal(Error([
     DecodeError(
       path: [],
-      expected: "Tuple or List of 6 elements",
+      expected: "Tuple of 6 elements",
       found: "Tuple of 2 elements",
     ),
   ]))
@@ -1003,7 +1003,7 @@ pub fn tuple6_test() {
   |> should.equal(Error([
     DecodeError(
       path: [],
-      expected: "Tuple or List of 6 elements",
+      expected: "Tuple of 6 elements",
       found: "List",
     ),
   ]))
@@ -1019,7 +1019,7 @@ pub fn tuple6_test() {
     dynamic.int,
   )
   |> should.equal(Error([
-    DecodeError(path: [], expected: "Tuple or List of 6 elements", found: "Int"),
+    DecodeError(path: [], expected: "Tuple of 6 elements", found: "Int"),
   ]))
 }