Merge pull request #23 from IBM/cleue-better-docs

fix: experiment with docs and examples

.github/workflows/build.yml

@@ -17,22 +17,25 @@ on:
 env:
   # Currently no way to detect automatically
   DEFAULT_BRANCH: main
-  GO_VERSION: 1.20.5 # renovate: datasource=golang-version depName=golang
+  GO_VERSION: 1.20.6 # renovate: datasource=golang-version depName=golang
   NODE_VERSION: 18
   DRY_RUN: true
 
 jobs:
   build:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go-version: [ '1.20.x', '1.21.x' ]
     steps:
       # full checkout for semantic-release
       - uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
         with:
           fetch-depth: 0
-      - name: Set up go ${{env.GO_VERSION}}
+      - name: Set up go ${{ matrix.go-version }}
         uses: actions/setup-go@v4
         with:
-          go-version: ${{env.GO_VERSION}}
+          go-version: ${{ matrix.go-version }}
       -
         name: Tests
         run: |

array/array.go

@@ -108,10 +108,16 @@ func MonadFilterMap[A, B any](fa []A, f func(a A) O.Option[B]) []B {
 	return G.MonadFilterMap[[]A, []B](fa, f)
 }
 
+// FilterChain maps an array with an iterating function that returns an [O.Option] and it keeps only the Some values discarding the Nones.
 func FilterMap[A, B any](f func(a A) O.Option[B]) func([]A) []B {
 	return G.FilterMap[[]A, []B](f)
 }
 
