fix: generic order on ContramapCache

Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>

function/cache.go

@@ -25,13 +25,13 @@ func Memoize[K comparable, T any](f func(K) T) func(K) T {
 }
 
 // ContramapMemoize converts a unary function into a unary function that caches the value depending on the parameter
-func ContramapMemoize[A any, K comparable, T any](kf func(A) K) func(func(A) T) func(A) T {
+func ContramapMemoize[T, A any, K comparable](kf func(A) K) func(func(A) T) func(A) T {
 	return G.ContramapMemoize[func(A) T](kf)
 }
 
 // CacheCallback converts a unary function into a unary function that caches the value depending on the parameter
 func CacheCallback[
-	A any, K comparable, T any](kf func(A) K, getOrCreate func(K, func() func() T) func() T) func(func(A) T) func(A) T {
+	T, A any, K comparable](kf func(A) K, getOrCreate func(K, func() func() T) func() T) func(func(A) T) func(A) T {
 	return G.CacheCallback[func(func(A) T) func(A) T](kf, getOrCreate)
 }
 

tuple/gen.go

@@ -4,7 +4,6 @@
 
 package tuple
 
-
 import (
 	M "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/ord"
@@ -128,7 +127,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()))
 }
@@ -136,7 +135,9 @@ 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)
@@ -222,7 +223,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()))
 }
@@ -230,8 +231,12 @@ 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 := o1.Compare(l.F1, r.F1); c != 0 {
-    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+			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)
@@ -320,7 +325,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()))
 }
@@ -328,9 +333,15 @@ 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 := o1.Compare(l.F1, r.F1); c != 0 {
-    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+			return c
-    if c:= o3.Compare(l.F3, r.F3); 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)
@@ -422,7 +433,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()))
 }
@@ -430,10 +441,18 @@ 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 := o1.Compare(l.F1, r.F1); c != 0 {
-    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+			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 := 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)
@@ -528,7 +547,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()))
 }
@@ -536,11 +555,21 @@ 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 := o1.Compare(l.F1, r.F1); c != 0 {
-    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+			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 := o2.Compare(l.F2, r.F2); c != 0 {
-    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
+			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)
@@ -638,7 +667,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()))
 }
@@ -646,12 +675,24 @@ 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 := o1.Compare(l.F1, r.F1); c != 0 {
-    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+			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 := o2.Compare(l.F2, r.F2); c != 0 {
-    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
+			return c
-    if c:= o6.Compare(l.F6, r.F6); 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)
@@ -752,7 +793,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()))
 }
@@ -760,13 +801,27 @@ 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 := o1.Compare(l.F1, r.F1); c != 0 {
-    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+			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 := o2.Compare(l.F2, r.F2); c != 0 {
-    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
+			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 := 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)
@@ -870,7 +925,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()))
 }
@@ -878,14 +933,30 @@ 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 := o1.Compare(l.F1, r.F1); c != 0 {
-    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+			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 := o2.Compare(l.F2, r.F2); c != 0 {
-    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
+			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 := o3.Compare(l.F3, r.F3); c != 0 {
-    if c:= o8.Compare(l.F8, r.F8); c != 0 {return c}
+			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)
@@ -992,7 +1063,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()))
 }
@@ -1000,15 +1071,33 @@ 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 := o1.Compare(l.F1, r.F1); c != 0 {
-    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+			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 := o2.Compare(l.F2, r.F2); c != 0 {
-    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
+			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 := o3.Compare(l.F3, r.F3); c != 0 {
-    if c:= o8.Compare(l.F8, r.F8); c != 0 {return c}
+			return c
-    if c:= o9.Compare(l.F9, r.F9); 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)
@@ -1118,7 +1207,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()))
 }
@@ -1126,16 +1215,36 @@ 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 := o1.Compare(l.F1, r.F1); c != 0 {
-    if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
+			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 := o2.Compare(l.F2, r.F2); c != 0 {
-    if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
+			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 := o3.Compare(l.F3, r.F3); c != 0 {
-    if c:= o8.Compare(l.F8, r.F8); c != 0 {return c}
+			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 := 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)