fix: optimize use of tuples

Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>
2025-08-10 22:31:32 +02:00 · 2024-02-08 08:41:51 +01:00
parent 79652d8474
commit 9f6b6d4968
3 changed files with 658 additions and 1084 deletions
--- a/cli/tuple.go
+++ b/cli/tuple.go
@@ -405,8 +405,6 @@ func generateTupleHelpers(filename string, count int) error {

 	fmt.Fprintf(f, `
 import (
-	"fmt"
-	"encoding/json"
 	M "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/ord"	
 )
@@ -457,7 +455,7 @@ func generateTupleMarshal(f *os.File, i int) {
 	fmt.Fprintf(f, "func (t ")
 	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, ") MarshalJSON() ([]byte, error) {\n")
-	fmt.Fprintf(f, "  return json.Marshal([]any{")
+	fmt.Fprintf(f, "  return tupleMarshalJSON(")
 	// function prototypes
 	for j := 1; j <= i; j++ {
 		if j > 1 {
@@ -465,7 +463,7 @@ func generateTupleMarshal(f *os.File, i int) {
 		}
 		fmt.Fprintf(f, "t.F%d", j)
 	}
-	fmt.Fprintf(f, "})\n")
+	fmt.Fprintf(f, ")\n")
 	fmt.Fprintf(f, "}\n")
 }

@@ -475,19 +473,12 @@ func generateTupleUnmarshal(f *os.File, i int) {
 	fmt.Fprintf(f, "func (t *")
 	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, ") UnmarshalJSON(data []byte) error {\n")
-	fmt.Fprintf(f, "  var tmp []json.RawMessage\n")
-	fmt.Fprintf(f, "  if err := json.Unmarshal(data, &tmp); err != nil {return err}\n")
-	fmt.Fprintf(f, "  l := len(tmp)\n")
-	// unmarshal fields
+	fmt.Fprintf(f, "  return tupleUnmarshalJSON(data")
+	// function prototypes
 	for j := 1; j <= i; j++ {
-		fmt.Fprintf(f, "  if l > %d {\n", j-1)
-		fmt.Fprintf(f, "  if err := json.Unmarshal(tmp[%d], &t.F%d); err != nil {return err}\n", j-1, j)
+		fmt.Fprintf(f, ", &t.F%d", j)
 	}
-	fmt.Fprintf(f, "  ")
-	for j := 1; j <= i; j++ {
-		fmt.Fprintf(f, "}")
-	}
-	fmt.Fprintf(f, "\n  return nil\n")
+	fmt.Fprintf(f, ")\n")
 	fmt.Fprintf(f, "}\n")
 }

@@ -570,30 +561,13 @@ func generateTupleString(f *os.File, i int) {
 	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, ") String() string {\n")
 	// convert to string
-	fmt.Fprintf(f, "  return fmt.Sprintf(\"Tuple%d[", i)
-	for j := 1; j <= i; j++ {
-		if j > 1 {
-			fmt.Fprintf(f, ", ")
-		}
-		fmt.Fprintf(f, "%s", "%T")
-	}
-	fmt.Fprintf(f, "](")
-	for j := 1; j <= i; j++ {
-		if j > 1 {
-			fmt.Fprintf(f, ", ")
-		}
-		fmt.Fprintf(f, "%s", "%v")
-	}
-	fmt.Fprintf(f, ")\", ")
+	fmt.Fprint(f, "  return tupleString(")
 	for j := 1; j <= i; j++ {
 		if j > 1 {
 			fmt.Fprintf(f, ", ")
 		}
 		fmt.Fprintf(f, "t.F%d", j)
 	}
-	for j := 1; j <= i; j++ {
-		fmt.Fprintf(f, ", t.F%d", j)
-	}
 	fmt.Fprintf(f, ")\n")
 	fmt.Fprintf(f, "}\n")
 }
--- a/tuple/gen.go
+++ b/tuple/gen.go
@@ -1,12 +1,11 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:31:19.0449107 +0200 CEST m=+0.023307601
+// 2024-02-08 08:36:32.8883679 +0100 CET m=+0.008054801

 package tuple

+
 import (
-	"encoding/json"
-	"fmt"
 	M "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/ord"	
 )
@@ -129,7 +128,7 @@ func Untupled1[F ~func(Tuple1[T1]) R, T1, R any](f F) func(T1) R {

 // Monoid1 creates a [Monoid] for a [Tuple1] based on 1 monoids for the contained types
 func Monoid1[T1 any](m1 M.Monoid[T1]) M.Monoid[Tuple1[T1]] {
-	return M.MakeMonoid(func(l, r Tuple1[T1]) Tuple1[T1] {
+  return M.MakeMonoid(func(l, r Tuple1[T1]) Tuple1[T1]{
    return MakeTuple1(m1.Concat(l.F1, r.F1))
  }, MakeTuple1(m1.Empty()))
 }
@@ -137,9 +136,7 @@ func Monoid1[T1 any](m1 M.Monoid[T1]) M.Monoid[Tuple1[T1]] {
 // Ord1 creates n [Ord] for a [Tuple1] based on 1 [Ord]s for the contained types
 func Ord1[T1 any](o1 O.Ord[T1]) O.Ord[Tuple1[T1]] {
  return O.MakeOrd(func(l, r Tuple1[T1]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
    return 0
  }, func(l, r Tuple1[T1]) bool {
    return o1.Equals(l.F1, r.F1)
@@ -162,27 +159,17 @@ func Replicate1[T any](t T) Tuple1[T] {

 // String prints some debug info for the [Tuple1]
 func (t Tuple1[T1]) String() string {
-	return fmt.Sprintf("Tuple1[%T](%v)", t.F1, t.F1)
+  return tupleString(t.F1)
 }

 // MarshalJSON marshals the [Tuple1] into a JSON array
 func (t Tuple1[T1]) MarshalJSON() ([]byte, error) {
-	return json.Marshal([]any{t.F1})
+  return tupleMarshalJSON(t.F1)
 }

 // UnmarshalJSON unmarshals a JSON array into a [Tuple1]
 func (t *Tuple1[T1]) UnmarshalJSON(data []byte) error {
-	var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
-	l := len(tmp)
-	if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
-	}
-	return nil
+  return tupleUnmarshalJSON(data, &t.F1)
 }

 // ToArray converts the [Tuple1] into an array of type [R] using 1 transformation functions from [T] to [R]
@@ -235,7 +222,7 @@ func Untupled2[F ~func(Tuple2[T1, T2]) R, T1, T2, R any](f F) func(T1, T2) R {

 // Monoid2 creates a [Monoid] for a [Tuple2] based on 2 monoids for the contained types
 func Monoid2[T1, T2 any](m1 M.Monoid[T1], m2 M.Monoid[T2]) M.Monoid[Tuple2[T1, T2]] {
-	return M.MakeMonoid(func(l, r Tuple2[T1, T2]) Tuple2[T1, T2] {
+  return M.MakeMonoid(func(l, r Tuple2[T1, T2]) Tuple2[T1, T2]{
    return MakeTuple2(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2))
  }, MakeTuple2(m1.Empty(), m2.Empty()))
 }
@@ -243,12 +230,8 @@ func Monoid2[T1, T2 any](m1 M.Monoid[T1], m2 M.Monoid[T2]) M.Monoid[Tuple2[T1, T
 // Ord2 creates n [Ord] for a [Tuple2] based on 2 [Ord]s for the contained types
 func Ord2[T1, T2 any](o1 O.Ord[T1], o2 O.Ord[T2]) O.Ord[Tuple2[T1, T2]] {
  return O.MakeOrd(func(l, r Tuple2[T1, T2]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
    return 0
  }, func(l, r Tuple2[T1, T2]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2)
@@ -272,32 +255,17 @@ func Replicate2[T any](t T) Tuple2[T, T] {

 // String prints some debug info for the [Tuple2]
 func (t Tuple2[T1, T2]) String() string {
-	return fmt.Sprintf("Tuple2[%T, %T](%v, %v)", t.F1, t.F2, t.F1, t.F2)
+  return tupleString(t.F1, t.F2)
 }

 // MarshalJSON marshals the [Tuple2] into a JSON array
 func (t Tuple2[T1, T2]) MarshalJSON() ([]byte, error) {
-	return json.Marshal([]any{t.F1, t.F2})
+  return tupleMarshalJSON(t.F1, t.F2)
 }

 // UnmarshalJSON unmarshals a JSON array into a [Tuple2]
 func (t *Tuple2[T1, T2]) UnmarshalJSON(data []byte) error {
-	var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
-	l := len(tmp)
-	if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
-		if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
+  return tupleUnmarshalJSON(data, &t.F1, &t.F2)
 }

 // ToArray converts the [Tuple2] into an array of type [R] using 2 transformation functions from [T] to [R]
@@ -352,7 +320,7 @@ func Untupled3[F ~func(Tuple3[T1, T2, T3]) R, T1, T2, T3, R any](f F) func(T1, T

 // Monoid3 creates a [Monoid] for a [Tuple3] based on 3 monoids for the contained types
 func Monoid3[T1, T2, T3 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3]) M.Monoid[Tuple3[T1, T2, T3]] {
-	return M.MakeMonoid(func(l, r Tuple3[T1, T2, T3]) Tuple3[T1, T2, T3] {
+  return M.MakeMonoid(func(l, r Tuple3[T1, T2, T3]) Tuple3[T1, T2, T3]{
    return MakeTuple3(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3))
  }, MakeTuple3(m1.Empty(), m2.Empty(), m3.Empty()))
 }
@@ -360,15 +328,9 @@ func Monoid3[T1, T2, T3 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3])
 // Ord3 creates n [Ord] for a [Tuple3] based on 3 [Ord]s for the contained types
 func Ord3[T1, T2, T3 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3]) O.Ord[Tuple3[T1, T2, T3]] {
  return O.MakeOrd(func(l, r Tuple3[T1, T2, T3]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
    return 0
  }, func(l, r Tuple3[T1, T2, T3]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3)
@@ -393,37 +355,17 @@ func Replicate3[T any](t T) Tuple3[T, T, T] {

 // String prints some debug info for the [Tuple3]
 func (t Tuple3[T1, T2, T3]) String() string {
-	return fmt.Sprintf("Tuple3[%T, %T, %T](%v, %v, %v)", t.F1, t.F2, t.F3, t.F1, t.F2, t.F3)
+  return tupleString(t.F1, t.F2, t.F3)
 }

 // MarshalJSON marshals the [Tuple3] into a JSON array
 func (t Tuple3[T1, T2, T3]) MarshalJSON() ([]byte, error) {
-	return json.Marshal([]any{t.F1, t.F2, t.F3})
+  return tupleMarshalJSON(t.F1, t.F2, t.F3)
 }

 // UnmarshalJSON unmarshals a JSON array into a [Tuple3]
 func (t *Tuple3[T1, T2, T3]) UnmarshalJSON(data []byte) error {
-	var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
-	l := len(tmp)
-	if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
-		if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
-			if l > 2 {
-				if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
-					return err
-				}
-			}
-		}
-	}
-	return nil
+  return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3)
 }

 // ToArray converts the [Tuple3] into an array of type [R] using 3 transformation functions from [T] to [R]
@@ -480,7 +422,7 @@ func Untupled4[F ~func(Tuple4[T1, T2, T3, T4]) R, T1, T2, T3, T4, R any](f F) fu

 // Monoid4 creates a [Monoid] for a [Tuple4] based on 4 monoids for the contained types
 func Monoid4[T1, T2, T3, T4 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4]) M.Monoid[Tuple4[T1, T2, T3, T4]] {
-	return M.MakeMonoid(func(l, r Tuple4[T1, T2, T3, T4]) Tuple4[T1, T2, T3, T4] {
+  return M.MakeMonoid(func(l, r Tuple4[T1, T2, T3, T4]) Tuple4[T1, T2, T3, T4]{
    return MakeTuple4(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4))
  }, MakeTuple4(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty()))
 }
@@ -488,18 +430,10 @@ func Monoid4[T1, T2, T3, T4 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T
 // Ord4 creates n [Ord] for a [Tuple4] based on 4 [Ord]s for the contained types
 func Ord4[T1, T2, T3, T4 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4]) O.Ord[Tuple4[T1, T2, T3, T4]] {
  return O.MakeOrd(func(l, r Tuple4[T1, T2, T3, T4]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
    return 0
  }, func(l, r Tuple4[T1, T2, T3, T4]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4)
@@ -525,42 +459,17 @@ func Replicate4[T any](t T) Tuple4[T, T, T, T] {

 // String prints some debug info for the [Tuple4]
 func (t Tuple4[T1, T2, T3, T4]) String() string {
-	return fmt.Sprintf("Tuple4[%T, %T, %T, %T](%v, %v, %v, %v)", t.F1, t.F2, t.F3, t.F4, t.F1, t.F2, t.F3, t.F4)
+  return tupleString(t.F1, t.F2, t.F3, t.F4)
 }

 // MarshalJSON marshals the [Tuple4] into a JSON array
 func (t Tuple4[T1, T2, T3, T4]) MarshalJSON() ([]byte, error) {
-	return json.Marshal([]any{t.F1, t.F2, t.F3, t.F4})
+  return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4)
 }

 // UnmarshalJSON unmarshals a JSON array into a [Tuple4]
 func (t *Tuple4[T1, T2, T3, T4]) UnmarshalJSON(data []byte) error {
-	var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
-	l := len(tmp)
-	if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
-		if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
-			if l > 2 {
-				if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
-					return err
-				}
-				if l > 3 {
-					if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
-						return err
-					}
-				}
-			}
-		}
-	}
-	return nil
+  return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4)
 }

 // ToArray converts the [Tuple4] into an array of type [R] using 4 transformation functions from [T] to [R]
@@ -619,7 +528,7 @@ func Untupled5[F ~func(Tuple5[T1, T2, T3, T4, T5]) R, T1, T2, T3, T4, T5, R any]

 // Monoid5 creates a [Monoid] for a [Tuple5] based on 5 monoids for the contained types
 func Monoid5[T1, T2, T3, T4, T5 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5]) M.Monoid[Tuple5[T1, T2, T3, T4, T5]] {
-	return M.MakeMonoid(func(l, r Tuple5[T1, T2, T3, T4, T5]) Tuple5[T1, T2, T3, T4, T5] {
+  return M.MakeMonoid(func(l, r Tuple5[T1, T2, T3, T4, T5]) Tuple5[T1, T2, T3, T4, T5]{
    return MakeTuple5(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5))
  }, MakeTuple5(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty()))
 }
@@ -627,21 +536,11 @@ func Monoid5[T1, T2, T3, T4, T5 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Mono
 // Ord5 creates n [Ord] for a [Tuple5] based on 5 [Ord]s for the contained types
 func Ord5[T1, T2, T3, T4, T5 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5]) O.Ord[Tuple5[T1, T2, T3, T4, T5]] {
  return O.MakeOrd(func(l, r Tuple5[T1, T2, T3, T4, T5]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
    return 0
  }, func(l, r Tuple5[T1, T2, T3, T4, T5]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5)
@@ -668,47 +567,17 @@ func Replicate5[T any](t T) Tuple5[T, T, T, T, T] {

 // String prints some debug info for the [Tuple5]
 func (t Tuple5[T1, T2, T3, T4, T5]) String() string {
-	return fmt.Sprintf("Tuple5[%T, %T, %T, %T, %T](%v, %v, %v, %v, %v)", t.F1, t.F2, t.F3, t.F4, t.F5, t.F1, t.F2, t.F3, t.F4, t.F5)
+  return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5)
 }

 // MarshalJSON marshals the [Tuple5] into a JSON array
 func (t Tuple5[T1, T2, T3, T4, T5]) MarshalJSON() ([]byte, error) {
-	return json.Marshal([]any{t.F1, t.F2, t.F3, t.F4, t.F5})
+  return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5)
 }

 // UnmarshalJSON unmarshals a JSON array into a [Tuple5]
 func (t *Tuple5[T1, T2, T3, T4, T5]) UnmarshalJSON(data []byte) error {
-	var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
-	l := len(tmp)
-	if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
-		if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
-			if l > 2 {
-				if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
-					return err
-				}
-				if l > 3 {
-					if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
-						return err
-					}
-					if l > 4 {
-						if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
-							return err
-						}
-					}
-				}
-			}
-		}
-	}
-	return nil
+  return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5)
 }

 // ToArray converts the [Tuple5] into an array of type [R] using 5 transformation functions from [T] to [R]
@@ -769,7 +638,7 @@ func Untupled6[F ~func(Tuple6[T1, T2, T3, T4, T5, T6]) R, T1, T2, T3, T4, T5, T6

 // Monoid6 creates a [Monoid] for a [Tuple6] based on 6 monoids for the contained types
 func Monoid6[T1, T2, T3, T4, T5, T6 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6]) M.Monoid[Tuple6[T1, T2, T3, T4, T5, T6]] {
-	return M.MakeMonoid(func(l, r Tuple6[T1, T2, T3, T4, T5, T6]) Tuple6[T1, T2, T3, T4, T5, T6] {
+  return M.MakeMonoid(func(l, r Tuple6[T1, T2, T3, T4, T5, T6]) Tuple6[T1, T2, T3, T4, T5, T6]{
    return MakeTuple6(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6))
  }, MakeTuple6(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty()))
 }
@@ -777,24 +646,12 @@ func Monoid6[T1, T2, T3, T4, T5, T6 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.
 // Ord6 creates n [Ord] for a [Tuple6] based on 6 [Ord]s for the contained types
 func Ord6[T1, T2, T3, T4, T5, T6 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6]) O.Ord[Tuple6[T1, T2, T3, T4, T5, T6]] {
  return O.MakeOrd(func(l, r Tuple6[T1, T2, T3, T4, T5, T6]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
-		if c := o6.Compare(l.F6, r.F6); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
+    if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
    return 0
  }, func(l, r Tuple6[T1, T2, T3, T4, T5, T6]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6)
@@ -822,52 +679,17 @@ func Replicate6[T any](t T) Tuple6[T, T, T, T, T, T] {

 // String prints some debug info for the [Tuple6]
 func (t Tuple6[T1, T2, T3, T4, T5, T6]) String() string {
-	return fmt.Sprintf("Tuple6[%T, %T, %T, %T, %T, %T](%v, %v, %v, %v, %v, %v)", t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F1, t.F2, t.F3, t.F4, t.F5, t.F6)
+  return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6)
 }

 // MarshalJSON marshals the [Tuple6] into a JSON array
 func (t Tuple6[T1, T2, T3, T4, T5, T6]) MarshalJSON() ([]byte, error) {
-	return json.Marshal([]any{t.F1, t.F2, t.F3, t.F4, t.F5, t.F6})
+  return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6)
 }

 // UnmarshalJSON unmarshals a JSON array into a [Tuple6]
 func (t *Tuple6[T1, T2, T3, T4, T5, T6]) UnmarshalJSON(data []byte) error {
-	var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
-	l := len(tmp)
-	if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
-		if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
-			if l > 2 {
-				if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
-					return err
-				}
-				if l > 3 {
-					if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
-						return err
-					}
-					if l > 4 {
-						if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
-							return err
-						}
-						if l > 5 {
-							if err := json.Unmarshal(tmp[5], &t.F6); err != nil {
-								return err
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-	return nil
+  return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6)
 }

 // ToArray converts the [Tuple6] into an array of type [R] using 6 transformation functions from [T] to [R]
@@ -930,7 +752,7 @@ func Untupled7[F ~func(Tuple7[T1, T2, T3, T4, T5, T6, T7]) R, T1, T2, T3, T4, T5

 // Monoid7 creates a [Monoid] for a [Tuple7] based on 7 monoids for the contained types
 func Monoid7[T1, T2, T3, T4, T5, T6, T7 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7]) M.Monoid[Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
-	return M.MakeMonoid(func(l, r Tuple7[T1, T2, T3, T4, T5, T6, T7]) Tuple7[T1, T2, T3, T4, T5, T6, T7] {
+  return M.MakeMonoid(func(l, r Tuple7[T1, T2, T3, T4, T5, T6, T7]) Tuple7[T1, T2, T3, T4, T5, T6, T7]{
    return MakeTuple7(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7))
  }, MakeTuple7(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty()))
 }
@@ -938,27 +760,13 @@ func Monoid7[T1, T2, T3, T4, T5, T6, T7 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m
 // Ord7 creates n [Ord] for a [Tuple7] based on 7 [Ord]s for the contained types
 func Ord7[T1, T2, T3, T4, T5, T6, T7 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7]) O.Ord[Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
  return O.MakeOrd(func(l, r Tuple7[T1, T2, T3, T4, T5, T6, T7]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
-		if c := o6.Compare(l.F6, r.F6); c != 0 {
-			return c
-		}
-		if c := o7.Compare(l.F7, r.F7); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
+    if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
+    if c:= o7.Compare(l.F7, r.F7); c != 0 {return c}
    return 0
  }, func(l, r Tuple7[T1, T2, T3, T4, T5, T6, T7]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7)
@@ -987,57 +795,17 @@ func Replicate7[T any](t T) Tuple7[T, T, T, T, T, T, T] {

 // String prints some debug info for the [Tuple7]
 func (t Tuple7[T1, T2, T3, T4, T5, T6, T7]) String() string {
-	return fmt.Sprintf("Tuple7[%T, %T, %T, %T, %T, %T, %T](%v, %v, %v, %v, %v, %v, %v)", t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7)
+  return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7)
 }

 // MarshalJSON marshals the [Tuple7] into a JSON array
 func (t Tuple7[T1, T2, T3, T4, T5, T6, T7]) MarshalJSON() ([]byte, error) {
-	return json.Marshal([]any{t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7})
+  return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7)
 }

 // UnmarshalJSON unmarshals a JSON array into a [Tuple7]
 func (t *Tuple7[T1, T2, T3, T4, T5, T6, T7]) UnmarshalJSON(data []byte) error {
-	var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
-	l := len(tmp)
-	if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
-		if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
-			if l > 2 {
-				if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
-					return err
-				}
-				if l > 3 {
-					if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
-						return err
-					}
-					if l > 4 {
-						if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
-							return err
-						}
-						if l > 5 {
-							if err := json.Unmarshal(tmp[5], &t.F6); err != nil {
-								return err
-							}
-							if l > 6 {
-								if err := json.Unmarshal(tmp[6], &t.F7); err != nil {
-									return err
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-	return nil
+  return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7)
 }

 // ToArray converts the [Tuple7] into an array of type [R] using 7 transformation functions from [T] to [R]
@@ -1102,7 +870,7 @@ func Untupled8[F ~func(Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) R, T1, T2, T3, T4

 // Monoid8 creates a [Monoid] for a [Tuple8] based on 8 monoids for the contained types
 func Monoid8[T1, T2, T3, T4, T5, T6, T7, T8 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8]) M.Monoid[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
-	return M.MakeMonoid(func(l, r Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
+  return M.MakeMonoid(func(l, r Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]{
    return MakeTuple8(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8))
  }, MakeTuple8(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty()))
 }
@@ -1110,30 +878,14 @@ func Monoid8[T1, T2, T3, T4, T5, T6, T7, T8 any](m1 M.Monoid[T1], m2 M.Monoid[T2
 // Ord8 creates n [Ord] for a [Tuple8] based on 8 [Ord]s for the contained types
 func Ord8[T1, T2, T3, T4, T5, T6, T7, T8 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8]) O.Ord[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
  return O.MakeOrd(func(l, r Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
-		if c := o6.Compare(l.F6, r.F6); c != 0 {
-			return c
-		}
-		if c := o7.Compare(l.F7, r.F7); c != 0 {
-			return c
-		}
-		if c := o8.Compare(l.F8, r.F8); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
+    if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
+    if c:= o7.Compare(l.F7, r.F7); c != 0 {return c}
+    if c:= o8.Compare(l.F8, r.F8); c != 0 {return c}
    return 0
  }, func(l, r Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8)
@@ -1163,62 +915,17 @@ func Replicate8[T any](t T) Tuple8[T, T, T, T, T, T, T, T] {

 // String prints some debug info for the [Tuple8]
 func (t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) String() string {
-	return fmt.Sprintf("Tuple8[%T, %T, %T, %T, %T, %T, %T, %T](%v, %v, %v, %v, %v, %v, %v, %v)", t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8)
+  return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8)
 }

 // MarshalJSON marshals the [Tuple8] into a JSON array
 func (t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) MarshalJSON() ([]byte, error) {
-	return json.Marshal([]any{t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8})
+  return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8)
 }

 // UnmarshalJSON unmarshals a JSON array into a [Tuple8]
 func (t *Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) UnmarshalJSON(data []byte) error {
-	var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
-	l := len(tmp)
-	if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
-		if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
-			if l > 2 {
-				if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
-					return err
-				}
-				if l > 3 {
-					if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
-						return err
-					}
-					if l > 4 {
-						if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
-							return err
-						}
-						if l > 5 {
-							if err := json.Unmarshal(tmp[5], &t.F6); err != nil {
-								return err
-							}
-							if l > 6 {
-								if err := json.Unmarshal(tmp[6], &t.F7); err != nil {
-									return err
-								}
-								if l > 7 {
-									if err := json.Unmarshal(tmp[7], &t.F8); err != nil {
-										return err
-									}
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-	return nil
+  return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8)
 }

 // ToArray converts the [Tuple8] into an array of type [R] using 8 transformation functions from [T] to [R]
@@ -1285,7 +992,7 @@ func Untupled9[F ~func(Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) R, T1, T2, T3

 // Monoid9 creates a [Monoid] for a [Tuple9] based on 9 monoids for the contained types
 func Monoid9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8], m9 M.Monoid[T9]) M.Monoid[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
-	return M.MakeMonoid(func(l, r Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
+  return M.MakeMonoid(func(l, r Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]{
    return MakeTuple9(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8), m9.Concat(l.F9, r.F9))
  }, MakeTuple9(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty(), m9.Empty()))
 }
@@ -1293,33 +1000,15 @@ func Monoid9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](m1 M.Monoid[T1], m2 M.Monoi
 // Ord9 creates n [Ord] for a [Tuple9] based on 9 [Ord]s for the contained types
 func Ord9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8], o9 O.Ord[T9]) O.Ord[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
  return O.MakeOrd(func(l, r Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
-		if c := o6.Compare(l.F6, r.F6); c != 0 {
-			return c
-		}
-		if c := o7.Compare(l.F7, r.F7); c != 0 {
-			return c
-		}
-		if c := o8.Compare(l.F8, r.F8); c != 0 {
-			return c
-		}
-		if c := o9.Compare(l.F9, r.F9); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
+    if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
+    if c:= o7.Compare(l.F7, r.F7); c != 0 {return c}
+    if c:= o8.Compare(l.F8, r.F8); c != 0 {return c}
+    if c:= o9.Compare(l.F9, r.F9); c != 0 {return c}
    return 0
  }, func(l, r Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8) && o9.Equals(l.F9, r.F9)
@@ -1350,67 +1039,17 @@ func Replicate9[T any](t T) Tuple9[T, T, T, T, T, T, T, T, T] {

 // String prints some debug info for the [Tuple9]
 func (t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) String() string {
-	return fmt.Sprintf("Tuple9[%T, %T, %T, %T, %T, %T, %T, %T, %T](%v, %v, %v, %v, %v, %v, %v, %v, %v)", t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9)
+  return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9)
 }

 // MarshalJSON marshals the [Tuple9] into a JSON array
 func (t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) MarshalJSON() ([]byte, error) {
-	return json.Marshal([]any{t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9})
+  return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9)
 }

 // UnmarshalJSON unmarshals a JSON array into a [Tuple9]
 func (t *Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) UnmarshalJSON(data []byte) error {
-	var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
-	l := len(tmp)
-	if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
-		if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
-			if l > 2 {
-				if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
-					return err
-				}
-				if l > 3 {
-					if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
-						return err
-					}
-					if l > 4 {
-						if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
-							return err
-						}
-						if l > 5 {
-							if err := json.Unmarshal(tmp[5], &t.F6); err != nil {
-								return err
-							}
-							if l > 6 {
-								if err := json.Unmarshal(tmp[6], &t.F7); err != nil {
-									return err
-								}
-								if l > 7 {
-									if err := json.Unmarshal(tmp[7], &t.F8); err != nil {
-										return err
-									}
-									if l > 8 {
-										if err := json.Unmarshal(tmp[8], &t.F9); err != nil {
-											return err
-										}
-									}
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-	return nil
+  return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8, &t.F9)
 }

 // ToArray converts the [Tuple9] into an array of type [R] using 9 transformation functions from [T] to [R]
@@ -1479,7 +1118,7 @@ func Untupled10[F ~func(Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) R, T1,

 // Monoid10 creates a [Monoid] for a [Tuple10] based on 10 monoids for the contained types
 func Monoid10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8], m9 M.Monoid[T9], m10 M.Monoid[T10]) M.Monoid[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
-	return M.MakeMonoid(func(l, r Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
+  return M.MakeMonoid(func(l, r Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]{
    return MakeTuple10(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8), m9.Concat(l.F9, r.F9), m10.Concat(l.F10, r.F10))
  }, MakeTuple10(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty(), m9.Empty(), m10.Empty()))
 }
@@ -1487,36 +1126,16 @@ func Monoid10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](m1 M.Monoid[T1], m2 M
 // Ord10 creates n [Ord] for a [Tuple10] based on 10 [Ord]s for the contained types
 func Ord10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8], o9 O.Ord[T9], o10 O.Ord[T10]) O.Ord[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
  return O.MakeOrd(func(l, r Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) int {
-		if c := o1.Compare(l.F1, r.F1); c != 0 {
-			return c
-		}
-		if c := o2.Compare(l.F2, r.F2); c != 0 {
-			return c
-		}
-		if c := o3.Compare(l.F3, r.F3); c != 0 {
-			return c
-		}
-		if c := o4.Compare(l.F4, r.F4); c != 0 {
-			return c
-		}
-		if c := o5.Compare(l.F5, r.F5); c != 0 {
-			return c
-		}
-		if c := o6.Compare(l.F6, r.F6); c != 0 {
-			return c
-		}
-		if c := o7.Compare(l.F7, r.F7); c != 0 {
-			return c
-		}
-		if c := o8.Compare(l.F8, r.F8); c != 0 {
-			return c
-		}
-		if c := o9.Compare(l.F9, r.F9); c != 0 {
-			return c
-		}
-		if c := o10.Compare(l.F10, r.F10); c != 0 {
-			return c
-		}
+    if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
+    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+    if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
+    if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
+    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
+    if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
+    if c:= o7.Compare(l.F7, r.F7); c != 0 {return c}
+    if c:= o8.Compare(l.F8, r.F8); c != 0 {return c}
+    if c:= o9.Compare(l.F9, r.F9); c != 0 {return c}
+    if c:= o10.Compare(l.F10, r.F10); c != 0 {return c}
    return 0
  }, func(l, r Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) bool {
    return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8) && o9.Equals(l.F9, r.F9) && o10.Equals(l.F10, r.F10)
@@ -1548,72 +1167,17 @@ func Replicate10[T any](t T) Tuple10[T, T, T, T, T, T, T, T, T, T] {

 // String prints some debug info for the [Tuple10]
 func (t Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) String() string {
-	return fmt.Sprintf("Tuple10[%T, %T, %T, %T, %T, %T, %T, %T, %T, %T](%v, %v, %v, %v, %v, %v, %v, %v, %v, %v)", t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10)
+  return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10)
 }

 // MarshalJSON marshals the [Tuple10] into a JSON array
 func (t Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) MarshalJSON() ([]byte, error) {
-	return json.Marshal([]any{t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10})
+  return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10)
 }

 // UnmarshalJSON unmarshals a JSON array into a [Tuple10]
 func (t *Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) UnmarshalJSON(data []byte) error {
-	var tmp []json.RawMessage
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		return err
-	}
-	l := len(tmp)
-	if l > 0 {
-		if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
-			return err
-		}
-		if l > 1 {
-			if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
-				return err
-			}
-			if l > 2 {
-				if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
-					return err
-				}
-				if l > 3 {
-					if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
-						return err
-					}
-					if l > 4 {
-						if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
-							return err
-						}
-						if l > 5 {
-							if err := json.Unmarshal(tmp[5], &t.F6); err != nil {
-								return err
-							}
-							if l > 6 {
-								if err := json.Unmarshal(tmp[6], &t.F7); err != nil {
-									return err
-								}
-								if l > 7 {
-									if err := json.Unmarshal(tmp[7], &t.F8); err != nil {
-										return err
-									}
-									if l > 8 {
-										if err := json.Unmarshal(tmp[8], &t.F9); err != nil {
-											return err
-										}
-										if l > 9 {
-											if err := json.Unmarshal(tmp[9], &t.F10); err != nil {
-												return err
-											}
-										}
-									}
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-	return nil
+  return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8, &t.F9, &t.F10)
 }

 // ToArray converts the [Tuple10] into an array of type [R] using 10 transformation functions from [T] to [R]
--- a/tuple/tuple.go
+++ b/tuple/tuple.go
@@ -17,6 +17,14 @@
 // consider to use arrays for simplicity
 package tuple

+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	N "github.com/IBM/fp-go/number"
+)
+
 func Of[T1 any](t T1) Tuple1[T1] {
 	return MakeTuple1(t)
 }
@@ -46,3 +54,31 @@ func BiMap[E, G, A, B any](mapSnd func(E) G, mapFst func(A) B) func(Tuple2[A, E]
 		return MakeTuple2(mapFst(First(t)), mapSnd(Second(t)))
 	}
 }
+
+// marshalJSON marshals the tuple into a JSON array
+func tupleMarshalJSON(src ...any) ([]byte, error) {
+	return json.Marshal(src)
+}
+
+// tupleUnmarshalJSON unmarshals a JSON array into a tuple
+func tupleUnmarshalJSON(data []byte, dst ...any) error {
+	var src []json.RawMessage
+	if err := json.Unmarshal(data, &src); err != nil {
+		return err
+	}
+	l := N.Min(len(src), len(dst))
+	// unmarshal
+	for i := 0; i < l; i++ {
+		if err := json.Unmarshal(src[i], dst[i]); err != nil {
+			return err
+		}
+	}
+	// successfully decoded the tuple
+	return nil
+}
+
+// tupleString converts a tuple to a string
+func tupleString(src ...any) string {
+	l := len(src)
+	return fmt.Sprintf("Tuple%d[%s](%s)", l, fmt.Sprintf(strings.Repeat(", %T", l)[2:], src...), fmt.Sprintf(strings.Repeat(", %v", l)[2:], src...))
+}