+// FilterChain maps an array with an iterating function that returns an [O.Option] of an array. It keeps only the Some values discarding the Nones and then flattens the result.
+func FilterChain[A, B any](f func(A) O.Option[[]B]) func([]A) []B {
+	return G.FilterChain[[]A](f)
+}
+
 func FilterMapRef[A, B any](pred func(a *A) bool, f func(a *A) B) func([]A) []B {
 	return func(fa []A) []B {
 		return filterMapRef(fa, pred, f)
@@ -237,7 +243,7 @@ func Intercalate[A any](m M.Monoid[A]) func(A) func([]A) A {
 }
 
 func Flatten[A any](mma [][]A) []A {
-	return MonadChain(mma, F.Identity[[]A])
+	return G.Flatten(mma)
 }
 
 func Slice[A any](low, high int) func(as []A) []A {
@@ -288,3 +294,13 @@ func SliceRight[A any](start int) func([]A) []A {
 func Copy[A any](b []A) []A {
 	return G.Copy(b)
 }
+
+// FoldMap maps and folds an array. Map the Array passing each value to the iterating function. Then fold the results using the provided Monoid.
+func FoldMap[A, B any](m M.Monoid[B]) func(func(A) B) func([]A) B {
+	return G.FoldMap[[]A](m)
+}
+
+// Fold folds the array using the provided Monoid.
+func Fold[A any](m M.Monoid[A]) func([]A) A {
+	return G.Fold[[]A](m)
+}

array/array_test.go

@@ -16,6 +16,7 @@
 package array
 
 import (
+	"fmt"
 	"strings"
 	"testing"
 
@@ -142,3 +143,52 @@ func TestPartition(t *testing.T) {
 	assert.Equal(t, T.MakeTuple2(Empty[int](), Empty[int]()), Partition(pred)(Empty[int]()))
 	assert.Equal(t, T.MakeTuple2(From(1), From(3)), Partition(pred)(From(1, 3)))
 }
+
+func TestFilterChain(t *testing.T) {
+	src := From(1, 2, 3)
+
+	f := func(i int) O.Option[[]string] {
+		if i%2 != 0 {
+			return O.Of(From(fmt.Sprintf("a%d", i), fmt.Sprintf("b%d", i)))
+		}
+		return O.None[[]string]()
+	}
+
+	res := FilterChain(f)(src)
+
+	assert.Equal(t, From("a1", "b1", "a3", "b3"), res)
+}
+
+func TestFilterMap(t *testing.T) {
+	src := From(1, 2, 3)
+
+	f := func(i int) O.Option[string] {
+		if i%2 != 0 {
+			return O.Of(fmt.Sprintf("a%d", i))
+		}
+		return O.None[string]()
+	}
+
+	res := FilterMap(f)(src)
+
+	assert.Equal(t, From("a1", "a3"), res)
+}
+
+func TestFoldMap(t *testing.T) {
+	src := From("a", "b", "c")
+
+	fold := FoldMap[string](S.Monoid)(strings.ToUpper)
+
+	assert.Equal(t, "ABC", fold(src))
+}
+
+func ExampleFoldMap() {
+	src := From("a", "b", "c")
+
+	fold := FoldMap[string](S.Monoid)(strings.ToUpper)
+
+	fmt.Println(fold(src))
+
+	// Output: ABC
+
+}

array/generic/array.go

@@ -18,6 +18,7 @@ package generic
 import (
 	F "github.com/IBM/fp-go/function"
 	"github.com/IBM/fp-go/internal/array"
+	M "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/option"
 	"github.com/IBM/fp-go/tuple"
 )
@@ -118,6 +119,17 @@ func MonadFilterMap[GA ~[]A, GB ~[]B, A, B any](fa GA, f func(a A) O.Option[B])
 	return filterMap[GA, GB](fa, f)
 }
 
+func FilterChain[GA ~[]A, GB ~[]B, A, B any](f func(a A) O.Option[GB]) func(GA) GB {
+	return F.Flow2(
+		FilterMap[GA, []GB](f),
+		Flatten[[]GB],
+	)
+}
+
+func Flatten[GAA ~[]GA, GA ~[]A, A any](mma GAA) GA {
+	return MonadChain(mma, F.Identity[GA])
+}
+
 func FilterMap[GA ~[]A, GB ~[]B, A, B any](f func(a A) O.Option[B]) func(GA) GB {
 	return F.Bind2nd(MonadFilterMap[GA, GB, A, B], f)
 }
@@ -198,3 +210,19 @@ func Copy[AS ~[]A, A any](b AS) AS {
 	copy(buf, b)
 	return buf
 }
+
+func FoldMap[AS ~[]A, A, B any](m M.Monoid[B]) func(func(A) B) func(AS) B {
+	return func(f func(A) B) func(AS) B {
+		return func(as AS) B {
+			return array.Reduce(as, func(cur B, a A) B {
+				return m.Concat(cur, f(a))
+			}, m.Empty())
+		}
+	}
+}
+
+func Fold[AS ~[]A, A any](m M.Monoid[A]) func(AS) A {
+	return func(as AS) A {
+		return array.Reduce(as, m.Concat, m.Empty())
+	}
+}

array/generic/sort.go

@@ -18,11 +18,17 @@ package generic
 import (
 	"sort"
 
+	F "github.com/IBM/fp-go/function"
 	O "github.com/IBM/fp-go/ord"
 )
 
 // Sort implements a stable sort on the array given the provided ordering
 func Sort[GA ~[]T, T any](ord O.Ord[T]) func(ma GA) GA {
+	return SortByKey[GA](ord, F.Identity[T])
+}
+
+// SortByKey implements a stable sort on the array given the provided ordering on an extracted key
+func SortByKey[GA ~[]T, K, T any](ord O.Ord[K], f func(T) K) func(ma GA) GA {
 
 	return func(ma GA) GA {
 		// nothing to sort
@@ -34,7 +40,7 @@ func Sort[GA ~[]T, T any](ord O.Ord[T]) func(ma GA) GA {
 		cpy := make(GA, l)
 		copy(cpy, ma)
 		sort.Slice(cpy, func(i, j int) bool {
-			return ord.Compare(cpy[i], cpy[j]) < 0
+			return ord.Compare(f(cpy[i]), f(cpy[j])) < 0
 		})
 		return cpy
 	}

array/sort.go

@@ -24,3 +24,8 @@ import (
 func Sort[T any](ord O.Ord[T]) func(ma []T) []T {
 	return G.Sort[[]T](ord)
 }
+
+// SortByKey implements a stable sort on the array given the provided ordering on an extracted key
+func SortByKey[K, T any](ord O.Ord[K], f func(T) K) func(ma []T) []T {
+	return G.SortByKey[[]T](ord, f)
+}

cli/apply.go

@@ -388,7 +388,7 @@ func generateApplyHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/bind.go

@@ -266,7 +266,7 @@ func generateBindHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n", pkg)
 

cli/either.go

@@ -150,7 +150,7 @@ func generateEitherHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/header.go

@@ -27,5 +27,5 @@ func writePackage(f *os.File, pkg string) {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 }

cli/identity.go

@@ -62,7 +62,7 @@ func generateIdentityHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/io.go

@@ -81,7 +81,7 @@ func generateIOHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/ioeither.go

@@ -217,7 +217,7 @@ func generateIOEitherHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/iooption.go

@@ -81,7 +81,7 @@ func generateIOOptionHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/option.go

@@ -148,7 +148,7 @@ func generateOptionHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/pipe.go

@@ -337,7 +337,7 @@ func generatePipeHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n", pkg)
 

cli/reader.go

@@ -12,6 +12,7 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+
 package cli
 
 import (
@@ -117,7 +118,7 @@ func generateReaderHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/readerioeither.go

@@ -169,7 +169,7 @@ func generateReaderIOEitherHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/tuple.go

@@ -355,7 +355,7 @@ func generateTupleHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

context/readerioeither/gen.go

@@ -1,23 +1,9 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 package readerioeither
 
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:20.012425 +0200 CEST m=+0.019517901
+// 2023-08-11 11:37:34.0836986 +0200 CEST m=+0.009764601
+
 
 import (
 	"context"

context/readerioeither/generic/gen.go

@@ -1,30 +1,16 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 package generic
 
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:20.012425 +0200 CEST m=+0.019517901
+// 2023-08-11 11:37:34.0838811 +0200 CEST m=+0.009947101
+
 
 import (
 	"context"
 
 	E "github.com/IBM/fp-go/either"
-	A "github.com/IBM/fp-go/internal/apply"
 	RE "github.com/IBM/fp-go/readerioeither/generic"
+	A "github.com/IBM/fp-go/internal/apply"
 	T "github.com/IBM/fp-go/tuple"
 )
 

either/gen.go

@@ -1,23 +1,10 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:23.165015 +0200 CEST m=+0.038998801
+// 2023-08-11 11:37:35.9608486 +0200 CEST m=+0.009664501
+
 package either
 
+
 import (
 	A "github.com/IBM/fp-go/internal/apply"
 	T "github.com/IBM/fp-go/tuple"

endomorphism/monoid.go

@@ -21,16 +21,12 @@ import (
 	S "github.com/IBM/fp-go/semigroup"
 )
 
-func concat[A any](first, second func(A) A) func(A) A {
-	return F.Flow2(first, second)
-}
-
 // Semigroup for the Endomorphism where the `concat` operation is the usual function composition.
 func Semigroup[A any]() S.Semigroup[func(A) A] {
-	return S.MakeSemigroup(concat[A])
+	return S.MakeSemigroup(F.Flow2[func(A) A, func(A) A])
 }
 
 // Monoid for the Endomorphism where the `concat` operation is the usual function composition.
 func Monoid[A any]() M.Monoid[func(A) A] {
-	return M.MakeMonoid(concat[A], F.Identity[A])
+	return M.MakeMonoid(F.Flow2[func(A) A, func(A) A], F.Identity[A])
 }

function/binds.go

@@ -1,23 +1,8 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:40.161663 +0200 CEST m=+0.009458101
-package function
+// 2023-08-11 11:37:50.171038 +0200 CEST m=+0.031513801
 
+package function
 // Combinations for a total of 1 arguments
 
 // Bind1of1 takes a function with 1 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
@@ -36,7 +21,6 @@ func Ignore1of1[T1 any, F ~func() R, R any](f F) func(T1) R {
       return f()
   }
 }
-
 // Combinations for a total of 2 arguments
 
 // Bind1of2 takes a function with 2 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
@@ -89,7 +73,6 @@ func Ignore12of2[T1, T2 any, F ~func() R, R any](f F) func(T1, T2) R {
       return f()
   }
 }
-
 // Combinations for a total of 3 arguments
 
 // Bind1of3 takes a function with 3 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
@@ -210,7 +193,6 @@ func Ignore123of3[T1, T2, T3 any, F ~func() R, R any](f F) func(T1, T2, T3) R {
       return f()
   }
 }
-
 // Combinations for a total of 4 arguments
 
 // Bind1of4 takes a function with 4 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.

function/gen.go

@@ -1,21 +1,7 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:27.8029852 +0200 CEST m=+0.051432001
+// 2023-08-11 11:37:38.4916948 +0200 CEST m=+0.060448601
+
 package function
 
 // Pipe0 takes an initial value t0 and successively applies 0 functions where the input of a function is the return value of the previous function
@@ -30,14 +16,12 @@ func Variadic0[V, R any](f func([]V) R) func(...V) R {
     return f(v)
   }
 }
-
 // Unvariadic0 converts a function taking 0 parameters and a final variadic argument into a function with 0 parameters but a final slice argument
 func Unvariadic0[V, R any](f func(...V) R) func([]V) R {
   return func(v []V) R {
     return f(v...)
   }
 }
-
 // Pipe1 takes an initial value t0 and successively applies 1 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe1[F1 ~func(T0) T1, T0, T1 any](t0 T0, f1 F1) T1 {
@@ -82,14 +66,12 @@ func Variadic1[T1, V, R any](f func(T1, []V) R) func(T1, ...V) R {
     return f(t1, v)
   }
 }
-
 // Unvariadic1 converts a function taking 1 parameters and a final variadic argument into a function with 1 parameters but a final slice argument
 func Unvariadic1[T1, V, R any](f func(T1, ...V) R) func(T1, []V) R {
   return func(t1 T1, v []V) R {
     return f(t1, v...)
   }
 }
-
 // Pipe2 takes an initial value t0 and successively applies 2 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe2[F1 ~func(T0) T1, F2 ~func(T1) T2, T0, T1, T2 any](t0 T0, f1 F1, f2 F2) T2 {
@@ -137,14 +119,12 @@ func Variadic2[T1, T2, V, R any](f func(T1, T2, []V) R) func(T1, T2, ...V) R {
     return f(t1, t2, v)
   }
 }
-
 // Unvariadic2 converts a function taking 2 parameters and a final variadic argument into a function with 2 parameters but a final slice argument
 func Unvariadic2[T1, T2, V, R any](f func(T1, T2, ...V) R) func(T1, T2, []V) R {
   return func(t1 T1, t2 T2, v []V) R {
     return f(t1, t2, v...)
   }
 }
-
 // Pipe3 takes an initial value t0 and successively applies 3 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe3[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, T0, T1, T2, T3 any](t0 T0, f1 F1, f2 F2, f3 F3) T3 {
@@ -195,14 +175,12 @@ func Variadic3[T1, T2, T3, V, R any](f func(T1, T2, T3, []V) R) func(T1, T2, T3,
     return f(t1, t2, t3, v)
   }
 }
-
 // Unvariadic3 converts a function taking 3 parameters and a final variadic argument into a function with 3 parameters but a final slice argument
 func Unvariadic3[T1, T2, T3, V, R any](f func(T1, T2, T3, ...V) R) func(T1, T2, T3, []V) R {
   return func(t1 T1, t2 T2, t3 T3, v []V) R {
     return f(t1, t2, t3, v...)
   }
 }
-
 // Pipe4 takes an initial value t0 and successively applies 4 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe4[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, T0, T1, T2, T3, T4 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4) T4 {
@@ -256,14 +234,12 @@ func Variadic4[T1, T2, T3, T4, V, R any](f func(T1, T2, T3, T4, []V) R) func(T1,
     return f(t1, t2, t3, t4, v)
   }
 }
-
 // Unvariadic4 converts a function taking 4 parameters and a final variadic argument into a function with 4 parameters but a final slice argument
 func Unvariadic4[T1, T2, T3, T4, V, R any](f func(T1, T2, T3, T4, ...V) R) func(T1, T2, T3, T4, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, v []V) R {
     return f(t1, t2, t3, t4, v...)
   }
 }
-
 // Pipe5 takes an initial value t0 and successively applies 5 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe5[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, T0, T1, T2, T3, T4, T5 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) T5 {
@@ -320,14 +296,12 @@ func Variadic5[T1, T2, T3, T4, T5, V, R any](f func(T1, T2, T3, T4, T5, []V) R)
     return f(t1, t2, t3, t4, t5, v)
   }
 }
-
 // Unvariadic5 converts a function taking 5 parameters and a final variadic argument into a function with 5 parameters but a final slice argument
 func Unvariadic5[T1, T2, T3, T4, T5, V, R any](f func(T1, T2, T3, T4, T5, ...V) R) func(T1, T2, T3, T4, T5, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, v []V) R {
     return f(t1, t2, t3, t4, t5, v...)
   }
 }
-
 // Pipe6 takes an initial value t0 and successively applies 6 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe6[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, T0, T1, T2, T3, T4, T5, T6 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) T6 {
@@ -387,14 +361,12 @@ func Variadic6[T1, T2, T3, T4, T5, T6, V, R any](f func(T1, T2, T3, T4, T5, T6,
     return f(t1, t2, t3, t4, t5, t6, v)
   }
 }
-
 // Unvariadic6 converts a function taking 6 parameters and a final variadic argument into a function with 6 parameters but a final slice argument
 func Unvariadic6[T1, T2, T3, T4, T5, T6, V, R any](f func(T1, T2, T3, T4, T5, T6, ...V) R) func(T1, T2, T3, T4, T5, T6, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, v...)
   }
 }
-
 // Pipe7 takes an initial value t0 and successively applies 7 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe7[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, T0, T1, T2, T3, T4, T5, T6, T7 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) T7 {
@@ -457,14 +429,12 @@ func Variadic7[T1, T2, T3, T4, T5, T6, T7, V, R any](f func(T1, T2, T3, T4, T5,
     return f(t1, t2, t3, t4, t5, t6, t7, v)
   }
 }
-
 // Unvariadic7 converts a function taking 7 parameters and a final variadic argument into a function with 7 parameters but a final slice argument
 func Unvariadic7[T1, T2, T3, T4, T5, T6, T7, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, v...)
   }
 }
-
 // Pipe8 takes an initial value t0 and successively applies 8 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe8[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, T0, T1, T2, T3, T4, T5, T6, T7, T8 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) T8 {
@@ -530,14 +500,12 @@ func Variadic8[T1, T2, T3, T4, T5, T6, T7, T8, V, R any](f func(T1, T2, T3, T4,
     return f(t1, t2, t3, t4, t5, t6, t7, t8, v)
   }
 }
-
 // Unvariadic8 converts a function taking 8 parameters and a final variadic argument into a function with 8 parameters but a final slice argument
 func Unvariadic8[T1, T2, T3, T4, T5, T6, T7, T8, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, v...)
   }
 }
-
 // Pipe9 takes an initial value t0 and successively applies 9 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe9[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) T9 {
@@ -606,14 +574,12 @@ func Variadic9[T1, T2, T3, T4, T5, T6, T7, T8, T9, V, R any](f func(T1, T2, T3,
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, v)
   }
 }
-
 // Unvariadic9 converts a function taking 9 parameters and a final variadic argument into a function with 9 parameters but a final slice argument
 func Unvariadic9[T1, T2, T3, T4, T5, T6, T7, T8, T9, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, v...)
   }
 }
-
 // Pipe10 takes an initial value t0 and successively applies 10 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe10[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) T10 {
@@ -685,14 +651,12 @@ func Variadic10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, V, R any](f func(T1, T2
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, v)
   }
 }
-
 // Unvariadic10 converts a function taking 10 parameters and a final variadic argument into a function with 10 parameters but a final slice argument
 func Unvariadic10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, v...)
   }
 }
-
 // Pipe11 takes an initial value t0 and successively applies 11 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe11[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11) T11 {
@@ -767,14 +731,12 @@ func Variadic11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, V, R any](f func(T
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, v)
   }
 }
-
 // Unvariadic11 converts a function taking 11 parameters and a final variadic argument into a function with 11 parameters but a final slice argument
 func Unvariadic11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, v...)
   }
 }
-
 // Pipe12 takes an initial value t0 and successively applies 12 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe12[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12) T12 {
@@ -852,14 +814,12 @@ func Variadic12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, V, R any](f f
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, v)
   }
 }
-
 // Unvariadic12 converts a function taking 12 parameters and a final variadic argument into a function with 12 parameters but a final slice argument
 func Unvariadic12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, v...)
   }
 }
-
 // Pipe13 takes an initial value t0 and successively applies 13 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe13[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13) T13 {
@@ -940,14 +900,12 @@ func Variadic13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, V, R any
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, v)
   }
 }
-
 // Unvariadic13 converts a function taking 13 parameters and a final variadic argument into a function with 13 parameters but a final slice argument
 func Unvariadic13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, v...)
   }
 }
-
 // Pipe14 takes an initial value t0 and successively applies 14 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe14[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14) T14 {
@@ -1031,14 +989,12 @@ func Variadic14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, V,
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, v)
   }
 }
-
 // Unvariadic14 converts a function taking 14 parameters and a final variadic argument into a function with 14 parameters but a final slice argument
 func Unvariadic14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, v...)
   }
 }
-
 // Pipe15 takes an initial value t0 and successively applies 15 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe15[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15) T15 {
@@ -1125,14 +1081,12 @@ func Variadic15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, v)
   }
 }
-
 // Unvariadic15 converts a function taking 15 parameters and a final variadic argument into a function with 15 parameters but a final slice argument
 func Unvariadic15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, v...)
   }
 }
-
 // Pipe16 takes an initial value t0 and successively applies 16 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe16[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16) T16 {
@@ -1222,14 +1176,12 @@ func Variadic16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, v)
   }
 }
-
 // Unvariadic16 converts a function taking 16 parameters and a final variadic argument into a function with 16 parameters but a final slice argument
 func Unvariadic16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15, t16 T16, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, v...)
   }
 }
-
 // Pipe17 takes an initial value t0 and successively applies 17 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe17[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17) T17 {
@@ -1322,14 +1274,12 @@ func Variadic17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, v)
   }
 }
-
 // Unvariadic17 converts a function taking 17 parameters and a final variadic argument into a function with 17 parameters but a final slice argument
 func Unvariadic17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15, t16 T16, t17 T17, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, v...)
   }
 }
-
 // Pipe18 takes an initial value t0 and successively applies 18 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe18[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18) T18 {
@@ -1425,14 +1375,12 @@ func Variadic18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, v)
   }
 }
-
 // Unvariadic18 converts a function taking 18 parameters and a final variadic argument into a function with 18 parameters but a final slice argument
 func Unvariadic18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15, t16 T16, t17 T17, t18 T18, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, v...)
   }
 }
-
 // Pipe19 takes an initial value t0 and successively applies 19 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe19[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, F19 ~func(T18) T19, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18, f19 F19) T19 {
@@ -1531,14 +1479,12 @@ func Variadic19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, v)
   }
 }
-
 // Unvariadic19 converts a function taking 19 parameters and a final variadic argument into a function with 19 parameters but a final slice argument
 func Unvariadic19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15, t16 T16, t17 T17, t18 T18, t19 T19, v []V) R {
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, v...)
   }
 }
-
 // Pipe20 takes an initial value t0 and successively applies 20 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe20[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, F19 ~func(T18) T19, F20 ~func(T19) T20, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18, f19 F19, f20 F20) T20 {
@@ -1640,7 +1586,6 @@ func Variadic20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15
     return f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, v)
   }
 }
-
 // Unvariadic20 converts a function taking 20 parameters and a final variadic argument into a function with 20 parameters but a final slice argument
 func Unvariadic20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, V, R any](f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, ...V) R) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, []V) R {
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12, t13 T13, t14 T14, t15 T15, t16 T16, t17 T17, t18 T18, t19 T19, t20 T20, v []V) R {

identity/gen.go

@@ -1,23 +1,10 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:46.7920356 +0200 CEST m=+0.045177201
+// 2023-08-11 11:38:00.2678592 +0200 CEST m=+0.008890401
+
 package identity
 
+
 import (
 	A "github.com/IBM/fp-go/internal/apply"
 	T "github.com/IBM/fp-go/tuple"

internal/apply/gen.go

@@ -1,23 +1,10 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:49.4210571 +0200 CEST m=+0.040316501
+// 2023-08-11 11:38:01.6948567 +0200 CEST m=+0.013530301
+
 package apply
 
+
 import (
 	F "github.com/IBM/fp-go/function"
 	T "github.com/IBM/fp-go/tuple"

io/gen.go

@@ -1,23 +1,10 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:57.7378739 +0200 CEST m=+0.063371401
+// 2023-08-11 11:38:07.3305497 +0200 CEST m=+0.014821301
+
 package io
 
+
 import (
 	G "github.com/IBM/fp-go/io/generic"	
 	T "github.com/IBM/fp-go/tuple"

io/generic/gen.go

@@ -1,26 +1,12 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:57.7499229 +0200 CEST m=+0.075420401
+// 2023-08-11 11:38:07.3305497 +0200 CEST m=+0.014821301
 package generic
 
+
 import (
-	A "github.com/IBM/fp-go/internal/apply"
 	T "github.com/IBM/fp-go/tuple"
+	A "github.com/IBM/fp-go/internal/apply"
 )
 
 // SequenceT1 converts 1 [func() T] into a [func() T.Tuple1[T1]]

ioeither/gen.go

@@ -1,23 +1,10 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:00.7618943 +0200 CEST m=+0.065441701
+// 2023-08-11 11:38:09.4187123 +0200 CEST m=+0.099620101
+
 package ioeither
 
+
 import (
 	G "github.com/IBM/fp-go/ioeither/generic"	
 	T "github.com/IBM/fp-go/tuple"

ioeither/generic/gen.go

@@ -1,27 +1,13 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:00.7765028 +0200 CEST m=+0.080050201
+// 2023-08-11 11:38:09.4489926 +0200 CEST m=+0.129900401
 package generic
 
+
 import (
 	ET "github.com/IBM/fp-go/either"
-	A "github.com/IBM/fp-go/internal/apply"
 	T "github.com/IBM/fp-go/tuple"
+	A "github.com/IBM/fp-go/internal/apply"
 )
 
 // Eitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [GIOA]
@@ -30,8 +16,7 @@ func Eitherize0[GIOA ~func() ET.Either[error, R], F ~func() (R, error), R any](f
   return func() GIOA {
     return func() ET.Either[error, R] {
       return e()
-		}
-	}
+    }}
 }
 
 // Uneitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [GIOA]
@@ -47,8 +32,7 @@ func Eitherize1[GIOA ~func() ET.Either[error, R], F ~func(T1) (R, error), T1, R
   return func(t1 T1) GIOA {
     return func() ET.Either[error, R] {
       return e(t1)
-		}
-	}
+    }}
 }
 
 // Uneitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [GIOA]
@@ -101,8 +85,7 @@ func Eitherize2[GIOA ~func() ET.Either[error, R], F ~func(T1, T2) (R, error), T1
   return func(t1 T1, t2 T2) GIOA {
     return func() ET.Either[error, R] {
       return e(t1, t2)
-		}
-	}
+    }}
 }
 
 // Uneitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning a [GIOA]
@@ -165,8 +148,7 @@ func Eitherize3[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3) (R, error)
   return func(t1 T1, t2 T2, t3 T3) GIOA {
     return func() ET.Either[error, R] {
       return e(t1, t2, t3)
-		}
-	}
+    }}
 }
 
 // Uneitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning a [GIOA]
@@ -239,8 +221,7 @@ func Eitherize4[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4) (R, er
   return func(t1 T1, t2 T2, t3 T3, t4 T4) GIOA {
     return func() ET.Either[error, R] {
       return e(t1, t2, t3, t4)
-		}
-	}
+    }}
 }
 
 // Uneitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning a [GIOA]
@@ -323,8 +304,7 @@ func Eitherize5[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5) (R
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GIOA {
     return func() ET.Either[error, R] {
       return e(t1, t2, t3, t4, t5)
-		}
-	}
+    }}
 }
 
 // Uneitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning a [GIOA]
@@ -417,8 +397,7 @@ func Eitherize6[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GIOA {
     return func() ET.Either[error, R] {
       return e(t1, t2, t3, t4, t5, t6)
-		}
-	}
+    }}
 }
 
 // Uneitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning a [GIOA]
@@ -521,8 +500,7 @@ func Eitherize7[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GIOA {
     return func() ET.Either[error, R] {
       return e(t1, t2, t3, t4, t5, t6, t7)
-		}
-	}
+    }}
 }
 
 // Uneitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning a [GIOA]
@@ -635,8 +613,7 @@ func Eitherize8[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GIOA {
     return func() ET.Either[error, R] {
       return e(t1, t2, t3, t4, t5, t6, t7, t8)
-		}
-	}
+    }}
 }
 
 // Uneitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning a [GIOA]
@@ -759,8 +736,7 @@ func Eitherize9[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GIOA {
     return func() ET.Either[error, R] {
       return e(t1, t2, t3, t4, t5, t6, t7, t8, t9)
-		}
-	}
+    }}
 }
 
 // Uneitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning a [GIOA]
@@ -893,8 +869,7 @@ func Eitherize10[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T
   return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) GIOA {
     return func() ET.Either[error, R] {
       return e(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
-		}
-	}
+    }}
 }
 
 // Uneitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning a [GIOA]

iooption/gen.go

@@ -1,23 +1,10 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:03.8471425 +0200 CEST m=+0.087124201
+// 2023-08-11 11:38:12.1021634 +0200 CEST m=+0.041956701
+
 package iooption
 
+
 import (
 	G "github.com/IBM/fp-go/iooption/generic"	
 	T "github.com/IBM/fp-go/tuple"

iooption/generic/gen.go

@@ -1,27 +1,13 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:03.8541587 +0200 CEST m=+0.094140401
+// 2023-08-11 11:38:12.1210201 +0200 CEST m=+0.060813401
 package generic
 
+
 import (
-	A "github.com/IBM/fp-go/internal/apply"
-	O "github.com/IBM/fp-go/option"
 	T "github.com/IBM/fp-go/tuple"
+	O "github.com/IBM/fp-go/option"
+	A "github.com/IBM/fp-go/internal/apply"
 )
 
 // SequenceT1 converts 1 [func() O.Option[T]] into a [func() O.Option[T.Tuple1[T1]]]

iterator/stateless/generic/iterator.go

@@ -20,6 +20,7 @@ import (
 	F "github.com/IBM/fp-go/function"
 	"github.com/IBM/fp-go/internal/utils"
 	IO "github.com/IBM/fp-go/iooption/generic"
+	M "github.com/IBM/fp-go/monoid"
 	N "github.com/IBM/fp-go/number"
 	O "github.com/IBM/fp-go/option"
 	T "github.com/IBM/fp-go/tuple"
@@ -219,3 +220,22 @@ func Ap[GUV ~func() O.Option[T.Tuple2[GUV, func(U) V]], GV ~func() O.Option[T.Tu
 func MonadAp[GUV ~func() O.Option[T.Tuple2[GUV, func(U) V]], GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](fab GUV, ma GU) GV {
 	return Ap[GUV, GV, GU](ma)(fab)
 }
+
+func FilterChain[GVV ~func() O.Option[T.Tuple2[GVV, GV]], GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(U) O.Option[GV], U, V any](f FCT) func(ma GU) GV {
+	return F.Flow2(
+		FilterMap[GVV, GU](f),
+		Flatten[GVV],
+	)
+}
+
+func FoldMap[GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(U) V, U, V any](m M.Monoid[V]) func(FCT) func(ma GU) V {
+	return func(f FCT) func(ma GU) V {
+		return Reduce[GU](func(cur V, a U) V {
+			return m.Concat(cur, f(a))
+		}, m.Empty())
+	}
+}
+
+func Fold[GU ~func() O.Option[T.Tuple2[GU, U]], U any](m M.Monoid[U]) func(ma GU) U {
+	return Reduce[GU](m.Concat, m.Empty())
+}

iterator/stateless/iterator.go

@@ -18,6 +18,7 @@ package stateless
 import (
 	G "github.com/IBM/fp-go/iterator/stateless/generic"
 	L "github.com/IBM/fp-go/lazy"
+	M "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/option"
 	T "github.com/IBM/fp-go/tuple"
 )
@@ -118,3 +119,18 @@ func Repeat[U any](n int, a U) Iterator[U] {
 func Count(start int) Iterator[int] {
 	return G.Count[Iterator[int]](start)
 }
+
+// FilterChain filters and transforms the content of an iterator
+func FilterChain[U, V any](f func(U) O.Option[Iterator[V]]) func(ma Iterator[U]) Iterator[V] {
+	return G.FilterChain[Iterator[Iterator[V]], Iterator[V], Iterator[U]](f)
+}
+
+// FoldMap maps and folds an iterator. Map the iterator passing each value to the iterating function. Then fold the results using the provided Monoid.
+func FoldMap[U, V any](m M.Monoid[V]) func(func(U) V) func(ma Iterator[U]) V {
+	return G.FoldMap[Iterator[U], func(U) V, U, V](m)
+}
+
+// Fold folds the iterator using the provided Monoid.
+func Fold[U any](m M.Monoid[U]) func(Iterator[U]) U {
+	return G.Fold[Iterator[U]](m)
+}

iterator/stateless/iterator_test.go

@@ -18,12 +18,14 @@ package stateless
 import (
 	"fmt"
 	"math"
+	"strings"
 	"testing"
 
 	A "github.com/IBM/fp-go/array"
 	F "github.com/IBM/fp-go/function"
 	"github.com/IBM/fp-go/internal/utils"
 	O "github.com/IBM/fp-go/option"
+	S "github.com/IBM/fp-go/string"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -102,3 +104,14 @@ func TestAp(t *testing.T) {
 
 	assert.Equal(t, A.From("a-1-c", "a-1-d", "a-2-c", "a-2-d", "b-1-c", "b-1-d", "b-2-c", "b-2-d"), it)
 }
+
+func ExampleFoldMap() {
+	src := From("a", "b", "c")
+
+	fold := FoldMap[string](S.Monoid)(strings.ToUpper)
+
+	fmt.Println(fold(src))
+
+	// Output: ABC
+
+}

option/gen.go

@@ -1,28 +1,14 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:06.6236747 +0200 CEST m=+0.039283301
+// 2023-08-11 11:38:14.9503867 +0200 CEST m=+0.020206701
+
 package option
 
+
 import (
 	A "github.com/IBM/fp-go/internal/apply"
 	T "github.com/IBM/fp-go/tuple"
 )
-
 // optionize converts a nullary function to an option
 func optionize[R any](f func() (R, bool)) Option[R] {
 	if r, ok := f(); ok {

reader/gen.go

@@ -1,23 +1,10 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:14.4173227 +0200 CEST m=+0.013163201
+// 2023-08-11 11:38:23.1396887 +0200 CEST m=+0.020805301
+
 package reader
 
+
 import (
 	G "github.com/IBM/fp-go/reader/generic"	
 )

reader/generic/gen.go

@@ -1,23 +1,9 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:14.4173227 +0200 CEST m=+0.013163201
+// 2023-08-11 11:38:23.1402159 +0200 CEST m=+0.021332501
 package generic
 
+
 // From0 converts a function with 1 parameters returning a [R] into a function with 0 parameters returning a [GRA]
 // The first parameter is considered to be the context [C].
 func From0[GRA ~func(C) R, F ~func(C) R, C, R any](f F) func() GRA {

readerioeither/gen.go

@@ -1,23 +1,10 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:16.5272334 +0200 CEST m=+0.043108701
+// 2023-08-11 11:38:26.9546728 +0200 CEST m=+0.032178301
+
 package readerioeither
 
+
 import (
 	G "github.com/IBM/fp-go/readerioeither/generic"	
 )

readerioeither/generic/gen.go

@@ -1,23 +1,9 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:16.5292332 +0200 CEST m=+0.045108501
+// 2023-08-11 11:38:26.9556725 +0200 CEST m=+0.033178001
 package generic
 
+
 import (
 	E "github.com/IBM/fp-go/either"
 	RD "github.com/IBM/fp-go/reader/generic"
@@ -37,8 +23,7 @@ func Eitherize0[GRA ~func(C) GIOA, F ~func(C) (R, error), GIOA ~func() E.Either[
   return From0[GRA](func(r C) func() (R, error) {
     return func() (R, error) {
       return f(r)
-		}
-	})
+    }})
 }
 
 // From1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [GRA]
@@ -55,8 +40,7 @@ func Eitherize1[GRA ~func(C) GIOA, F ~func(C, T0) (R, error), GIOA ~func() E.Eit
   return From1[GRA](func(r C, t0 T0) func() (R, error) {
     return func() (R, error) {
       return f(r, t0)
-		}
-	})
+    }})
 }
 
 // From2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [GRA]
@@ -73,8 +57,7 @@ func Eitherize2[GRA ~func(C) GIOA, F ~func(C, T0, T1) (R, error), GIOA ~func() E
   return From2[GRA](func(r C, t0 T0, t1 T1) func() (R, error) {
     return func() (R, error) {
       return f(r, t0, t1)
-		}
-	})
+    }})
 }
 
 // From3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [GRA]
@@ -91,8 +74,7 @@ func Eitherize3[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2) (R, error), GIOA ~func
   return From3[GRA](func(r C, t0 T0, t1 T1, t2 T2) func() (R, error) {
     return func() (R, error) {
       return f(r, t0, t1, t2)
-		}
-	})
+    }})
 }
 
 // From4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [GRA]
@@ -109,8 +91,7 @@ func Eitherize4[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3) (R, error), GIOA ~
   return From4[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3) func() (R, error) {
     return func() (R, error) {
       return f(r, t0, t1, t2, t3)
-		}
-	})
+    }})
 }
 
 // From5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [GRA]
@@ -127,8 +108,7 @@ func Eitherize5[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4) (R, error), GI
   return From5[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) func() (R, error) {
     return func() (R, error) {
       return f(r, t0, t1, t2, t3, t4)
-		}
-	})
+    }})
 }
 
 // From6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [GRA]
@@ -145,8 +125,7 @@ func Eitherize6[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5) (R, error)
   return From6[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) func() (R, error) {
     return func() (R, error) {
       return f(r, t0, t1, t2, t3, t4, t5)
-		}
-	})
+    }})
 }
 
 // From7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [GRA]
@@ -163,8 +142,7 @@ func Eitherize7[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R, er
   return From7[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) func() (R, error) {
     return func() (R, error) {
       return f(r, t0, t1, t2, t3, t4, t5, t6)
-		}
-	})
+    }})
 }
 
 // From8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [GRA]
@@ -181,8 +159,7 @@ func Eitherize8[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R
   return From8[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) func() (R, error) {
     return func() (R, error) {
       return f(r, t0, t1, t2, t3, t4, t5, t6, t7)
-		}
-	})
+    }})
 }
 
 // From9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [GRA]
@@ -199,8 +176,7 @@ func Eitherize9[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8
   return From9[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) func() (R, error) {
     return func() (R, error) {
       return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8)
-		}
-	})
+    }})
 }
 
 // From10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [GRA]
@@ -217,6 +193,5 @@ func Eitherize10[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T
   return From10[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) func() (R, error) {
     return func() (R, error) {
       return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
-		}
-	})
+    }})
 }

record/doc.go

@@ -0,0 +1,17 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package record contains monadic operations for maps as well as a rich set of utility functions
+package record

record/generic/monoid.go

@@ -16,6 +16,7 @@
 package generic
 
 import (
+	F "github.com/IBM/fp-go/function"
 	M "github.com/IBM/fp-go/monoid"
 	S "github.com/IBM/fp-go/semigroup"
 )
@@ -26,3 +27,17 @@ func UnionMonoid[N ~map[K]V, K comparable, V any](s S.Semigroup[V]) M.Monoid[N]
 		Empty[N](),
 	)
 }
+
+func UnionLastMonoid[N ~map[K]V, K comparable, V any]() M.Monoid[N] {
+	return M.MakeMonoid(
+		unionLast[N],
+		Empty[N](),
+	)
+}
+
+func UnionFirstMonoid[N ~map[K]V, K comparable, V any]() M.Monoid[N] {
+	return M.MakeMonoid(
+		F.Swap(unionLast[N]),
+		Empty[N](),
+	)
+}

record/generic/record.go

@@ -16,10 +16,14 @@
 package generic
 
 import (
+	"sort"
+
 	F "github.com/IBM/fp-go/function"
 	G "github.com/IBM/fp-go/internal/record"
 	Mg "github.com/IBM/fp-go/magma"
+	Mo "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/option"
+	"github.com/IBM/fp-go/ord"
 	T "github.com/IBM/fp-go/tuple"
 )
 
@@ -39,6 +43,46 @@ func Values[M ~map[K]V, GV ~[]V, K comparable, V any](r M) GV {
 	return collect[M, GV](r, F.Second[K, V])
 }
 
+func KeysOrd[M ~map[K]V, GK ~[]K, K comparable, V any](o ord.Ord[K]) func(r M) GK {
+	return func(r M) GK {
+		return collectOrd[M, GK](o, r, F.First[K, V])
+	}
+}
+
+func ValuesOrd[M ~map[K]V, GV ~[]V, K comparable, V any](o ord.Ord[K]) func(r M) GV {
+	return func(r M) GV {
+		return collectOrd[M, GV](o, r, F.Second[K, V])
+	}
+}
+
+func collectOrd[M ~map[K]V, GR ~[]R, K comparable, V, R any](o ord.Ord[K], r M, f func(K, V) R) GR {
+	// create the entries
+	entries := toEntriesOrd[M, []T.Tuple2[K, V]](o, r)
+	// collect this array
+	ft := T.Tupled2(f)
+	count := len(entries)
+	result := make(GR, count)
+	for i := count - 1; i >= 0; i-- {
+		result[i] = ft(entries[i])
+	}
+	// done
+	return result
+}
+
+func reduceOrd[M ~map[K]V, K comparable, V, R any](o ord.Ord[K], r M, f func(K, R, V) R, initial R) R {
+	// create the entries
+	entries := toEntriesOrd[M, []T.Tuple2[K, V]](o, r)
+	// collect this array
+	current := initial
+	count := len(entries)
+	for i := 0; i < count; i++ {
+		t := entries[i]
+		current = f(T.First(t), current, T.Second(t))
+	}
+	// done
+	return current
+}
+
 func collect[M ~map[K]V, GR ~[]R, K comparable, V, R any](r M, f func(K, V) R) GR {
 	count := len(r)
 	result := make(GR, count)
@@ -82,6 +126,34 @@ func MonadMap[M ~map[K]V, N ~map[K]R, K comparable, V, R any](r M, f func(V) R)
 	return MonadMapWithIndex[M, N](r, F.Ignore1of2[K](f))
 }
 
+func MonadChainWithIndex[M ~map[K]V1, N ~map[K]V2, K comparable, V1, V2 any](m Mo.Monoid[N], r M, f func(K, V1) N) N {
+	return G.ReduceWithIndex(r, func(k K, dst N, b V1) N {
+		return m.Concat(dst, f(k, b))
+	}, m.Empty())
+}
+
+func MonadChain[M ~map[K]V1, N ~map[K]V2, K comparable, V1, V2 any](m Mo.Monoid[N], r M, f func(V1) N) N {
+	return G.Reduce(r, func(dst N, b V1) N {
+		return m.Concat(dst, f(b))
+	}, m.Empty())
+}
+
+func ChainWithIndex[M ~map[K]V1, N ~map[K]V2, K comparable, V1, V2 any](m Mo.Monoid[N]) func(func(K, V1) N) func(M) N {
+	return func(f func(K, V1) N) func(M) N {
+		return func(ma M) N {
+			return MonadChainWithIndex(m, ma, f)
+		}
+	}
+}
+
+func Chain[M ~map[K]V1, N ~map[K]V2, K comparable, V1, V2 any](m Mo.Monoid[N]) func(func(V1) N) func(M) N {
+	return func(f func(V1) N) func(M) N {
+		return func(ma M) N {
+			return MonadChain(m, ma, f)
+		}
+	}
+}
+
 func MonadMapWithIndex[M ~map[K]V, N ~map[K]R, K comparable, V, R any](r M, f func(K, V) R) N {
 	return G.ReduceWithIndex(r, func(k K, dst N, v V) N {
 		return upsertAtReadWrite(dst, k, f(k, v))
@@ -114,15 +186,14 @@ func MapRefWithIndex[M ~map[K]V, N ~map[K]R, K comparable, V, R any](f func(K, *
 	return F.Bind2nd(MonadMapRefWithIndex[M, N, K, V, R], f)
 }
 
-func lookup[M ~map[K]V, K comparable, V any](r M, k K) O.Option[V] {
-	if val, ok := r[k]; ok {
+func Lookup[M ~map[K]V, K comparable, V any](k K) func(M) O.Option[V] {
+	n := O.None[V]()
+	return func(m M) O.Option[V] {
+		if val, ok := m[k]; ok {
 			return O.Some(val)
 		}
-	return O.None[V]()
+		return n
 	}
-
-func Lookup[M ~map[K]V, K comparable, V any](k K) func(M) O.Option[V] {
-	return F.Bind2nd(lookup[M, K, V], k)
 }
 
 func Has[M ~map[K]V, K comparable, V any](k K, r M) bool {
@@ -161,6 +232,31 @@ func union[M ~map[K]V, K comparable, V any](m Mg.Magma[V], left M, right M) M {
 	return result
 }
 
+func unionLast[M ~map[K]V, K comparable, V any](left M, right M) M {
+	lenLeft := len(left)
+
+	if lenLeft == 0 {
+		return right
+	}
+
+	lenRight := len(right)
+	if lenRight == 0 {
+		return left
+	}
+
+	result := make(M, lenLeft+lenRight)
+
+	for k, v := range left {
+		result[k] = v
+	}
+
+	for k, v := range right {
+		result[k] = v
+	}
+
+	return result
+}
+
 func Union[M ~map[K]V, K comparable, V any](m Mg.Magma[V]) func(M) func(M) M {
 	return func(right M) func(M) M {
 		return func(left M) M {
@@ -169,6 +265,22 @@ func Union[M ~map[K]V, K comparable, V any](m Mg.Magma[V]) func(M) func(M) M {
 	}
 }
 
+func UnionLast[M ~map[K]V, K comparable, V any](right M) func(M) M {
+	return func(left M) M {
+		return unionLast(left, right)
+	}
+}
+
+func Merge[M ~map[K]V, K comparable, V any](right M) func(M) M {
+	return UnionLast(right)
+}
+
+func UnionFirst[M ~map[K]V, K comparable, V any](right M) func(M) M {
+	return func(left M) M {
+		return unionLast(right, left)
+	}
+}
+
 func Empty[M ~map[K]V, K comparable, V any]() M {
 	return make(M)
 }
@@ -181,6 +293,27 @@ func ToArray[M ~map[K]V, GT ~[]T.Tuple2[K, V], K comparable, V any](r M) GT {
 	return collect[M, GT](r, T.MakeTuple2[K, V])
 }
 
+func toEntriesOrd[M ~map[K]V, GT ~[]T.Tuple2[K, V], K comparable, V any](o ord.Ord[K], r M) GT {
+	// total number of elements
+	count := len(r)
+	// produce an array that we can sort by key
+	entries := make(GT, count)
+	idx := 0
+	for k, v := range r {
+		entries[idx] = T.MakeTuple2(k, v)
+		idx++
+	}
+	sort.Slice(entries, func(i, j int) bool {
+		return o.Compare(T.First(entries[i]), T.First(entries[j])) < 0
+	})
+	// final entries
+	return entries
+}
+
+func ToEntriesOrd[M ~map[K]V, GT ~[]T.Tuple2[K, V], K comparable, V any](o ord.Ord[K]) func(r M) GT {
+	return F.Bind1st(toEntriesOrd[M, GT, K, V], o)
+}
+
 func ToEntries[M ~map[K]V, GT ~[]T.Tuple2[K, V], K comparable, V any](r M) GT {
 	return ToArray[M, GT](r)
 }
@@ -269,6 +402,33 @@ func FilterMap[M ~map[K]V1, N ~map[K]V2, K comparable, V1, V2 any](f func(V1) O.
 	return F.Bind2nd(filterMapWithIndex[M, N, K, V1, V2], F.Ignore1of2[K](f))
 }
 
+// Flatten converts a nested map into a regular map
+func Flatten[M ~map[K]N, N ~map[K]V, K comparable, V any](m Mo.Monoid[N]) func(M) N {
+	return Chain[M, N](m)(F.Identity[N])
+}
+
+// FilterChainWithIndex creates a new map with only the elements for which the transformation function creates a Some
+func FilterChainWithIndex[M ~map[K]V1, N ~map[K]V2, K comparable, V1, V2 any](m Mo.Monoid[N]) func(func(K, V1) O.Option[N]) func(M) N {
+	flatten := Flatten[map[K]N, N](m)
+	return func(f func(K, V1) O.Option[N]) func(M) N {
+		return F.Flow2(
+			FilterMapWithIndex[M, map[K]N](f),
+			flatten,
+		)
+	}
+}
+
+// FilterChain creates a new map with only the elements for which the transformation function creates a Some
+func FilterChain[M ~map[K]V1, N ~map[K]V2, K comparable, V1, V2 any](m Mo.Monoid[N]) func(func(V1) O.Option[N]) func(M) N {
+	flatten := Flatten[map[K]N, N](m)
+	return func(f func(V1) O.Option[N]) func(M) N {
+		return F.Flow2(
+			FilterMap[M, map[K]N](f),
+			flatten,
+		)
+	}
+}
+
 // IsNil checks if the map is set to nil
 func IsNil[M ~map[K]V, K comparable, V any](m M) bool {
 	return m == nil
@@ -283,3 +443,67 @@ func IsNonNil[M ~map[K]V, K comparable, V any](m M) bool {
 func ConstNil[M ~map[K]V, K comparable, V any]() M {
 	return (M)(nil)
 }
+
+func FoldMap[AS ~map[K]A, K comparable, A, B any](m Mo.Monoid[B]) func(func(A) B) func(AS) B {
+	return func(f func(A) B) func(AS) B {
+		return Reduce[AS](func(cur B, a A) B {
+			return m.Concat(cur, f(a))
+		}, m.Empty())
+	}
+}
+
+func Fold[AS ~map[K]A, K comparable, A any](m Mo.Monoid[A]) func(AS) A {
+	return Reduce[AS](m.Concat, m.Empty())
+}
+
+func FoldMapWithIndex[AS ~map[K]A, K comparable, A, B any](m Mo.Monoid[B]) func(func(K, A) B) func(AS) B {
+	return func(f func(K, A) B) func(AS) B {
+		return ReduceWithIndex[AS](func(k K, cur B, a A) B {
+			return m.Concat(cur, f(k, a))
+		}, m.Empty())
+	}
+}
+
+func ReduceOrdWithIndex[M ~map[K]V, K comparable, V, R any](o ord.Ord[K]) func(func(K, R, V) R, R) func(M) R {
+	return func(f func(K, R, V) R, initial R) func(M) R {
+		return func(m M) R {
+			return reduceOrd(o, m, f, initial)
+		}
+	}
+}
+
+func ReduceOrd[M ~map[K]V, K comparable, V, R any](o ord.Ord[K]) func(func(R, V) R, R) func(M) R {
+	ro := ReduceOrdWithIndex[M, K, V, R](o)
+	return func(f func(R, V) R, initial R) func(M) R {
+		return ro(F.Ignore1of3[K](f), initial)
+	}
+}
+
+func FoldMapOrd[AS ~map[K]A, K comparable, A, B any](o ord.Ord[K]) func(m Mo.Monoid[B]) func(func(A) B) func(AS) B {
+	red := ReduceOrd[AS, K, A, B](o)
+	return func(m Mo.Monoid[B]) func(func(A) B) func(AS) B {
+		return func(f func(A) B) func(AS) B {
+			return red(func(cur B, a A) B {
+				return m.Concat(cur, f(a))
+			}, m.Empty())
+		}
+	}
+}
+
+func FoldOrd[AS ~map[K]A, K comparable, A any](o ord.Ord[K]) func(m Mo.Monoid[A]) func(AS) A {
+	red := ReduceOrd[AS, K, A, A](o)
+	return func(m Mo.Monoid[A]) func(AS) A {
+		return red(m.Concat, m.Empty())
+	}
+}
+
+func FoldMapOrdWithIndex[AS ~map[K]A, K comparable, A, B any](o ord.Ord[K]) func(m Mo.Monoid[B]) func(func(K, A) B) func(AS) B {
+	red := ReduceOrdWithIndex[AS, K, A, B](o)
+	return func(m Mo.Monoid[B]) func(func(K, A) B) func(AS) B {
+		return func(f func(K, A) B) func(AS) B {
+			return red(func(k K, cur B, a A) B {
+				return m.Concat(cur, f(k, a))
+			}, m.Empty())
+		}
+	}
+}

record/generic/semigroup.go

@@ -20,8 +20,19 @@ import (
 )
 
 func UnionSemigroup[N ~map[K]V, K comparable, V any](s S.Semigroup[V]) S.Semigroup[N] {
-	union := Union[N, K, V](s)
 	return S.MakeSemigroup(func(first N, second N) N {
-		return union(second)(first)
+		return union[N, K, V](S.ToMagma(s), first, second)
+	})
+}
+
+func UnionLastSemigroup[N ~map[K]V, K comparable, V any]() S.Semigroup[N] {
+	return S.MakeSemigroup(func(first N, second N) N {
+		return unionLast[N, K, V](first, second)
+	})
+}
+
+func UnionFirstSemigroup[N ~map[K]V, K comparable, V any]() S.Semigroup[N] {
+	return S.MakeSemigroup(func(first N, second N) N {
+		return unionLast[N, K, V](second, first)
 	})
 }

record/monoid.go

@@ -21,6 +21,22 @@ import (
 	S "github.com/IBM/fp-go/semigroup"
 )
 
+// UnionMonoid computes the union of two maps of the same type
 func UnionMonoid[K comparable, V any](s S.Semigroup[V]) M.Monoid[map[K]V] {
 	return G.UnionMonoid[map[K]V](s)
 }
+
+// UnionLastMonoid computes the union of two maps of the same type giving the last map precedence
+func UnionLastMonoid[K comparable, V any]() M.Monoid[map[K]V] {
+	return G.UnionLastMonoid[map[K]V]()
+}
+
+// UnionFirstMonoid computes the union of two maps of the same type giving the first map precedence
+func UnionFirstMonoid[K comparable, V any]() M.Monoid[map[K]V] {
+	return G.UnionFirstMonoid[map[K]V]()
+}
+
+// MergeMonoid computes the union of two maps of the same type giving the last map precedence
+func MergeMonoid[K comparable, V any]() M.Monoid[map[K]V] {
+	return G.UnionLastMonoid[map[K]V]()
+}

record/record.go

@@ -17,27 +17,34 @@ package record
 
 import (
 	Mg "github.com/IBM/fp-go/magma"
+	Mo "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/option"
+	"github.com/IBM/fp-go/ord"
 	G "github.com/IBM/fp-go/record/generic"
 	T "github.com/IBM/fp-go/tuple"
 )
 
+// IsEmpty tests if a map is empty
 func IsEmpty[K comparable, V any](r map[K]V) bool {
 	return G.IsEmpty(r)
 }
 
+// IsNonEmpty tests if a map is not empty
 func IsNonEmpty[K comparable, V any](r map[K]V) bool {
 	return G.IsNonEmpty(r)
 }
 
+// Keys returns the key in a map
 func Keys[K comparable, V any](r map[K]V) []K {
 	return G.Keys[map[K]V, []K](r)
 }
 
+// Values returns the values in a map
 func Values[K comparable, V any](r map[K]V) []V {
 	return G.Values[map[K]V, []V](r)
 }
 
+// Collect applies a collector function to the key value pairs in a map and returns the result as an array
 func Collect[K comparable, V, R any](f func(K, V) R) func(map[K]V) []R {
 	return G.Collect[map[K]V, []R](f)
 }
@@ -90,10 +97,12 @@ func MapRefWithIndex[K comparable, V, R any](f func(K, *V) R) func(map[K]V) map[
 	return G.MapRefWithIndex[map[K]V, map[K]R](f)
 }
 
+// Lookup returns the entry for a key in a map if it exists
 func Lookup[K comparable, V any](k K) func(map[K]V) O.Option[V] {
 	return G.Lookup[map[K]V](k)
 }
 
+// Has tests if a key is contained in a map
 func Has[K comparable, V any](k K, r map[K]V) bool {
 	return G.Has(k, r)
 }
@@ -102,10 +111,17 @@ func Union[K comparable, V any](m Mg.Magma[V]) func(map[K]V) func(map[K]V) map[K
 	return G.Union[map[K]V](m)
 }
 
+// Merge combines two maps giving the values in the right one precedence. Also refer to [MergeMonoid]
+func Merge[K comparable, V any](right map[K]V) func(map[K]V) map[K]V {
+	return G.Merge[map[K]V](right)
+}
+
+// Empty creates an empty map
 func Empty[K comparable, V any]() map[K]V {
 	return G.Empty[map[K]V]()
 }
 
+// Size returns the number of elements in a map
 func Size[K comparable, V any](r map[K]V) int {
 	return G.Size(r)
 }
@@ -130,6 +146,7 @@ func DeleteAt[K comparable, V any](k K) func(map[K]V) map[K]V {
 	return G.DeleteAt[map[K]V](k)
 }
 
+// Singleton creates a new map with a single entry
 func Singleton[K comparable, V any](k K, v V) map[K]V {
 	return G.Singleton[map[K]V](k, v)
 }
@@ -168,3 +185,84 @@ func IsNonNil[K comparable, V any](m map[K]V) bool {
 func ConstNil[K comparable, V any]() map[K]V {
 	return (map[K]V)(nil)
 }
+
+func MonadChainWithIndex[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2], r map[K]V1, f func(K, V1) map[K]V2) map[K]V2 {
+	return G.MonadChainWithIndex(m, r, f)
+}
+
+func MonadChain[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2], r map[K]V1, f func(V1) map[K]V2) map[K]V2 {
+	return G.MonadChain(m, r, f)
+}
+
+func ChainWithIndex[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2]) func(func(K, V1) map[K]V2) func(map[K]V1) map[K]V2 {
+	return G.ChainWithIndex[map[K]V1](m)
+}
+
+func Chain[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2]) func(func(V1) map[K]V2) func(map[K]V1) map[K]V2 {
+	return G.Chain[map[K]V1](m)
+}
+
+// Flatten converts a nested map into a regular map
+func Flatten[K comparable, V any](m Mo.Monoid[map[K]V]) func(map[K]map[K]V) map[K]V {
+	return G.Flatten[map[K]map[K]V](m)
+}
+
+// FilterChainWithIndex creates a new map with only the elements for which the transformation function creates a Some
+func FilterChainWithIndex[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2]) func(func(K, V1) O.Option[map[K]V2]) func(map[K]V1) map[K]V2 {
+	return G.FilterChainWithIndex[map[K]V1](m)
+}
+
+// FilterChain creates a new map with only the elements for which the transformation function creates a Some
+func FilterChain[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2]) func(func(V1) O.Option[map[K]V2]) func(map[K]V1) map[K]V2 {
+	return G.FilterChain[map[K]V1](m)
+}
+
+// FoldMap maps and folds a record. Map the record passing each value to the iterating function. Then fold the results using the provided Monoid.
+func FoldMap[K comparable, A, B any](m Mo.Monoid[B]) func(func(A) B) func(map[K]A) B {
+	return G.FoldMap[map[K]A](m)
+}
+
+// FoldMapWithIndex maps and folds a record. Map the record passing each value to the iterating function. Then fold the results using the provided Monoid.
+func FoldMapWithIndex[K comparable, A, B any](m Mo.Monoid[B]) func(func(K, A) B) func(map[K]A) B {
+	return G.FoldMapWithIndex[map[K]A](m)
+}
+
+// Fold folds the record using the provided Monoid.
+func Fold[K comparable, A any](m Mo.Monoid[A]) func(map[K]A) A {
+	return G.Fold[map[K]A](m)
+}
+
+// ReduceOrdWithIndex reduces a map into a single value via a reducer function making sure that the keys are passed to the reducer in the specified order
+func ReduceOrdWithIndex[V, R any, K comparable](o ord.Ord[K]) func(func(K, R, V) R, R) func(map[K]V) R {
+	return G.ReduceOrdWithIndex[map[K]V, K, V, R](o)
+}
+
+// ReduceOrd reduces a map into a single value via a reducer function making sure that the keys are passed to the reducer in the specified order
+func ReduceOrd[V, R any, K comparable](o ord.Ord[K]) func(func(R, V) R, R) func(map[K]V) R {
+	return G.ReduceOrd[map[K]V, K, V, R](o)
+}
+
+// FoldMap maps and folds a record. Map the record passing each value to the iterating function. Then fold the results using the provided Monoid and the items in the provided order
+func FoldMapOrd[A, B any, K comparable](o ord.Ord[K]) func(m Mo.Monoid[B]) func(func(A) B) func(map[K]A) B {
+	return G.FoldMapOrd[map[K]A, K, A, B](o)
+}
+
+// Fold folds the record using the provided Monoid with the items passed in the given order
+func FoldOrd[A any, K comparable](o ord.Ord[K]) func(m Mo.Monoid[A]) func(map[K]A) A {
+	return G.FoldOrd[map[K]A, K, A](o)
+}
+
+// FoldMapWithIndex maps and folds a record. Map the record passing each value to the iterating function. Then fold the results using the provided Monoid and the items in the provided order
+func FoldMapOrdWithIndex[K comparable, A, B any](o ord.Ord[K]) func(m Mo.Monoid[B]) func(func(K, A) B) func(map[K]A) B {
+	return G.FoldMapOrdWithIndex[map[K]A, K, A, B](o)
+}
+
+// KeysOrd returns the keys in the map in their given order
+func KeysOrd[V any, K comparable](o ord.Ord[K]) func(r map[K]V) []K {
+	return G.KeysOrd[map[K]V, []K, K, V](o)
+}
+
+// ValuesOrd returns the values in the map ordered by their keys in the given order
+func ValuesOrd[V any, K comparable](o ord.Ord[K]) func(r map[K]V) []V {
+	return G.ValuesOrd[map[K]V, []V, K, V](o)
+}

record/record_test.go

@@ -16,11 +16,14 @@
 package record
 
 import (
+	"fmt"
 	"sort"
+	"strings"
 	"testing"
 
 	"github.com/IBM/fp-go/internal/utils"
 	O "github.com/IBM/fp-go/option"
+	S "github.com/IBM/fp-go/string"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -71,3 +74,60 @@ func TestLookup(t *testing.T) {
 	assert.Equal(t, O.Some("a"), Lookup[string, string]("a")(data))
 	assert.Equal(t, O.None[string](), Lookup[string, string]("a1")(data))
 }
+
+func TestFilterChain(t *testing.T) {
+	src := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+	}
+
+	f := func(k string, value int) O.Option[map[string]string] {
+		if value%2 != 0 {
+			return O.Of(map[string]string{
+				k: fmt.Sprintf("%s%d", k, value),
+			})
+		}
+		return O.None[map[string]string]()
+	}
+
+	// monoid
+	monoid := MergeMonoid[string, string]()
+
+	res := FilterChainWithIndex[int](monoid)(f)(src)
+
+	assert.Equal(t, map[string]string{
+		"a": "a1",
+		"c": "c3",
+	}, res)
+}
+
+func ExampleFoldMap() {
+	src := map[string]string{
+		"a": "a",
+		"b": "b",
+		"c": "c",
+	}
+
+	fold := FoldMap[string, string](S.Monoid)(strings.ToUpper)
+
+	fmt.Println(fold(src))
+
+	// Output: ABC
+
+}
+
+func ExampleValuesOrd() {
+	src := map[string]string{
+		"c": "a",
+		"b": "b",
+		"a": "c",
+	}
+
+	getValues := ValuesOrd[string](S.Ord)
+
+	fmt.Println(getValues(src))
+
+	// Output: [c b a]
+
+}

record/semigroup.go

@@ -12,6 +12,7 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+
 package record
 
 import (
@@ -22,3 +23,11 @@ import (
 func UnionSemigroup[K comparable, V any](s S.Semigroup[V]) S.Semigroup[map[K]V] {
 	return G.UnionSemigroup[map[K]V](s)
 }
+
+func UnionLastSemigroup[K comparable, V any]() S.Semigroup[map[K]V] {
+	return G.UnionLastSemigroup[map[K]V]()
+}
+
+func UnionFirstSemigroup[K comparable, V any]() S.Semigroup[map[K]V] {
+	return G.UnionFirstSemigroup[map[K]V]()
+}

semigroup/semigroup.go

@@ -59,3 +59,8 @@ func First[A any]() Semigroup[A] {
 func Last[A any]() Semigroup[A] {
 	return MakeSemigroup(F.Second[A, A])
 }
+
+// ToMagma converts a semigroup to a magma
+func ToMagma[A any](s Semigroup[A]) M.Magma[A] {
+	return s
+}

tuple/gen.go

@@ -1,26 +1,13 @@
-// Copyright (c) 2023 IBM Corp.
-// All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:18.7141124 +0200 CEST m=+0.109464201
+// 2023-08-11 11:38:30.5947727 +0200 CEST m=+0.033600301
+
 package tuple
 
+
 import (
-	"encoding/json"
 	"fmt"
+	"encoding/json"
 	M "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/ord"	
 )
@@ -151,9 +138,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)
@@ -187,14 +172,10 @@ func (t Tuple1[T1]) MarshalJSON() ([]byte, error) {
 // 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
-	}
+  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 err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
   }
   return nil
 }
@@ -250,12 +231,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)
@@ -290,20 +267,13 @@ func (t Tuple2[T1, T2]) MarshalJSON() ([]byte, error) {
 // 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
-	}
+  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 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 err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
+  }}
   return nil
 }
 
@@ -360,15 +330,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)
@@ -404,25 +368,15 @@ func (t Tuple3[T1, T2, T3]) MarshalJSON() ([]byte, error) {
 // 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
-	}
+  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 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 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 err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
+  }}}
   return nil
 }
 
@@ -481,18 +435,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)
@@ -529,30 +475,17 @@ func (t Tuple4[T1, T2, T3, T4]) MarshalJSON() ([]byte, error) {
 // 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
-	}
+  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 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 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 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 err := json.Unmarshal(tmp[3], &t.F4); err != nil {return err}
+  }}}}
   return nil
 }
 
@@ -613,21 +546,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)
@@ -665,35 +588,19 @@ func (t Tuple5[T1, T2, T3, T4, T5]) MarshalJSON() ([]byte, error) {
 // 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
-	}
+  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 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 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 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 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 err := json.Unmarshal(tmp[4], &t.F5); err != nil {return err}
+  }}}}}
   return nil
 }
 
@@ -756,24 +663,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)
@@ -812,40 +707,21 @@ func (t Tuple6[T1, T2, T3, T4, T5, T6]) MarshalJSON() ([]byte, error) {
 // 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
-	}
+  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 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 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 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 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 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 err := json.Unmarshal(tmp[5], &t.F6); err != nil {return err}
+  }}}}}}
   return nil
 }
 
@@ -910,27 +786,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)
@@ -970,45 +832,23 @@ func (t Tuple7[T1, T2, T3, T4, T5, T6, T7]) MarshalJSON() ([]byte, error) {
 // 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
-	}
+  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 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 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 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 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 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 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 err := json.Unmarshal(tmp[6], &t.F7); err != nil {return err}
+  }}}}}}}
   return nil
 }
 
@@ -1075,30 +915,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)
@@ -1139,50 +963,25 @@ func (t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) MarshalJSON() ([]byte, error) {
 // 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
-	}
+  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 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 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 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 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 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 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 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 err := json.Unmarshal(tmp[7], &t.F8); err != nil {return err}
+  }}}}}}}}
   return nil
 }
 
@@ -1251,33 +1050,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)
@@ -1319,55 +1100,27 @@ func (t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) MarshalJSON() ([]byte, error
 // 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
-	}
+  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 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 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 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 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 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 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 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 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 err := json.Unmarshal(tmp[8], &t.F9); err != nil {return err}
+  }}}}}}}}}
   return nil
 }
 
@@ -1438,36 +1191,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)
@@ -1510,60 +1243,29 @@ func (t Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) MarshalJSON() ([]byte,
 // 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
-	}
+  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 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 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 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 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 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 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 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 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 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
-											}
-										}
-									}
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
+  if err := json.Unmarshal(tmp[9], &t.F10); err != nil {return err}
+  }}}}}}}}}}
   return nil
 }
 

writer/writer_test.go

@@ -31,7 +31,7 @@ func doubleAndLog(data int) Writer[[]string, int] {
 	}
 }
 
-func ExampleLoggingWriter() {
+func Example() {
 
 	m := A.Monoid[string]()
 	s := M.ToSemigroup(m)