+func Traverse[K comparable, A, B, HKTB, HKTAB, HKTRB any](
+ fof func(map[K]B) HKTRB,
+ fmap func(func(map[K]B) func(B) map[K]B) func(HKTRB) HKTAB,
+ fap func(HKTB) func(HKTAB) HKTRB,
+ f func(A) HKTB) func(map[K]A) HKTRB {
+ return G.Traverse[map[K]A](fof, fmap, fap, f)
+}
+
+// HKTA = HKT[A]
+// HKTAA = HKT[func(A)map[K]A]
+// HKTRA = HKT[map[K]A]
+func Sequence[K comparable, A, HKTA, HKTAA, HKTRA any](
+ fof func(map[K]A) HKTRA,
+ fmap func(func(map[K]A) func(A) map[K]A) func(HKTRA) HKTAA,
+ fap func(HKTA) func(HKTAA) HKTRA,
+ ma map[K]HKTA) HKTRA {
+ return G.Sequence(fof, fmap, fap, ma)
+
+}
diff --git a/v2/record/traverse_test.go b/v2/record/traverse_test.go
new file mode 100644
index 0000000..df8ebc6
--- /dev/null
+++ b/v2/record/traverse_test.go
@@ -0,0 +1,90 @@
+// Copyright (c) 2023 - 2025 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
+
+import (
+ "testing"
+
+ F "github.com/IBM/fp-go/v2/function"
+ O "github.com/IBM/fp-go/v2/option"
+ "github.com/stretchr/testify/assert"
+)
+
+type MapType = map[string]int
+type MapTypeString = map[string]string
+type MapTypeO = map[string]O.Option[int]
+
+func TestSimpleTraversalWithIndex(t *testing.T) {
+
+ f := func(k string, n int) O.Option[int] {
+ if k != "a" {
+ return O.Some(n)
+ }
+ return O.None[int]()
+ }
+
+ tWithIndex := TraverseWithIndex(
+ O.Of[MapType],
+ O.Map[MapType, func(int) MapType],
+ O.Ap[MapType, int],
+ f)
+
+ assert.Equal(t, O.None[MapType](), F.Pipe1(MapType{"a": 1, "b": 2}, tWithIndex))
+ assert.Equal(t, O.Some(MapType{"b": 2}), F.Pipe1(MapType{"b": 2}, tWithIndex))
+}
+
+func TestSimpleTraversalNoIndex(t *testing.T) {
+
+ f := func(k string) O.Option[string] {
+ if k != "1" {
+ return O.Some(k)
+ }
+ return O.None[string]()
+ }
+
+ tWithoutIndex := Traverse(
+ O.Of[MapTypeString],
+ O.Map[MapTypeString, func(string) MapTypeString],
+ O.Ap[MapTypeString, string],
+ f)
+
+ assert.Equal(t, O.None[MapTypeString](), F.Pipe1(MapTypeString{"a": "1", "b": "2"}, tWithoutIndex))
+ assert.Equal(t, O.Some(MapTypeString{"b": "2"}), F.Pipe1(MapTypeString{"b": "2"}, tWithoutIndex))
+}
+
+func TestSequence(t *testing.T) {
+ // source map
+ simpleMapO := MapTypeO{"a": O.Of(1), "b": O.Of(2)}
+ // convert to an option of record
+
+ s := Traverse(
+ O.Of[MapType],
+ O.Map[MapType, func(int) MapType],
+ O.Ap[MapType, int],
+ F.Identity[O.Option[int]],
+ )
+
+ assert.Equal(t, O.Of(MapType{"a": 1, "b": 2}), F.Pipe1(simpleMapO, s))
+
+ s1 := Sequence(
+ O.Of[MapType],
+ O.Map[MapType, func(int) MapType],
+ O.Ap[MapType, int],
+ simpleMapO,
+ )
+
+ assert.Equal(t, O.Of(MapType{"a": 1, "b": 2}), s1)
+}
diff --git a/v2/reflect/generic/reflect.go b/v2/reflect/generic/reflect.go
new file mode 100644
index 0000000..1d80132
--- /dev/null
+++ b/v2/reflect/generic/reflect.go
@@ -0,0 +1,31 @@
+// Copyright (c) 2023 - 2025 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
+
+import (
+ R "reflect"
+)
+
+func Map[GA ~[]A, A any](f func(R.Value) A) func(R.Value) GA {
+ return func(val R.Value) GA {
+ l := val.Len()
+ res := make(GA, l)
+ for i := l - 1; i >= 0; i-- {
+ res[i] = f(val.Index(i))
+ }
+ return res
+ }
+}
diff --git a/v2/reflect/reflect.go b/v2/reflect/reflect.go
new file mode 100644
index 0000000..487a801
--- /dev/null
+++ b/v2/reflect/reflect.go
@@ -0,0 +1,42 @@
+// Copyright (c) 2023 - 2025 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 option
+
+import (
+ R "reflect"
+
+ F "github.com/IBM/fp-go/v2/function"
+ G "github.com/IBM/fp-go/v2/reflect/generic"
+)
+
+func ReduceWithIndex[A any](f func(int, A, R.Value) A, initial A) func(R.Value) A {
+ return func(val R.Value) A {
+ count := val.Len()
+ current := initial
+ for i := 0; i < count; i++ {
+ current = f(i, current, val.Index(i))
+ }
+ return current
+ }
+}
+
+func Reduce[A any](f func(A, R.Value) A, initial A) func(R.Value) A {
+ return ReduceWithIndex(F.Ignore1of3[int](f), initial)
+}
+
+func Map[A any](f func(R.Value) A) func(R.Value) []A {
+ return G.Map[[]A](f)
+}
diff --git a/v2/resources/images/logo.png b/v2/resources/images/logo.png
new file mode 100644
index 0000000..f0242f5
Binary files /dev/null and b/v2/resources/images/logo.png differ
diff --git a/v2/retry/generic/retry.go b/v2/retry/generic/retry.go
new file mode 100644
index 0000000..236bbbd
--- /dev/null
+++ b/v2/retry/generic/retry.go
@@ -0,0 +1,102 @@
+// Copyright (c) 2023 - 2025 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
+
+import (
+ "time"
+
+ F "github.com/IBM/fp-go/v2/function"
+ O "github.com/IBM/fp-go/v2/option"
+ R "github.com/IBM/fp-go/v2/retry"
+)
+
+// Apply policy and delay by its amount if it results in a R.
+// Returns updated status.
+// HKTSTATUS = HKT
+func applyAndDelay[HKTSTATUS any](
+ monadOf func(R.RetryStatus) HKTSTATUS,
+ monadDelay func(time.Duration) func(HKTSTATUS) HKTSTATUS,
+) func(policy R.RetryPolicy, status R.RetryStatus) HKTSTATUS {
+ return func(policy R.RetryPolicy, status R.RetryStatus) HKTSTATUS {
+ newStatus := R.ApplyPolicy(policy, status)
+ return F.Pipe1(
+ newStatus.PreviousDelay,
+ O.Fold(
+ F.Nullary2(F.Constant(newStatus), monadOf),
+ func(delay time.Duration) HKTSTATUS {
+ return monadDelay(delay)(monadOf(newStatus))
+ },
+ ),
+ )
+ }
+}
+
+// Retry combinator for actions that don't raise exceptions, but
+// signal in their type the outcome has failed. Examples are the
+// `Option`, `Either` and `EitherT` monads.
+//
+// policy - refers to the retry policy
+// action - converts a status into an operation to be executed
+// check - checks if the result of the action needs to be retried
+func Retrying[HKTA, HKTSTATUS, A any](
+ monadChain func(func(A) HKTA) func(HKTA) HKTA,
+ monadChainStatus func(func(R.RetryStatus) HKTA) func(HKTSTATUS) HKTA,
+ monadOf func(A) HKTA,
+ monadOfStatus func(R.RetryStatus) HKTSTATUS,
+ monadDelay func(time.Duration) func(HKTSTATUS) HKTSTATUS,
+
+ policy R.RetryPolicy,
+ action func(R.RetryStatus) HKTA,
+ check func(A) bool,
+) HKTA {
+ // delay callback
+ applyDelay := applyAndDelay(monadOfStatus, monadDelay)
+
+ // function to check if we need to retry or not
+ checkForRetry := O.FromPredicate(check)
+
+ var f func(status R.RetryStatus) HKTA
+
+ // need some lazy init because we reference it in the chain
+ f = func(status R.RetryStatus) HKTA {
+ return F.Pipe2(
+ status,
+ action,
+ monadChain(func(a A) HKTA {
+ return F.Pipe3(
+ a,
+ checkForRetry,
+ O.Map(func(a A) HKTA {
+ return F.Pipe1(
+ applyDelay(policy, status),
+ monadChainStatus(func(status R.RetryStatus) HKTA {
+ return F.Pipe1(
+ status.PreviousDelay,
+ O.Fold(F.Constant(monadOf(a)), func(_ time.Duration) HKTA {
+ return f(status)
+ }),
+ )
+ }),
+ )
+ }),
+ O.GetOrElse(F.Constant(monadOf(a))),
+ )
+ }),
+ )
+ }
+ // seed
+ return f(R.DefaultRetryStatus)
+}
diff --git a/v2/retry/retry.go b/v2/retry/retry.go
new file mode 100644
index 0000000..dea6dde
--- /dev/null
+++ b/v2/retry/retry.go
@@ -0,0 +1,121 @@
+// Copyright (c) 2023 - 2025 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 retry
+
+import (
+ "math"
+ "time"
+
+ F "github.com/IBM/fp-go/v2/function"
+ M "github.com/IBM/fp-go/v2/monoid"
+ O "github.com/IBM/fp-go/v2/option"
+ "github.com/IBM/fp-go/v2/ord"
+)
+
+type RetryStatus struct {
+ // Iteration number, where `0` is the first try
+ IterNumber uint
+ // Delay incurred so far from retries
+ CumulativeDelay time.Duration
+ // Latest attempt's delay. Will always be `none` on first run.
+ PreviousDelay Option[time.Duration]
+}
+
+// RetryPolicy is a function that takes an `RetryStatus` and
+// possibly returns a delay in milliseconds. Iteration numbers start
+// at zero and increase by one on each retry. A //None// return value from
+// the function implies we have reached the retry limit.
+type RetryPolicy = func(RetryStatus) Option[time.Duration]
+
+const emptyDuration = time.Duration(0)
+
+var ordDuration = ord.FromStrictCompare[time.Duration]()
+
+// Monoid 'RetryPolicy' is a 'Monoid'. You can collapse multiple strategies into one using 'concat'.
+// The semantics of this combination are as follows:
+//
+// 1. If either policy returns 'None', the combined policy returns
+// 'None'. This can be used to inhibit after a number of retries,
+// for example.
+//
+// 2. If both policies return a delay, the larger delay will be used.
+// This is quite natural when combining multiple policies to achieve a
+// certain effect.
+var Monoid = M.FunctionMonoid[RetryStatus](O.ApplicativeMonoid(M.MakeMonoid(
+ ord.MaxSemigroup(ordDuration).Concat, emptyDuration)))
+
+// LimitRetries retries immediately, but only up to `i` times.
+func LimitRetries(i uint) RetryPolicy {
+ pred := func(value uint) bool {
+ return value < i
+ }
+ empty := F.Constant1[uint](emptyDuration)
+ return func(status RetryStatus) Option[time.Duration] {
+ return F.Pipe2(
+ status.IterNumber,
+ O.FromPredicate(pred),
+ O.Map(empty),
+ )
+ }
+}
+
+// ConstantDelay delays with unlimited retries
+func ConstantDelay(delay time.Duration) RetryPolicy {
+ return F.Constant1[RetryStatus](O.Of(delay))
+}
+
+// CapDelay sets a time-upperbound for any delays that may be directed by the
+// given policy. This function does not terminate the retrying. The policy
+// capDelay(maxDelay, exponentialBackoff(n))` will never stop retrying. It
+// will reach a state where it retries forever with a delay of `maxDelay`
+// between each one. To get termination you need to use one of the
+// 'limitRetries' function variants.
+func CapDelay(maxDelay time.Duration, policy RetryPolicy) RetryPolicy {
+ return F.Flow2(
+ policy,
+ O.Map(F.Bind1st(ord.Min(ordDuration), maxDelay)),
+ )
+}
+
+// ExponentialBackoff grows delay exponentially each iteration.
+// Each delay will increase by a factor of two.
+func ExponentialBackoff(delay time.Duration) RetryPolicy {
+ return func(status RetryStatus) Option[time.Duration] {
+ return O.Some(delay * time.Duration(math.Pow(2, float64(status.IterNumber))))
+ }
+}
+
+// DefaultRetryStatus is the default retry status. Exported mostly to allow user code
+// to test their handlers and retry policies.
+var DefaultRetryStatus = RetryStatus{
+ IterNumber: 0,
+ CumulativeDelay: 0,
+ PreviousDelay: O.None[time.Duration](),
+}
+
+var getOrElseDelay = O.GetOrElse(F.Constant(emptyDuration))
+
+/**
+ * Apply policy on status to see what the decision would be.
+ */
+func ApplyPolicy(policy RetryPolicy, status RetryStatus) RetryStatus {
+ previousDelay := policy(status)
+ return RetryStatus{
+ IterNumber: status.IterNumber + 1,
+ CumulativeDelay: status.CumulativeDelay + getOrElseDelay(previousDelay),
+ PreviousDelay: previousDelay,
+ }
+}
diff --git a/v2/retry/types.go b/v2/retry/types.go
new file mode 100644
index 0000000..8f755a0
--- /dev/null
+++ b/v2/retry/types.go
@@ -0,0 +1,22 @@
+// Copyright (c) 2023 - 2025 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 retry
+
+import "github.com/IBM/fp-go/v2/option"
+
+type (
+ Option[A any] = option.Option[A]
+)
diff --git a/v2/samples/README.md b/v2/samples/README.md
new file mode 100644
index 0000000..fdff004
--- /dev/null
+++ b/v2/samples/README.md
@@ -0,0 +1,14 @@
+# Samples
+
+This folder is meant to contain examples that illustrate how to use the library. I recommend the following reading to get an idea of the underlying concepts. These articles talk about [fp-ts](https://github.com/gcanti/fp-ts) but the concepts are very similar, only syntax differs.
+
+# Video Introduction
+
+[](https://www.youtube.com/watch?v=Jif3jL6DRdw "introduction to fp-go")
+
+### References
+
+- [Ryan's Blog](https://rlee.dev/practical-guide-to-fp-ts-part-1) - practical introduction into FP concepts
+- [Investigate Functional Programming Concepts in Go](https://betterprogramming.pub/investigate-functional-programming-concepts-in-go-1dada09bc913) - discussion around FP concepts in golang
+- [Investigating the I/O Monad in Go](https://medium.com/better-programming/investigating-the-i-o-monad-in-go-3c0fabbb4b3d) - a closer look at I/O monads in golang
+-
\ No newline at end of file
diff --git a/v2/samples/doc_test.go b/v2/samples/doc_test.go
new file mode 100644
index 0000000..dffb948
--- /dev/null
+++ b/v2/samples/doc_test.go
@@ -0,0 +1,17 @@
+// Copyright (c) 2023 - 2025 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 sample contains examples that illustrate how to use fp-go
+package samples
diff --git a/v2/samples/getting-started-with-fp-ts/reader/example1/reader_test.go b/v2/samples/getting-started-with-fp-ts/reader/example1/reader_test.go
new file mode 100644
index 0000000..5a3a6b5
--- /dev/null
+++ b/v2/samples/getting-started-with-fp-ts/reader/example1/reader_test.go
@@ -0,0 +1,75 @@
+// Copyright (c) 2023 - 2025 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 example1 implements the first example in [https://dev.to/gcanti/getting-started-with-fp-ts-reader-1ie5]
+package example1
+
+import (
+ "fmt"
+
+ F "github.com/IBM/fp-go/v2/function"
+ N "github.com/IBM/fp-go/v2/number"
+ I "github.com/IBM/fp-go/v2/number/integer"
+ "github.com/IBM/fp-go/v2/ord"
+ R "github.com/IBM/fp-go/v2/reader"
+ S "github.com/IBM/fp-go/v2/string"
+)
+
+type (
+ I18n struct {
+ True string
+ False string
+ }
+
+ Dependencies struct {
+ I18n I18n
+ }
+)
+
+var (
+ // g: func(int) R.Reader[*Dependencies, string], note how the implementation does not depend on the dependencies
+ g = F.Flow2(
+ ord.Gt(I.Ord)(2),
+ f,
+ )
+
+ // h: func(string) R.Reader[*Dependencies, string], note how the implementation does not depend on the dependencies
+ h = F.Flow3(
+ S.Size,
+ N.Add(1),
+ g,
+ )
+)
+
+func f(b bool) R.Reader[*Dependencies, string] {
+ return func(deps *Dependencies) string {
+ if b {
+ return deps.I18n.True
+ }
+ return deps.I18n.False
+ }
+}
+
+func ExampleReader() {
+
+ deps := Dependencies{I18n: I18n{True: "vero", False: "falso"}}
+
+ fmt.Println(h("foo")(&deps))
+ fmt.Println(h("a")(&deps))
+
+ // Output:
+ // vero
+ // falso
+}
diff --git a/v2/samples/getting-started-with-fp-ts/reader/example2/reader_test.go b/v2/samples/getting-started-with-fp-ts/reader/example2/reader_test.go
new file mode 100644
index 0000000..1c6ba8c
--- /dev/null
+++ b/v2/samples/getting-started-with-fp-ts/reader/example2/reader_test.go
@@ -0,0 +1,97 @@
+// Copyright (c) 2023 - 2025 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 example2 implements the second example in [https://dev.to/gcanti/getting-started-with-fp-ts-reader-1ie5]
+package example2
+
+import (
+ "fmt"
+
+ F "github.com/IBM/fp-go/v2/function"
+ ID "github.com/IBM/fp-go/v2/identity"
+ N "github.com/IBM/fp-go/v2/number"
+ I "github.com/IBM/fp-go/v2/number/integer"
+ "github.com/IBM/fp-go/v2/ord"
+ R "github.com/IBM/fp-go/v2/reader"
+ S "github.com/IBM/fp-go/v2/string"
+)
+
+type (
+ I18n struct {
+ True string
+ False string
+ }
+
+ Dependencies struct {
+ I18n I18n
+ LowerBound int
+ }
+)
+
+var (
+ // h: func(string) R.Reader[*Dependencies, string], note how the implementation does not depend on the dependencies
+ h = F.Flow3(
+ S.Size,
+ N.Add(1),
+ g,
+ )
+)
+
+func getLowerBound(deps *Dependencies) int {
+ return deps.LowerBound
+}
+
+func g(n int) R.Reader[*Dependencies, string] {
+ return F.Pipe1(
+ R.Ask[*Dependencies](),
+ R.Chain(F.Flow4(
+ getLowerBound,
+ ord.Gt(I.Ord),
+ ID.Flap[bool](n),
+ f,
+ )),
+ )
+}
+
+func f(b bool) R.Reader[*Dependencies, string] {
+ return func(deps *Dependencies) string {
+ if b {
+ return deps.I18n.True
+ }
+ return deps.I18n.False
+ }
+}
+
+func ExampleReader() {
+
+ deps1 := Dependencies{I18n: I18n{True: "vero", False: "falso"}, LowerBound: 2}
+
+ hFoo := h("foo")
+ hA := h("a")
+
+ fmt.Println(hFoo(&deps1))
+ fmt.Println(hA(&deps1))
+
+ deps2 := Dependencies{I18n: I18n{True: "vero", False: "falso"}, LowerBound: 4}
+
+ fmt.Println(hFoo(&deps2))
+ fmt.Println(hA(&deps2))
+
+ // Output:
+ // vero
+ // falso
+ // falso
+ // falso
+}
diff --git a/v2/samples/http/http_test.go b/v2/samples/http/http_test.go
new file mode 100644
index 0000000..453bc29
--- /dev/null
+++ b/v2/samples/http/http_test.go
@@ -0,0 +1,113 @@
+// Copyright (c) 2023 - 2025 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 http
+
+import (
+ "context"
+ "fmt"
+ "testing"
+
+ HTTP "net/http"
+
+ A "github.com/IBM/fp-go/v2/array"
+ R "github.com/IBM/fp-go/v2/context/readerioeither"
+ H "github.com/IBM/fp-go/v2/context/readerioeither/http"
+ E "github.com/IBM/fp-go/v2/either"
+ F "github.com/IBM/fp-go/v2/function"
+ IO "github.com/IBM/fp-go/v2/io"
+ T "github.com/IBM/fp-go/v2/tuple"
+ "github.com/stretchr/testify/assert"
+)
+
+type PostItem struct {
+ UserID uint `json:"userId"`
+ ID uint `json:"id"`
+ Title string `json:"title"`
+ Body string `json:"body"`
+}
+
+type CatFact struct {
+ Fact string `json:"fact"`
+}
+
+func idxToURL(idx int) string {
+ return fmt.Sprintf("https://jsonplaceholder.typicode.com/posts/%d", idx+1)
+}
+
+// TestMultipleHttpRequests shows how to execute multiple HTTP requests in parallel assuming
+// that the response structure of all requests is identical, which is why we can use [R.TraverseArray]
+func TestMultipleHttpRequests(t *testing.T) {
+ // prepare the http client
+ client := H.MakeClient(HTTP.DefaultClient)
+ // readSinglePost sends a GET request and parses the response as [PostItem]
+ readSinglePost := H.ReadJSON[PostItem](client)
+
+ // total number of http requests
+ count := 10
+
+ data := F.Pipe3(
+ A.MakeBy(count, idxToURL),
+ R.TraverseArray(F.Flow3(
+ H.MakeGetRequest,
+ readSinglePost,
+ R.ChainFirstIOK(IO.Logf[PostItem]("Log Single: %v")),
+ )),
+ R.ChainFirstIOK(IO.Logf[[]PostItem]("Log Result: %v")),
+ R.Map(A.Size[PostItem]),
+ )
+
+ result := data(context.Background())
+
+ assert.Equal(t, E.Of[error](count), result())
+}
+
+func heterogeneousHTTPRequests() ReaderIOEither[T.Tuple2[PostItem, CatFact]] {
+ // prepare the http client
+ client := H.MakeClient(HTTP.DefaultClient)
+ // readSinglePost sends a GET request and parses the response as [PostItem]
+ readSinglePost := H.ReadJSON[PostItem](client)
+ // readSingleCatFact sends a GET request and parses the response as [CatFact]
+ readSingleCatFact := H.ReadJSON[CatFact](client)
+
+ return F.Pipe3(
+ T.MakeTuple2("https://jsonplaceholder.typicode.com/posts/1", "https://catfact.ninja/fact"),
+ T.Map2(H.MakeGetRequest, H.MakeGetRequest),
+ R.TraverseTuple2(
+ readSinglePost,
+ readSingleCatFact,
+ ),
+ R.ChainFirstIOK(IO.Logf[T.Tuple2[PostItem, CatFact]]("Log Result: %v")),
+ )
+
+}
+
+// TestHeterogeneousHttpRequests shows how to execute multiple HTTP requests in parallel when
+// the response structure of these requests is different. We use [R.TraverseTuple2] to account for the different types
+func TestHeterogeneousHttpRequests(t *testing.T) {
+ data := heterogeneousHTTPRequests()
+
+ result := data(context.Background())
+
+ fmt.Println(result())
+}
+
+// BenchmarkHeterogeneousHttpRequests shows how to execute multiple HTTP requests in parallel when
+// the response structure of these requests is different. We use [R.TraverseTuple2] to account for the different types
+func BenchmarkHeterogeneousHttpRequests(b *testing.B) {
+ for n := 0; n < b.N; n++ {
+ heterogeneousHTTPRequests()(context.Background())()
+ }
+}
diff --git a/v2/samples/http/types.go b/v2/samples/http/types.go
new file mode 100644
index 0000000..6418963
--- /dev/null
+++ b/v2/samples/http/types.go
@@ -0,0 +1,24 @@
+// Copyright (c) 2023 - 2025 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 http
+
+import (
+ "github.com/IBM/fp-go/v2/context/readerioeither"
+)
+
+type (
+ ReaderIOEither[A any] = readerioeither.ReaderIOEither[A]
+)
diff --git a/v2/samples/match/examples_match_test.go b/v2/samples/match/examples_match_test.go
new file mode 100644
index 0000000..6858247
--- /dev/null
+++ b/v2/samples/match/examples_match_test.go
@@ -0,0 +1,65 @@
+// Copyright (c) 2023 - 2025 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 match
+
+import (
+ "fmt"
+
+ E "github.com/IBM/fp-go/v2/either"
+ "github.com/IBM/fp-go/v2/errors"
+ F "github.com/IBM/fp-go/v2/function"
+ O "github.com/IBM/fp-go/v2/option"
+ S "github.com/IBM/fp-go/v2/string"
+)
+
+type Thing struct {
+ Name string
+}
+
+func (t Thing) GetName() string {
+ return t.Name
+}
+
+var (
+ // func(Thing) Either[error, string]
+ getName = F.Flow2(
+ Thing.GetName,
+ E.FromPredicate(S.IsNonEmpty, errors.OnSome[string]("value [%s] is empty")),
+ )
+
+ // func(option.Option[Thing]) Either[error, string]
+ GetName = F.Flow2(
+ E.FromOption[Thing](errors.OnNone("value is none")),
+ E.Chain(getName),
+ )
+)
+
+func ExampleEither_match() {
+
+ oThing := O.Of(Thing{"Carsten"})
+
+ res := F.Pipe2(
+ oThing,
+ GetName,
+ E.Fold(S.Format[error]("failed with error %v"), S.Format[string]("get value %s")),
+ )
+
+ fmt.Println(res)
+
+ // Output:
+ // get value Carsten
+
+}
diff --git a/v2/samples/mostly-adequate/README.md b/v2/samples/mostly-adequate/README.md
new file mode 100644
index 0000000..caf7b84
--- /dev/null
+++ b/v2/samples/mostly-adequate/README.md
@@ -0,0 +1,6 @@
+# Mostly Adequate: fp-go Companion Guide
+
+This resource is meant to serve as a go "companion" resource to Professor [Frisby's Mostly Adequate Guide](https://github.com/MostlyAdequate/mostly-adequate-guide).
+
+It is a port of the [mostly-adequate-fp-ts](https://github.com/ChuckJonas/mostly-adequate-fp-ts/) book.
+
diff --git a/v2/samples/mostly-adequate/chapter01_test.go b/v2/samples/mostly-adequate/chapter01_test.go
new file mode 100644
index 0000000..ae1da6a
--- /dev/null
+++ b/v2/samples/mostly-adequate/chapter01_test.go
@@ -0,0 +1,47 @@
+// Copyright (c) 2023 - 2025 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 mostlyadequate
+
+import "fmt"
+
+type Flock struct {
+ Seagulls int
+}
+
+func MakeFlock(n int) Flock {
+ return Flock{Seagulls: n}
+}
+
+func (f *Flock) Conjoin(other *Flock) *Flock {
+ f.Seagulls += other.Seagulls
+ return f
+}
+
+func (f *Flock) Breed(other *Flock) *Flock {
+ f.Seagulls = f.Seagulls * other.Seagulls
+ return f
+}
+
+func Example_flock() {
+
+ flockA := MakeFlock(4)
+ flockB := MakeFlock(2)
+ flockC := MakeFlock(0)
+
+ fmt.Println(flockA.Conjoin(&flockC).Breed(&flockB).Conjoin(flockA.Breed(&flockB)).Seagulls)
+
+ // Output: 32
+}
diff --git a/v2/samples/mostly-adequate/chapter02_firstclassfunctions_test.go b/v2/samples/mostly-adequate/chapter02_firstclassfunctions_test.go
new file mode 100644
index 0000000..7d04ef2
--- /dev/null
+++ b/v2/samples/mostly-adequate/chapter02_firstclassfunctions_test.go
@@ -0,0 +1,38 @@
+// Copyright (c) 2023 - 2025 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 mostlyadequate
+
+import "fmt"
+
+func Hi(name string) string {
+ return fmt.Sprintf("Hi %s", name)
+}
+
+func Greeting(name string) string {
+ return Hi(name)
+}
+
+func Example_greeting() {
+ // functions are first class objects
+ greet := Hi
+
+ fmt.Println(Greeting("times"))
+ fmt.Println(greet("times"))
+
+ // Output:
+ // Hi times
+ // Hi times
+}
diff --git a/v2/samples/mostly-adequate/chapter04_currying_test.go b/v2/samples/mostly-adequate/chapter04_currying_test.go
new file mode 100644
index 0000000..57d5557
--- /dev/null
+++ b/v2/samples/mostly-adequate/chapter04_currying_test.go
@@ -0,0 +1,83 @@
+// Copyright (c) 2023 - 2025 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 mostlyadequate
+
+import (
+ "fmt"
+ "math"
+ "regexp"
+ "strings"
+
+ A "github.com/IBM/fp-go/v2/array"
+ F "github.com/IBM/fp-go/v2/function"
+ N "github.com/IBM/fp-go/v2/number"
+ I "github.com/IBM/fp-go/v2/number/integer"
+ S "github.com/IBM/fp-go/v2/string"
+)
+
+var (
+ Match = F.Curry2((*regexp.Regexp).FindStringSubmatch)
+ Matches = F.Curry2((*regexp.Regexp).MatchString)
+ Split = F.Curry2(F.Bind3of3((*regexp.Regexp).Split)(-1))
+
+ Add = N.Add[int]
+ ToString = I.ToString
+ ToLower = strings.ToLower
+ ToUpper = strings.ToUpper
+ Concat = F.Curry2(S.Monoid.Concat)
+)
+
+// Replace cannot be generated via [F.Curry3] because the order of parameters does not match our desired curried order
+func Replace(search *regexp.Regexp) func(replace string) func(s string) string {
+ return func(replace string) func(s string) string {
+ return func(s string) string {
+ return search.ReplaceAllString(s, replace)
+ }
+ }
+}
+
+func Example_solution04A() {
+ // words :: String -> [String]
+ words := Split(regexp.MustCompile(` `))
+
+ fmt.Println(words("Jingle bells Batman smells"))
+
+ // Output:
+ // [Jingle bells Batman smells]
+}
+
+func Example_solution04B() {
+ // filterQs :: [String] -> [String]
+ filterQs := A.Filter(Matches(regexp.MustCompile(`q`)))
+
+ fmt.Println(filterQs(A.From("quick", "camels", "quarry", "over", "quails")))
+
+ // Output:
+ // [quick quarry quails]
+}
+
+func Example_solution04C() {
+
+ keepHighest := N.Max[int]
+
+ // max :: [Number] -> Number
+ max := A.Reduce(keepHighest, math.MinInt)
+
+ fmt.Println(max(A.From(323, 523, 554, 123, 5234)))
+
+ // Output:
+ // 5234
+}
diff --git a/v2/samples/mostly-adequate/chapter05_composing_test.go b/v2/samples/mostly-adequate/chapter05_composing_test.go
new file mode 100644
index 0000000..61837d2
--- /dev/null
+++ b/v2/samples/mostly-adequate/chapter05_composing_test.go
@@ -0,0 +1,110 @@
+// Copyright (c) 2023 - 2025 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 mostlyadequate
+
+import (
+ "fmt"
+ "regexp"
+
+ A "github.com/IBM/fp-go/v2/array"
+ F "github.com/IBM/fp-go/v2/function"
+ I "github.com/IBM/fp-go/v2/number/integer"
+ O "github.com/IBM/fp-go/v2/option"
+ "github.com/IBM/fp-go/v2/ord"
+ S "github.com/IBM/fp-go/v2/string"
+)
+
+var (
+ Exclaim = S.Format[string]("%s!")
+ Shout = F.Flow2(ToUpper, Exclaim)
+ Dasherize = F.Flow4(
+ Replace(regexp.MustCompile(`\s{2,}`))(" "),
+ Split(regexp.MustCompile(` `)),
+ A.Map(ToLower),
+ A.Intercalate(S.Monoid)("-"),
+ )
+)
+
+func Example_shout() {
+ fmt.Println(Shout("send in the clowns"))
+
+ // Output: SEND IN THE CLOWNS!
+}
+
+func Example_dasherize() {
+ fmt.Println(Dasherize("The world is a vampire"))
+
+ // Output: the-world-is-a-vampire
+}
+
+func Example_pipe() {
+ output := F.Pipe2(
+ "send in the clowns",
+ ToUpper,
+ Exclaim,
+ )
+
+ fmt.Println(output)
+
+ // Output: SEND IN THE CLOWNS!
+}
+
+func Example_solution05A() {
+ IsLastInStock := F.Flow2(
+ A.Last[Car],
+ O.Map(Car.getInStock),
+ )
+
+ fmt.Println(IsLastInStock(Cars[0:3]))
+ fmt.Println(IsLastInStock(Cars[3:]))
+
+ // Output:
+ // Some[bool](true)
+ // Some[bool](false)
+}
+
+func Example_solution05B() {
+ // averageDollarValue :: [Car] -> Int
+ averageDollarValue := F.Flow2(
+ A.Map(Car.getDollarValue),
+ average,
+ )
+
+ fmt.Println(averageDollarValue(Cars))
+
+ // Output:
+ // 790700
+}
+
+func Example_solution05C() {
+ // order by horsepower
+ ordByHorsepower := ord.Contramap(Car.getHorsepower)(I.Ord)
+
+ // fastestCar :: [Car] -> Option[String]
+ fastestCar := F.Flow3(
+ A.Sort(ordByHorsepower),
+ A.Last[Car],
+ O.Map(F.Flow2(
+ Car.getName,
+ S.Format[string]("%s is the fastest"),
+ )),
+ )
+
+ fmt.Println(fastestCar(Cars))
+
+ // Output:
+ // Some[string](Aston Martin One-77 is the fastest)
+}
diff --git a/v2/samples/mostly-adequate/chapter06_exampleapplication_test.go b/v2/samples/mostly-adequate/chapter06_exampleapplication_test.go
new file mode 100644
index 0000000..713c1f9
--- /dev/null
+++ b/v2/samples/mostly-adequate/chapter06_exampleapplication_test.go
@@ -0,0 +1,115 @@
+// Copyright (c) 2023 - 2025 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 mostlyadequate
+
+import (
+ "context"
+ "fmt"
+ "net/http"
+ "regexp"
+
+ A "github.com/IBM/fp-go/v2/array"
+ E "github.com/IBM/fp-go/v2/either"
+ F "github.com/IBM/fp-go/v2/function"
+ J "github.com/IBM/fp-go/v2/json"
+ S "github.com/IBM/fp-go/v2/string"
+
+ R "github.com/IBM/fp-go/v2/context/readerioeither"
+ H "github.com/IBM/fp-go/v2/context/readerioeither/http"
+)
+
+type (
+ FlickrMedia struct {
+ Link string `json:"m"`
+ }
+
+ FlickrItem struct {
+ Media FlickrMedia `json:"media"`
+ }
+
+ FlickrFeed struct {
+ Items []FlickrItem `json:"items"`
+ }
+)
+
+func (f FlickrMedia) getLink() string {
+ return f.Link
+}
+
+func (f FlickrItem) getMedia() FlickrMedia {
+ return f.Media
+}
+
+func (f FlickrFeed) getItems() []FlickrItem {
+ return f.Items
+}
+
+func Example_application() {
+ // pure
+ host := "api.flickr.com"
+ path := "/services/feeds/photos_public.gne"
+ query := S.Format[string]("?tags=%s&format=json&jsoncallback=?")
+ url := F.Flow2(
+ query,
+ S.Format[string](fmt.Sprintf("https://%s%s%%s", host, path)),
+ )
+ // flick returns jsonP, we extract the JSON body, this is handled by jquery in the original code
+ sanitizeJSONP := Replace(regexp.MustCompile(`(?s)^\s*\((.*)\)\s*$`))("$1")
+ // parse jsonP
+ parseJSONP := F.Flow3(
+ sanitizeJSONP,
+ S.ToBytes,
+ J.Unmarshal[FlickrFeed],
+ )
+ // markup
+ img := S.Format[string]("
")
+ // lenses
+ mediaURL := F.Flow2(
+ FlickrItem.getMedia,
+ FlickrMedia.getLink,
+ )
+ mediaURLs := F.Flow2(
+ FlickrFeed.getItems,
+ A.Map(mediaURL),
+ )
+ images := F.Flow2(
+ mediaURLs,
+ A.Map(img),
+ )
+
+ client := H.MakeClient(http.DefaultClient)
+
+ // func(string) R.ReaderIOEither[[]string]
+ app := F.Flow5(
+ url,
+ H.MakeGetRequest,
+ H.ReadText(client),
+ R.ChainEitherK(parseJSONP),
+ R.Map(images),
+ )
+
+ // R.ReaderIOEither[[]string]
+ // this is the managed effect that can be called to download and render the images
+ catImageEffect := app("cats")
+
+ // impure, actually executes the effect
+ catImages := catImageEffect(context.TODO())()
+ fmt.Println(E.IsRight(catImages))
+
+ // Output:
+ // true
+
+}
diff --git a/v2/samples/mostly-adequate/chapter08_tupperware_test.go b/v2/samples/mostly-adequate/chapter08_tupperware_test.go
new file mode 100644
index 0000000..0ef9c31
--- /dev/null
+++ b/v2/samples/mostly-adequate/chapter08_tupperware_test.go
@@ -0,0 +1,276 @@
+// Copyright (c) 2023 - 2025 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 mostlyadequate
+
+import (
+ "fmt"
+ "time"
+
+ A "github.com/IBM/fp-go/v2/array"
+ E "github.com/IBM/fp-go/v2/either"
+ "github.com/IBM/fp-go/v2/errors"
+ F "github.com/IBM/fp-go/v2/function"
+ I "github.com/IBM/fp-go/v2/identity"
+ IOE "github.com/IBM/fp-go/v2/ioeither"
+ N "github.com/IBM/fp-go/v2/number"
+ O "github.com/IBM/fp-go/v2/option"
+ "github.com/IBM/fp-go/v2/ord"
+ S "github.com/IBM/fp-go/v2/string"
+)
+
+type Account struct {
+ Balance float32
+}
+
+func MakeAccount(b float32) Account {
+ return Account{Balance: b}
+}
+
+func getBalance(a Account) float32 {
+ return a.Balance
+}
+
+type (
+ Chapter08User struct {
+ Id int
+ Name string
+ Active bool
+ Saved bool
+ }
+)
+
+var (
+ albert08 = Chapter08User{
+ Id: 1,
+ Active: true,
+ Name: "Albert",
+ }
+
+ gary08 = Chapter08User{
+ Id: 2,
+ Active: false,
+ Name: "Gary",
+ }
+
+ theresa08 = Chapter08User{
+ Id: 3,
+ Active: true,
+ Name: "Theresa",
+ }
+
+ yi08 = Chapter08User{Id: 4, Name: "Yi", Active: true}
+)
+
+func (u Chapter08User) getName() string {
+ return u.Name
+}
+
+func (u Chapter08User) isActive() bool {
+ return u.Active
+}
+
+var (
+ ordFloat32 = ord.FromStrictCompare[float32]()
+ UpdateLedger = F.Identity[Account]
+ RemainingBalance = F.Flow2(
+ getBalance,
+ S.Format[float32]("Your balance is $%0.2f"),
+ )
+ FinishTransaction = F.Flow2(
+ UpdateLedger,
+ RemainingBalance,
+ )
+ getTwenty = F.Flow2(
+ Withdraw(20),
+ O.Fold(F.Constant("You're broke!"), FinishTransaction),
+ )
+
+ // showWelcome :: User -> String
+ showWelcome = F.Flow2(
+ Chapter08User.getName,
+ S.Format[string]("Welcome %s"),
+ )
+
+ // checkActive :: User -> Either error User
+ checkActive = E.FromPredicate(Chapter08User.isActive, F.Constant1[Chapter08User](fmt.Errorf("your account is not active")))
+
+ // validateUser :: (User -> Either String ()) -> User -> Either String User
+ validateUser = F.Curry2(func(validate func(Chapter08User) Either[any], user Chapter08User) Either[Chapter08User] {
+ return F.Pipe2(
+ user,
+ validate,
+ E.MapTo[error, any](user),
+ )
+ })
+
+ // save :: User -> IOEither error User
+ save = func(user Chapter08User) IOEither[Chapter08User] {
+ return IOE.FromIO[error](func() Chapter08User {
+ var u = user
+ u.Saved = true
+ return u
+ })
+ }
+)
+
+func Withdraw(amount float32) func(account Account) Option[Account] {
+
+ return F.Flow3(
+ getBalance,
+ O.FromPredicate(ord.Geq(ordFloat32)(amount)),
+ O.Map(F.Flow2(
+ N.Add(-amount),
+ MakeAccount,
+ )))
+}
+
+type User struct {
+ BirthDate string
+}
+
+func getBirthDate(u User) string {
+ return u.BirthDate
+}
+
+func MakeUser(d string) User {
+ return User{BirthDate: d}
+}
+
+var parseDate = F.Bind1of2(E.Eitherize2(time.Parse))(time.DateOnly)
+
+func GetAge(now time.Time) func(User) Either[float64] {
+ return F.Flow3(
+ getBirthDate,
+ parseDate,
+ E.Map[error](F.Flow3(
+ now.Sub,
+ time.Duration.Hours,
+ N.Mul(1/24.0),
+ )),
+ )
+}
+
+func Example_widthdraw() {
+ fmt.Println(getTwenty(MakeAccount(200)))
+ fmt.Println(getTwenty(MakeAccount(10)))
+
+ // Output:
+ // Your balance is $180.00
+ // You're broke!
+}
+
+func Example_getAge() {
+ now, err := time.Parse(time.DateOnly, "2023-09-01")
+ if err != nil {
+ panic(err)
+ }
+
+ fmt.Println(GetAge(now)(MakeUser("2005-12-12")))
+ fmt.Println(GetAge(now)(MakeUser("July 4, 2001")))
+
+ fortune := F.Flow3(
+ N.Add(365.0),
+ S.Format[float64]("%0.0f"),
+ Concat("If you survive, you will be "),
+ )
+
+ zoltar := F.Flow3(
+ GetAge(now),
+ E.Map[error](fortune),
+ E.GetOrElse(errors.ToString),
+ )
+
+ fmt.Println(zoltar(MakeUser("2005-12-12")))
+
+ // Output:
+ // Right[float64](6472)
+ // Left[*time.ParseError](parsing time "July 4, 2001" as "2006-01-02": cannot parse "July 4, 2001" as "2006")
+ // If you survive, you will be 6837
+}
+
+func Example_solution08A() {
+ incrF := I.Map(N.Add(1))
+
+ fmt.Println(incrF(I.Of(2)))
+
+ // Output: 3
+}
+
+func Example_solution08B() {
+ // initial :: User -> Option rune
+ initial := F.Flow3(
+ Chapter08User.getName,
+ S.ToRunes,
+ A.Head[rune],
+ )
+
+ fmt.Println(initial(albert08))
+
+ // Output:
+ // Some[int32](65)
+}
+
+func Example_solution08C() {
+
+ // eitherWelcome :: User -> Either String String
+ eitherWelcome := F.Flow2(
+ checkActive,
+ E.Map[error](showWelcome),
+ )
+
+ fmt.Println(eitherWelcome(gary08))
+ fmt.Println(eitherWelcome(theresa08))
+
+ // Output:
+ // Left[*errors.errorString](your account is not active)
+ // Right[string](Welcome Theresa)
+}
+
+func Example_solution08D() {
+
+ // // validateName :: User -> Either String ()
+ validateName := F.Flow3(
+ Chapter08User.getName,
+ E.FromPredicate(F.Flow2(
+ S.Size,
+ ord.Gt(ord.FromStrictCompare[int]())(3),
+ ), errors.OnSome[string]("Your name %s is larger than 3 characters")),
+ E.Map[error](F.ToAny[string]),
+ )
+
+ saveAndWelcome := F.Flow2(
+ save,
+ IOE.Map[error](showWelcome),
+ )
+
+ register := F.Flow3(
+ validateUser(validateName),
+ IOE.FromEither[error, Chapter08User],
+ IOE.Chain(saveAndWelcome),
+ )
+
+ fmt.Println(validateName(gary08))
+ fmt.Println(validateName(yi08))
+
+ fmt.Println(register(albert08)())
+ fmt.Println(register(yi08)())
+
+ // Output:
+ // Right[string](Gary)
+ // Left[*errors.errorString](Your name Yi is larger than 3 characters)
+ // Right[string](Welcome Albert)
+ // Left[*errors.errorString](Your name Yi is larger than 3 characters)
+}
diff --git a/v2/samples/mostly-adequate/chapter09_monadiconions_test.go b/v2/samples/mostly-adequate/chapter09_monadiconions_test.go
new file mode 100644
index 0000000..ab78afa
--- /dev/null
+++ b/v2/samples/mostly-adequate/chapter09_monadiconions_test.go
@@ -0,0 +1,186 @@
+// Copyright (c) 2023 - 2025 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 mostlyadequate
+
+import (
+ "fmt"
+ "path"
+ "regexp"
+
+ A "github.com/IBM/fp-go/v2/array"
+ E "github.com/IBM/fp-go/v2/either"
+ "github.com/IBM/fp-go/v2/errors"
+ F "github.com/IBM/fp-go/v2/function"
+ "github.com/IBM/fp-go/v2/io"
+ IOE "github.com/IBM/fp-go/v2/ioeither"
+ O "github.com/IBM/fp-go/v2/option"
+ S "github.com/IBM/fp-go/v2/string"
+)
+
+type (
+ Street struct {
+ Name string
+ Number int
+ }
+
+ Address struct {
+ Street Street
+ Postcode string
+ }
+
+ AddressBook struct {
+ Addresses []Address
+ }
+
+ Chapter09User struct {
+ Id int
+ Name string
+ Address Address
+ }
+)
+
+var (
+ albert09 = Chapter09User{
+ Id: 1,
+ Name: "Albert",
+ Address: Address{
+ Street: Street{
+ Number: 22,
+ Name: "Walnut St",
+ },
+ },
+ }
+
+ gary09 = Chapter09User{
+ Id: 2,
+ Name: "Gary",
+ Address: Address{
+ Street: Street{
+ Number: 14,
+ },
+ },
+ }
+
+ theresa09 = Chapter09User{
+ Id: 3,
+ Name: "Theresa",
+ }
+)
+
+func (ab AddressBook) getAddresses() []Address {
+ return ab.Addresses
+}
+
+func (s Address) getStreet() Street {
+ return s.Street
+}
+
+func (s Street) getName() string {
+ return s.Name
+}
+
+func (u Chapter09User) getAddress() Address {
+ return u.Address
+}
+
+var (
+ FirstAddressStreet = F.Flow3(
+ AddressBook.getAddresses,
+ A.Head[Address],
+ O.Map(Address.getStreet),
+ )
+
+ // getFile :: IO String
+ getFile = io.Of("/home/mostly-adequate/ch09.md")
+
+ // pureLog :: String -> IO ()
+ pureLog = io.Logf[string]("%s")
+
+ // addToMailingList :: Email -> IOEither([Email])
+ addToMailingList = F.Flow2(
+ A.Of[string],
+ IOE.Of[error, []string],
+ )
+
+ // validateEmail :: Email -> Either error Email
+ validateEmail = E.FromPredicate(Matches(regexp.MustCompile(`\S+@\S+\.\S+`)), errors.OnSome[string]("email %s is invalid"))
+
+ // emailBlast :: [Email] -> IO ()
+ emailBlast = F.Flow2(
+ A.Intercalate(S.Monoid)(","),
+ IOE.Of[error, string],
+ )
+)
+
+func Example_street() {
+ s := FirstAddressStreet(AddressBook{
+ Addresses: A.From(Address{Street: Street{Name: "Mulburry", Number: 8402}, Postcode: "WC2N"}),
+ })
+ fmt.Println(s)
+
+ // Output:
+ // Some[mostlyadequate.Street]({Mulburry 8402})
+}
+
+func Example_solution09A() {
+ // // getStreetName :: User -> Maybe String
+ getStreetName := F.Flow4(
+ Chapter09User.getAddress,
+ Address.getStreet,
+ Street.getName,
+ O.FromPredicate(S.IsNonEmpty),
+ )
+
+ fmt.Println(getStreetName(albert09))
+ fmt.Println(getStreetName(gary09))
+ fmt.Println(getStreetName(theresa09))
+
+ // Output:
+ // Some[string](Walnut St)
+ // None[string]
+ // None[string]
+
+}
+
+func Example_solution09B() {
+ logFilename := F.Flow2(
+ io.Map(path.Base),
+ io.ChainFirst(pureLog),
+ )
+
+ fmt.Println(logFilename(getFile)())
+
+ // Output:
+ // ch09.md
+}
+
+func Example_solution09C() {
+
+ // // joinMailingList :: Email -> Either String (IO ())
+ joinMailingList := F.Flow4(
+ validateEmail,
+ IOE.FromEither[error, string],
+ IOE.Chain(addToMailingList),
+ IOE.Chain(emailBlast),
+ )
+
+ fmt.Println(joinMailingList("sleepy@grandpa.net")())
+ fmt.Println(joinMailingList("notanemail")())
+
+ // Output:
+ // Right[string](sleepy@grandpa.net)
+ // Left[*errors.errorString](email notanemail is invalid)
+}
diff --git a/v2/samples/mostly-adequate/chapter10_applicativefunctor_test.go b/v2/samples/mostly-adequate/chapter10_applicativefunctor_test.go
new file mode 100644
index 0000000..80aceab
--- /dev/null
+++ b/v2/samples/mostly-adequate/chapter10_applicativefunctor_test.go
@@ -0,0 +1,183 @@
+// Copyright (c) 2023 - 2025 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 mostlyadequate
+
+import (
+ "context"
+ "fmt"
+ "net/http"
+
+ R "github.com/IBM/fp-go/v2/context/readerioeither"
+ H "github.com/IBM/fp-go/v2/context/readerioeither/http"
+ F "github.com/IBM/fp-go/v2/function"
+ IOO "github.com/IBM/fp-go/v2/iooption"
+ N "github.com/IBM/fp-go/v2/number"
+ O "github.com/IBM/fp-go/v2/option"
+ M "github.com/IBM/fp-go/v2/record"
+ T "github.com/IBM/fp-go/v2/tuple"
+)
+
+type (
+ PostItem struct {
+ UserID uint `json:"userId"`
+ Id uint `json:"id"`
+ Title string `json:"title"`
+ Body string `json:"body"`
+ }
+
+ Player struct {
+ Id int
+ Name string
+ }
+
+ LocalStorage = map[string]Player
+)
+
+var (
+ playerAlbert = Player{
+ Id: 1,
+ Name: "Albert",
+ }
+ playerTheresa = Player{
+ Id: 2,
+ Name: "Theresa",
+ }
+ localStorage = LocalStorage{
+ "player1": playerAlbert,
+ "player2": playerTheresa,
+ }
+
+ // getFromCache :: String -> IO User
+ getFromCache = func(name string) IOOption[Player] {
+ return func() Option[Player] {
+ return M.MonadLookup(localStorage, name)
+ }
+ }
+
+ // game :: User -> User -> String
+ game = F.Curry2(func(a, b Player) string {
+ return fmt.Sprintf("%s vs %s", a.Name, b.Name)
+ })
+)
+
+func (player Player) getName() string {
+ return player.Name
+}
+
+func (player Player) getID() int {
+ return player.Id
+}
+
+func (item PostItem) getTitle() string {
+ return item.Title
+}
+
+func idxToURL(idx int) string {
+ return fmt.Sprintf("https://jsonplaceholder.typicode.com/posts/%d", idx+1)
+}
+
+func renderString(destinations string) func(string) string {
+ return func(events string) string {
+ return fmt.Sprintf("Destinations: [%s], Events: [%s]
", destinations, events)
+ }
+}
+
+func Example_renderPage() {
+ // prepare the http client
+ client := H.MakeClient(http.DefaultClient)
+
+ // get returns the title of the nth item from the REST service
+ get := F.Flow4(
+ idxToURL,
+ H.MakeGetRequest,
+ H.ReadJSON[PostItem](client),
+ R.Map(PostItem.getTitle),
+ )
+
+ res := F.Pipe2(
+ R.Of(renderString), // start with a function with 2 unresolved arguments
+ R.Ap[func(string) string](get(1)), // resolve the first argument
+ R.Ap[string](get(2)), // in parallel resolve the second argument
+ )
+
+ // finally invoke in context and start
+ fmt.Println(res(context.TODO())())
+
+ // Output:
+ // Right[string](Destinations: [qui est esse], Events: [ea molestias quasi exercitationem repellat qui ipsa sit aut]
)
+
+}
+
+func Example_solution10A() {
+ safeAdd := F.Curry2(func(a, b Option[int]) Option[int] {
+ return F.Pipe3(
+ N.Add[int],
+ O.Of[func(int) func(int) int],
+ O.Ap[func(int) int](a),
+ O.Ap[int](b),
+ )
+ })
+
+ fmt.Println(safeAdd(O.Of(2))(O.Of(3)))
+ fmt.Println(safeAdd(O.None[int]())(O.Of(3)))
+ fmt.Println(safeAdd(O.Of(2))(O.None[int]()))
+
+ // Output:
+ // Some[int](5)
+ // None[int]
+ // None[int]
+}
+
+func Example_solution10B() {
+
+ safeAdd := F.Curry2(T.Untupled2(F.Flow2(
+ O.SequenceTuple2[int, int],
+ O.Map(T.Tupled2(N.MonoidSum[int]().Concat)),
+ )))
+
+ fmt.Println(safeAdd(O.Of(2))(O.Of(3)))
+ fmt.Println(safeAdd(O.None[int]())(O.Of(3)))
+ fmt.Println(safeAdd(O.Of(2))(O.None[int]()))
+
+ // Output:
+ // Some[int](5)
+ // None[int]
+ // None[int]
+}
+
+func Example_solution10C() {
+ // startGame :: IO String
+ startGame := F.Pipe2(
+ IOO.Of(game),
+ IOO.Ap[func(Player) string](getFromCache("player1")),
+ IOO.Ap[string](getFromCache("player2")),
+ )
+
+ startGameTupled := F.Pipe2(
+ T.MakeTuple2("player1", "player2"),
+ IOO.TraverseTuple2(getFromCache, getFromCache),
+ IOO.Map(T.Tupled2(func(a, b Player) string {
+ return fmt.Sprintf("%s vs %s", a.Name, b.Name)
+ })),
+ )
+
+ fmt.Println(startGame())
+ fmt.Println(startGameTupled())
+
+ // Output:
+ // Some[string](Albert vs Theresa)
+ // Some[string](Albert vs Theresa)
+}
diff --git a/v2/samples/mostly-adequate/chapter11_transformagain_test.go b/v2/samples/mostly-adequate/chapter11_transformagain_test.go
new file mode 100644
index 0000000..22d5fbb
--- /dev/null
+++ b/v2/samples/mostly-adequate/chapter11_transformagain_test.go
@@ -0,0 +1,89 @@
+// Copyright (c) 2023 - 2025 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 mostlyadequate
+
+import (
+ "fmt"
+ "regexp"
+
+ A "github.com/IBM/fp-go/v2/array"
+ E "github.com/IBM/fp-go/v2/either"
+ F "github.com/IBM/fp-go/v2/function"
+ IOE "github.com/IBM/fp-go/v2/ioeither"
+ S "github.com/IBM/fp-go/v2/string"
+)
+
+func findUserByID(id int) IOEither[Chapter08User] {
+ switch id {
+ case 1:
+ return IOE.Of[error](albert08)
+ case 2:
+ return IOE.Of[error](gary08)
+ case 3:
+ return IOE.Of[error](theresa08)
+ default:
+ return IOE.Left[Chapter08User](fmt.Errorf("user %d not found", id))
+ }
+}
+
+func Example_solution11A() {
+ // eitherToMaybe :: Either b a -> Maybe a
+ eitherToMaybe := E.ToOption[error, string]
+
+ fmt.Println(eitherToMaybe(E.Of[error]("one eyed willy")))
+ fmt.Println(eitherToMaybe(E.Left[string](fmt.Errorf("some error"))))
+
+ // Output:
+ // Some[string](one eyed willy)
+ // None[string]
+}
+
+func Example_solution11B() {
+ findByNameID := F.Flow2(
+ findUserByID,
+ IOE.Map[error](Chapter08User.getName),
+ )
+
+ fmt.Println(findByNameID(1)())
+ fmt.Println(findByNameID(2)())
+ fmt.Println(findByNameID(3)())
+ fmt.Println(findByNameID(4)())
+
+ // Output:
+ // Right[string](Albert)
+ // Right[string](Gary)
+ // Right[string](Theresa)
+ // Left[*errors.errorString](user 4 not found)
+}
+
+func Example_solution11C() {
+ // strToList :: String -> [Char
+ strToList := Split(regexp.MustCompile(``))
+
+ // listToStr :: [Char] -> String
+ listToStr := A.Intercalate(S.Monoid)("")
+
+ sortLetters := F.Flow3(
+ strToList,
+ A.Sort(S.Ord),
+ listToStr,
+ )
+
+ fmt.Println(sortLetters("sortme"))
+
+ // Output:
+ // emorst
+}
diff --git a/v2/samples/mostly-adequate/chapter12_traversing_test.go b/v2/samples/mostly-adequate/chapter12_traversing_test.go
new file mode 100644
index 0000000..2c57dee
--- /dev/null
+++ b/v2/samples/mostly-adequate/chapter12_traversing_test.go
@@ -0,0 +1,98 @@
+// Copyright (c) 2023 - 2025 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 mostlyadequate
+
+import (
+ "fmt"
+
+ A "github.com/IBM/fp-go/v2/array"
+ E "github.com/IBM/fp-go/v2/either"
+ "github.com/IBM/fp-go/v2/errors"
+ F "github.com/IBM/fp-go/v2/function"
+ IOE "github.com/IBM/fp-go/v2/ioeither"
+ O "github.com/IBM/fp-go/v2/option"
+ P "github.com/IBM/fp-go/v2/predicate"
+ S "github.com/IBM/fp-go/v2/string"
+)
+
+var (
+ // httpGet :: Route -> Task Error JSON
+ httpGet = F.Flow2(
+ S.Format[string]("json for %s"),
+ IOE.Of[error, string],
+ )
+
+ // routes :: Map Route Route
+ routes = map[string]string{
+ "/": "/",
+ "/about": "/about",
+ }
+
+ // validate :: Player -> Either error Player
+ validatePlayer = E.FromPredicate(P.ContraMap(Player.getName)(S.IsNonEmpty), F.Flow2(Player.getID, errors.OnSome[int]("player %d must have a name")))
+
+ // readfile :: String -> String -> Task Error String
+ readfile = F.Curry2(func(encoding, file string) IOEither[string] {
+ return IOE.Of[error](fmt.Sprintf("content of %s (%s)", file, encoding))
+ })
+
+ // readdir :: String -> Task Error [String]
+ readdir = IOE.Of[error](A.From("file1", "file2", "file3"))
+)
+
+func Example_solution12A() {
+ // getJsons :: Map Route Route -> Task Error (Map Route JSON)
+ getJsons := IOE.TraverseRecord[string](httpGet)
+
+ fmt.Println(getJsons(routes)())
+
+ // Output:
+ // Right[map[string]string](map[/:json for / /about:json for /about])
+}
+
+func Example_solution12B() {
+ // startGame :: [Player] -> [Either Error String]
+ startGame := F.Flow2(
+ E.TraverseArray(validatePlayer),
+ E.MapTo[error, []Player]("Game started"),
+ )
+
+ fmt.Println(startGame(A.From(playerAlbert, playerTheresa)))
+ fmt.Println(startGame(A.From(playerAlbert, Player{Id: 4})))
+
+ // Output:
+ // Right[string](Game started)
+ // Left[*errors.errorString](player 4 must have a name)
+}
+
+func Example_solution12C() {
+ traverseO := O.Traverse[string](
+ IOE.Of[error, Option[string]],
+ IOE.Map[error, string, Option[string]],
+ )
+
+ // readFirst :: String -> Task Error (Maybe String)
+ readFirst := F.Pipe2(
+ readdir,
+ IOE.Map[error](A.Head[string]),
+ IOE.Chain(traverseO(readfile("utf-8"))),
+ )
+
+ fmt.Println(readFirst())
+
+ // Output:
+ // Right[option.Option[string]](Some[string](content of file1 (utf-8)))
+}
diff --git a/v2/samples/mostly-adequate/doc_test.go b/v2/samples/mostly-adequate/doc_test.go
new file mode 100644
index 0000000..963a2eb
--- /dev/null
+++ b/v2/samples/mostly-adequate/doc_test.go
@@ -0,0 +1,19 @@
+// Copyright (c) 2023 - 2025 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 mostlyadequate is meant to serve as a go "companion" resource to Professor [Frisby's Mostly Adequate Guide].
+//
+// [Frisby's Mostly Adequate Guide]: https://github.com/MostlyAdequate/mostly-adequate-guide
+package mostlyadequate
diff --git a/v2/samples/mostly-adequate/support_test.go b/v2/samples/mostly-adequate/support_test.go
new file mode 100644
index 0000000..45e4bd4
--- /dev/null
+++ b/v2/samples/mostly-adequate/support_test.go
@@ -0,0 +1,89 @@
+// Copyright (c) 2023 - 2025 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 mostlyadequate
+
+import (
+ A "github.com/IBM/fp-go/v2/array"
+ F "github.com/IBM/fp-go/v2/function"
+ N "github.com/IBM/fp-go/v2/number"
+)
+
+type (
+ Car struct {
+ Name string
+ Horsepower int
+ DollarValue float32
+ InStock bool
+ }
+)
+
+func (car Car) getInStock() bool {
+ return car.InStock
+}
+
+func (car Car) getDollarValue() float32 {
+ return car.DollarValue
+}
+
+func (car Car) getHorsepower() int {
+ return car.Horsepower
+}
+
+func (car Car) getName() string {
+ return car.Name
+}
+
+func average(val []float32) float32 {
+ return F.Pipe2(
+ val,
+ A.Fold(N.MonoidSum[float32]()),
+ N.Div(float32(len(val))),
+ )
+}
+
+var (
+ Cars = A.From(Car{
+ Name: "Ferrari FF",
+ Horsepower: 660,
+ DollarValue: 700000,
+ InStock: true,
+ }, Car{
+ Name: "Spyker C12 Zagato",
+ Horsepower: 650,
+ DollarValue: 648000,
+ InStock: false,
+ }, Car{
+ Name: "Jaguar XKR-S",
+ Horsepower: 550,
+ DollarValue: 132000,
+ InStock: true,
+ }, Car{
+ Name: "Audi R8",
+ Horsepower: 525,
+ DollarValue: 114200,
+ InStock: false,
+ }, Car{
+ Name: "Aston Martin One-77",
+ Horsepower: 750,
+ DollarValue: 1850000,
+ InStock: true,
+ }, Car{
+ Name: "Pagani Huayra",
+ Horsepower: 700,
+ DollarValue: 1300000,
+ InStock: false,
+ })
+)
diff --git a/v2/samples/mostly-adequate/types.go b/v2/samples/mostly-adequate/types.go
new file mode 100644
index 0000000..dba8589
--- /dev/null
+++ b/v2/samples/mostly-adequate/types.go
@@ -0,0 +1,30 @@
+// Copyright (c) 2023 - 2025 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 mostlyadequate
+
+import (
+ "github.com/IBM/fp-go/v2/either"
+ "github.com/IBM/fp-go/v2/ioeither"
+ "github.com/IBM/fp-go/v2/iooption"
+ "github.com/IBM/fp-go/v2/option"
+)
+
+type (
+ Either[A any] = either.Either[error, A]
+ IOEither[A any] = ioeither.IOEither[error, A]
+ IOOption[A any] = iooption.IOOption[A]
+ Option[A any] = option.Option[A]
+)
diff --git a/v2/samples/presentation/.gitignore b/v2/samples/presentation/.gitignore
new file mode 100644
index 0000000..10f7209
--- /dev/null
+++ b/v2/samples/presentation/.gitignore
@@ -0,0 +1 @@
+~$*
\ No newline at end of file
diff --git a/v2/samples/presentation/benchmarks/http_test.go b/v2/samples/presentation/benchmarks/http_test.go
new file mode 100644
index 0000000..fd08d3a
--- /dev/null
+++ b/v2/samples/presentation/benchmarks/http_test.go
@@ -0,0 +1,123 @@
+// Copyright (c) 2023 - 2025 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 benchmarks
+
+import (
+ "context"
+ "encoding/json"
+ "io"
+ "testing"
+
+ HTTP "net/http"
+
+ A "github.com/IBM/fp-go/v2/array"
+ R "github.com/IBM/fp-go/v2/context/readerioeither"
+ H "github.com/IBM/fp-go/v2/context/readerioeither/http"
+ F "github.com/IBM/fp-go/v2/function"
+ T "github.com/IBM/fp-go/v2/tuple"
+)
+
+type PostItem struct {
+ UserID uint `json:"userId"`
+ Id uint `json:"id"`
+ Title string `json:"title"`
+ Body string `json:"body"`
+}
+
+type CatFact struct {
+ Fact string `json:"fact"`
+}
+
+func heterogeneousHTTPRequests(count int) R.ReaderIOEither[[]T.Tuple2[PostItem, CatFact]] {
+ // prepare the http client
+ client := H.MakeClient(HTTP.DefaultClient)
+ // readSinglePost sends a GET request and parses the response as [PostItem]
+ readSinglePost := H.ReadJSON[PostItem](client)
+ // readSingleCatFact sends a GET request and parses the response as [CatFact]
+ readSingleCatFact := H.ReadJSON[CatFact](client)
+
+ single := F.Pipe2(
+ T.MakeTuple2("https://jsonplaceholder.typicode.com/posts/1", "https://catfact.ninja/fact"),
+ T.Map2(H.MakeGetRequest, H.MakeGetRequest),
+ R.TraverseTuple2(
+ readSinglePost,
+ readSingleCatFact,
+ ),
+ )
+
+ return F.Pipe1(
+ A.Replicate(count, single),
+ R.SequenceArray[T.Tuple2[PostItem, CatFact]],
+ )
+}
+
+func heterogeneousHTTPRequestsIdiomatic(count int) ([]T.Tuple2[PostItem, CatFact], error) {
+ // prepare the http client
+ var result []T.Tuple2[PostItem, CatFact]
+
+ for i := 0; i < count; i++ {
+ resp, err := HTTP.Get("https://jsonplaceholder.typicode.com/posts/1")
+ if err != nil {
+ return nil, err
+ }
+ body, err := io.ReadAll(resp.Body)
+ if err != nil {
+ return nil, err
+ }
+ var item PostItem
+ err = json.Unmarshal(body, &item)
+ if err != nil {
+ return nil, err
+ }
+ resp, err = HTTP.Get("https://catfact.ninja/fact")
+ if err != nil {
+ return nil, err
+ }
+ body, err = io.ReadAll(resp.Body)
+ if err != nil {
+ return nil, err
+ }
+ var fact CatFact
+ err = json.Unmarshal(body, &item)
+ if err != nil {
+ return nil, err
+ }
+ result = append(result, T.MakeTuple2(item, fact))
+ }
+ return result, nil
+}
+
+// BenchmarkHeterogeneousHttpRequests shows how to execute multiple HTTP requests in parallel when
+// the response structure of these requests is different. We use [R.TraverseTuple2] to account for the different types
+func BenchmarkHeterogeneousHttpRequests(b *testing.B) {
+
+ count := 100
+ var benchResults any
+
+ b.Run("functional", func(b *testing.B) {
+ for n := 0; n < b.N; n++ {
+ benchResults = heterogeneousHTTPRequests(count)(context.Background())()
+ }
+ })
+
+ b.Run("idiomatic", func(b *testing.B) {
+ for n := 0; n < b.N; n++ {
+ benchResults, _ = heterogeneousHTTPRequestsIdiomatic(count)
+ }
+ })
+
+ globalResult = benchResults
+}
diff --git a/v2/samples/presentation/benchmarks/map_test.go b/v2/samples/presentation/benchmarks/map_test.go
new file mode 100644
index 0000000..0234ab9
--- /dev/null
+++ b/v2/samples/presentation/benchmarks/map_test.go
@@ -0,0 +1,177 @@
+// Copyright (c) 2023 - 2025 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 benchmarks
+
+import (
+ "math/big"
+ "strings"
+ "testing"
+
+ A "github.com/IBM/fp-go/v2/array"
+ F "github.com/IBM/fp-go/v2/function"
+ N "github.com/IBM/fp-go/v2/number"
+ O "github.com/IBM/fp-go/v2/option"
+)
+
+var (
+ createStringSet = createRandom(createRandomString(256))(256)
+ createIntDataSet = createRandom(randInt(10000))(256)
+
+ globalResult any
+)
+
+func BenchmarkMap(b *testing.B) {
+
+ data := createStringSet()
+
+ var benchResult []string
+
+ b.Run("functional", func(b *testing.B) {
+ for n := 0; n < b.N; n++ {
+ benchResult = F.Pipe1(
+ data,
+ A.Map(strings.ToUpper),
+ )
+ }
+ })
+
+ b.Run("idiomatic", func(b *testing.B) {
+ for n := 0; n < b.N; n++ {
+ var result = make([]string, 0, len(data))
+ for _, value := range data {
+ result = append(result, strings.ToUpper(value))
+ }
+ benchResult = result
+ }
+ })
+
+ globalResult = benchResult
+}
+
+func isEven(data int) bool {
+ return data%2 == 0
+}
+
+func isPrime(data int) bool {
+ return big.NewInt(int64(data)).ProbablyPrime(0)
+}
+
+func BenchmarkMapThenFilter(b *testing.B) {
+
+ data := createIntDataSet()
+ var benchResult []int
+
+ b.Run("functional isPrime", func(b *testing.B) {
+ for n := 0; n < b.N; n++ {
+ benchResult = F.Pipe2(
+ data,
+ A.Filter(isPrime),
+ A.Map(N.Div[int](2)),
+ )
+ }
+ })
+
+ b.Run("idiomatic isPrime", func(b *testing.B) {
+ for n := 0; n < b.N; n++ {
+ var result []int
+ for _, value := range data {
+ if isPrime(value) {
+ result = append(result, value/2)
+ }
+ }
+ benchResult = result
+ }
+ })
+ b.Run("functional isEven", func(b *testing.B) {
+ for n := 0; n < b.N; n++ {
+ benchResult = F.Pipe2(
+ data,
+ A.Filter(isEven),
+ A.Map(N.Div[int](2)),
+ )
+ }
+ })
+
+ b.Run("idiomatic isEven", func(b *testing.B) {
+ for n := 0; n < b.N; n++ {
+ var result []int
+ for _, value := range data {
+ if isEven(value) {
+ result = append(result, value/2)
+ }
+ }
+ benchResult = result
+ }
+ })
+
+ globalResult = benchResult
+}
+
+func BenchmarkFilterMap(b *testing.B) {
+
+ data := createIntDataSet()
+ var benchResult []int
+
+ b.Run("functional isPrime", func(b *testing.B) {
+ for n := 0; n < b.N; n++ {
+ benchResult = F.Pipe1(
+ data,
+ A.FilterMap(F.Flow2(
+ O.FromPredicate(isPrime),
+ O.Map(N.Div[int](2)),
+ )),
+ )
+ }
+ })
+
+ b.Run("idiomatic isPrime", func(b *testing.B) {
+ for n := 0; n < b.N; n++ {
+ var result []int
+ for _, value := range data {
+ if isPrime(value) {
+ result = append(result, value/2)
+ }
+ }
+ benchResult = result
+ }
+ })
+
+ b.Run("functional isEven", func(b *testing.B) {
+ for n := 0; n < b.N; n++ {
+ benchResult = F.Pipe1(
+ data,
+ A.FilterMap(F.Flow2(
+ O.FromPredicate(isEven),
+ O.Map(N.Div[int](2)),
+ )),
+ )
+ }
+ })
+
+ b.Run("idiomatic isEven", func(b *testing.B) {
+ for n := 0; n < b.N; n++ {
+ var result []int
+ for _, value := range data {
+ if isEven(value) {
+ result = append(result, value/2)
+ }
+ }
+ benchResult = result
+ }
+ })
+
+ globalResult = benchResult
+}
diff --git a/v2/samples/presentation/benchmarks/utils_test.go b/v2/samples/presentation/benchmarks/utils_test.go
new file mode 100644
index 0000000..45595eb
--- /dev/null
+++ b/v2/samples/presentation/benchmarks/utils_test.go
@@ -0,0 +1,59 @@
+// Copyright (c) 2023 - 2025 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 benchmarks
+
+import (
+ "math/rand"
+ "time"
+
+ A "github.com/IBM/fp-go/v2/array"
+ B "github.com/IBM/fp-go/v2/bytes"
+ F "github.com/IBM/fp-go/v2/function"
+ IO "github.com/IBM/fp-go/v2/io"
+)
+
+const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+
+var (
+ seededRand = rand.New(rand.NewSource(time.Now().UnixNano()))
+ randChar = F.Pipe2(
+ len(charset),
+ randInt,
+ IO.Map(charAt),
+ )
+ createRandomString = F.Flow3(
+ F.Bind2of2(A.Replicate[IO.IO[byte]])(randChar),
+ IO.SequenceArray[byte],
+ IO.Map(B.ToString),
+ )
+)
+
+func createRandom[T any](single IO.IO[T]) func(size int) IO.IO[[]T] {
+ return F.Flow2(
+ F.Bind2of2(A.Replicate[IO.IO[T]])(single),
+ IO.SequenceArray[T],
+ )
+}
+
+func charAt(idx int) byte {
+ return charset[idx]
+}
+
+func randInt(count int) IO.IO[int] {
+ return func() int {
+ return seededRand.Intn(count)
+ }
+}
diff --git a/v2/samples/presentation/cover.jpg b/v2/samples/presentation/cover.jpg
new file mode 100644
index 0000000..0831740
Binary files /dev/null and b/v2/samples/presentation/cover.jpg differ
diff --git a/v2/samples/presentation/examples/data/file1.txt b/v2/samples/presentation/examples/data/file1.txt
new file mode 100644
index 0000000..9fb0773
--- /dev/null
+++ b/v2/samples/presentation/examples/data/file1.txt
@@ -0,0 +1 @@
+Some data
\ No newline at end of file
diff --git a/v2/samples/presentation/examples/data/file2.json b/v2/samples/presentation/examples/data/file2.json
new file mode 100644
index 0000000..d37b1b0
--- /dev/null
+++ b/v2/samples/presentation/examples/data/file2.json
@@ -0,0 +1,3 @@
+{
+ "a": 10
+}
\ No newline at end of file
diff --git a/v2/samples/presentation/examples/example_composition_test.go b/v2/samples/presentation/examples/example_composition_test.go
new file mode 100644
index 0000000..918d053
--- /dev/null
+++ b/v2/samples/presentation/examples/example_composition_test.go
@@ -0,0 +1,70 @@
+// Copyright (c) 2023 - 2025 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 examples
+
+import (
+ "fmt"
+
+ A "github.com/IBM/fp-go/v2/array"
+ F "github.com/IBM/fp-go/v2/function"
+)
+
+func Example_composition_pipe() {
+
+ filter := func(i int) bool {
+ return i%2 == 0
+ }
+
+ double := func(i int) int {
+ return i * 2
+ }
+
+ input := []int{1, 2, 3, 4}
+
+ res := F.Pipe2(
+ input,
+ A.Filter(filter),
+ A.Map(double),
+ )
+
+ fmt.Println(res)
+
+ // Output:
+ // [4 8]
+}
+
+func Example_composition_flow() {
+
+ filter := func(i int) bool {
+ return i%2 == 0
+ }
+
+ double := func(i int) int {
+ return i * 2
+ }
+
+ input := []int{1, 2, 3, 4}
+
+ filterAndDouble := F.Flow2(
+ A.Filter(filter),
+ A.Map(double),
+ ) // func([]int) []int
+
+ fmt.Println(filterAndDouble(input))
+
+ // Output:
+ // [4 8]
+}
diff --git a/v2/samples/presentation/examples/example_either_test.go b/v2/samples/presentation/examples/example_either_test.go
new file mode 100644
index 0000000..f559ac2
--- /dev/null
+++ b/v2/samples/presentation/examples/example_either_test.go
@@ -0,0 +1,103 @@
+// Copyright (c) 2023 - 2025 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 examples
+
+import (
+ "fmt"
+ "strconv"
+
+ E "github.com/IBM/fp-go/v2/either"
+ F "github.com/IBM/fp-go/v2/function"
+ S "github.com/IBM/fp-go/v2/string"
+)
+
+func validatePort(port int) (int, error) {
+ if port > 0 {
+ return port, nil
+ }
+ return 0, fmt.Errorf("Value %d is not a valid port number", port)
+}
+
+func Example_either_monad() {
+
+ // func(string) E.Either[error, int]
+ atoi := E.Eitherize1(strconv.Atoi)
+ // func(int) E.Either[error, int]
+ valPort := E.Eitherize1(validatePort)
+
+ // func(string) E.Either[error, string]
+ makeUrl := F.Flow3(
+ atoi,
+ E.Chain(valPort),
+ E.Map[error](S.Format[int]("http://localhost:%d")),
+ )
+
+ fmt.Println(makeUrl("8080"))
+
+ // Output:
+ // Right[string](http://localhost:8080)
+}
+
+func Example_either_idiomatic() {
+
+ makeUrl := func(port string) (string, error) {
+ parsed, err := strconv.Atoi(port)
+ if err != nil {
+ return "", err
+ }
+ valid, err := validatePort(parsed)
+ if err != nil {
+ return "", err
+ }
+ return fmt.Sprintf("http://localhost:%d", valid), nil
+ }
+
+ url, err := makeUrl("8080")
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println(url)
+
+ // Output:
+ // http://localhost:8080
+}
+
+func Example_either_worlds() {
+
+ // func(string) E.Either[error, int]
+ atoi := E.Eitherize1(strconv.Atoi)
+ // func(int) E.Either[error, int]
+ valPort := E.Eitherize1(validatePort)
+
+ // func(string) E.Either[error, string]
+ makeUrl := F.Flow3(
+ atoi,
+ E.Chain(valPort),
+ E.Map[error](S.Format[int]("http://localhost:%d")),
+ )
+
+ // func(string) (string, error)
+ makeUrlGo := E.Uneitherize1(makeUrl)
+
+ url, err := makeUrlGo("8080")
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println(url)
+
+ // Output:
+ // http://localhost:8080
+}
diff --git a/v2/samples/presentation/examples/example_generics_test.go b/v2/samples/presentation/examples/example_generics_test.go
new file mode 100644
index 0000000..2ff023d
--- /dev/null
+++ b/v2/samples/presentation/examples/example_generics_test.go
@@ -0,0 +1,46 @@
+// Copyright (c) 2023 - 2025 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 examples
+
+import (
+ "fmt"
+
+ N "github.com/IBM/fp-go/v2/number"
+)
+
+// addInts adds two integers
+func addInts(left, right int) int {
+ return left + right
+}
+
+// addNumbers adds two numbers
+func addNumbers[T N.Number](left, right T) T {
+ return left + right
+}
+
+func Example_generics() {
+ // invoke the non generic version
+ fmt.Println(addInts(1, 2))
+
+ // invoke the generic version
+ fmt.Println(addNumbers(1, 2))
+ fmt.Println(addNumbers(1.0, 2.0))
+
+ // Output:
+ // 3
+ // 3
+ // 3
+}
diff --git a/v2/samples/presentation/examples/example_hof_test.go b/v2/samples/presentation/examples/example_hof_test.go
new file mode 100644
index 0000000..bb46a87
--- /dev/null
+++ b/v2/samples/presentation/examples/example_hof_test.go
@@ -0,0 +1,34 @@
+// Copyright (c) 2023 - 2025 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 examples
+
+import "fmt"
+
+func captureValue[T any](captured T) func() string {
+ return func() string {
+ return fmt.Sprintf("Value: %v", captured)
+ }
+}
+
+func Example_closure() {
+
+ hof := captureValue("Carsten") // func() string
+
+ fmt.Println(hof())
+
+ // Output:
+ // Value: Carsten
+}
diff --git a/v2/samples/presentation/examples/example_immutability_test.go b/v2/samples/presentation/examples/example_immutability_test.go
new file mode 100644
index 0000000..136fc55
--- /dev/null
+++ b/v2/samples/presentation/examples/example_immutability_test.go
@@ -0,0 +1,156 @@
+// Copyright (c) 2023 - 2025 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 examples
+
+import (
+ "fmt"
+ "strings"
+
+ F "github.com/IBM/fp-go/v2/function"
+ N "github.com/IBM/fp-go/v2/number"
+ L "github.com/IBM/fp-go/v2/optics/lens"
+)
+
+type Person struct {
+ name string
+ age int
+}
+
+func (p Person) GetName() string {
+ return p.name
+}
+
+func (p Person) GetAge() int {
+ return p.age
+}
+
+func (p Person) SetName(name string) Person {
+ p.name = name
+ return p
+}
+
+func (p Person) SetAge(age int) Person {
+ p.age = age
+ return p
+}
+
+type Address struct {
+ city string
+}
+
+func (a Address) GetCity() string {
+ return a.city
+}
+
+func (a Address) SetCity(city string) Address {
+ a.city = city
+ return a
+}
+
+type Client struct {
+ person Person
+ address Address
+}
+
+func (c Client) GetPerson() Person {
+ return c.person
+}
+
+func (c Client) SetPerson(person Person) Client {
+ c.person = person
+ return c
+}
+
+func (c Client) GetAddress() Address {
+ return c.address
+}
+
+func (c Client) SetAddress(address Address) Client {
+ c.address = address
+ return c
+}
+
+func MakePerson(name string, age int) Person {
+ return Person{name, age}
+}
+
+func MakeClient(city string, name string, age int) Client {
+ return Client{person: Person{name, age}, address: Address{city}}
+}
+
+func Example_immutability_struct() {
+ p1 := MakePerson("Carsten", 53)
+
+ // func(int) func(Person) Person
+ setAge := F.Curry2(F.Swap(Person.SetAge))
+
+ p2 := F.Pipe1(
+ p1,
+ setAge(54),
+ )
+
+ fmt.Println(p1)
+ fmt.Println(p2)
+
+ // Output:
+ // {Carsten 53}
+ // {Carsten 54}
+}
+
+func Example_immutability_optics() {
+
+ // Lens[Person, int]
+ ageLens := L.MakeLens(Person.GetAge, Person.SetAge)
+ // func(Person) Person
+ incAge := L.Modify[Person](N.Inc[int])(ageLens)
+
+ p1 := MakePerson("Carsten", 53)
+ p2 := incAge(p1)
+
+ fmt.Println(p1)
+ fmt.Println(p2)
+
+ // Output:
+ // {Carsten 53}
+ // {Carsten 54}
+}
+
+func Example_immutability_lenses() {
+
+ // Lens[Person, string]
+ nameLens := L.MakeLens(Person.GetName, Person.SetName)
+ // Lens[Client, Person]
+ personLens := L.MakeLens(Client.GetPerson, Client.SetPerson)
+
+ // Lens[Client, string]
+ clientNameLens := F.Pipe1(
+ personLens,
+ L.Compose[Client](nameLens),
+ )
+ // func(Client) Client
+ upperName := L.Modify[Client](strings.ToUpper)(clientNameLens)
+
+ c1 := MakeClient("Böblingen", "Carsten", 53)
+
+ c2 := upperName(c1)
+
+ fmt.Println(c1)
+ fmt.Println(c2)
+
+ // Output:
+ // {{Carsten 53} {Böblingen}}
+ // {{CARSTEN 53} {Böblingen}}
+}
diff --git a/v2/samples/presentation/examples/example_map_test.go b/v2/samples/presentation/examples/example_map_test.go
new file mode 100644
index 0000000..4552056
--- /dev/null
+++ b/v2/samples/presentation/examples/example_map_test.go
@@ -0,0 +1,64 @@
+// Copyright (c) 2023 - 2025 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 examples
+
+import (
+ "fmt"
+
+ A "github.com/IBM/fp-go/v2/array"
+ N "github.com/IBM/fp-go/v2/number"
+)
+
+func Example_map() {
+
+ f := func(i int) int {
+ return i * 2
+ }
+
+ input := []int{1, 2, 3, 4}
+
+ // idiomatic go
+ res1 := make([]int, 0, len(input))
+ for _, i := range input {
+ res1 = append(res1, f(i))
+ }
+ fmt.Println(res1)
+
+ // map
+ res2 := A.Map(f)(input)
+ fmt.Println(res2)
+
+ // Output:
+ // [2 4 6 8]
+ // [2 4 6 8]
+}
+
+func Example_reduce() {
+
+ input := []int{1, 2, 3, 4}
+
+ // reduce
+ red := A.Reduce(N.MonoidSum[int]().Concat, 0)(input)
+ fmt.Println(red)
+
+ // fold
+ fld := A.Fold(N.MonoidSum[int]())(input)
+ fmt.Println(fld)
+
+ // Output:
+ // 10
+ // 10
+}
diff --git a/v2/samples/presentation/examples/example_sideeffect_test.go b/v2/samples/presentation/examples/example_sideeffect_test.go
new file mode 100644
index 0000000..9ff9315
--- /dev/null
+++ b/v2/samples/presentation/examples/example_sideeffect_test.go
@@ -0,0 +1,105 @@
+// Copyright (c) 2023 - 2025 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 examples
+
+import (
+ "encoding/json"
+ "fmt"
+ "os"
+
+ B "github.com/IBM/fp-go/v2/bytes"
+ F "github.com/IBM/fp-go/v2/function"
+ IOE "github.com/IBM/fp-go/v2/ioeither"
+ "github.com/IBM/fp-go/v2/ioeither/file"
+ J "github.com/IBM/fp-go/v2/json"
+ T "github.com/IBM/fp-go/v2/tuple"
+)
+
+type Sample struct {
+ Value int `json:"a"`
+}
+
+func (s Sample) getValue() int {
+ return s.Value
+}
+
+func Example_io_flow() {
+
+ // IOE.IOEither[error, string]
+ text := F.Pipe2(
+ "data/file1.txt",
+ file.ReadFile,
+ IOE.Map[error](B.ToString),
+ )
+
+ // IOE.IOEither[error, int]
+ value := F.Pipe3(
+ "data/file2.json",
+ file.ReadFile,
+ IOE.ChainEitherK(J.Unmarshal[Sample]),
+ IOE.Map[error](Sample.getValue),
+ )
+
+ // IOE.IOEither[error, string]
+ result := F.Pipe1(
+ IOE.SequenceT2(text, value),
+ IOE.Map[error](func(res T.Tuple2[string, int]) string {
+ return fmt.Sprintf("Text: %s, Number: %d", res.F1, res.F2)
+ }),
+ )
+
+ fmt.Println(result())
+
+ // Output:
+ // Right[string](Text: Some data, Number: 10)
+
+}
+
+func io_flow_idiomatic() error {
+
+ // []byte
+ file1AsBytes, err := os.ReadFile("data/file1.txt")
+ if err != nil {
+ return err
+ }
+ // string
+ text := string(file1AsBytes)
+
+ // []byte
+ file2AsBytes, err := os.ReadFile("data/file2.json")
+ if err != nil {
+ return err
+ }
+ var value Sample
+ if err := json.Unmarshal(file2AsBytes, &value); err != nil {
+ return err
+ }
+ // string
+ result := fmt.Sprintf("Text: %s, Number: %d", text, value.Value)
+
+ fmt.Println(result)
+
+ return nil
+}
+
+func Example_io_flow_idiomatic() {
+ if err := io_flow_idiomatic(); err != nil {
+ panic(err)
+ }
+
+ // Output:
+ // Text: Some data, Number: 10
+}
diff --git a/v2/samples/presentation/examples/examples_monad_test.go b/v2/samples/presentation/examples/examples_monad_test.go
new file mode 100644
index 0000000..4e4be79
--- /dev/null
+++ b/v2/samples/presentation/examples/examples_monad_test.go
@@ -0,0 +1,50 @@
+// Copyright (c) 2023 - 2025 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 examples
+
+type HKT[T any] struct {
+}
+
+// Pointed
+func Of[A any](A) HKT[A] { return HKT[A]{} }
+
+// Functor
+func Map[A, B any](func(A) B) func(HKT[A]) HKT[B] { return func(HKT[A]) HKT[B] { return HKT[B]{} } }
+func MapTo[A, B any](A) func(HKT[A]) HKT[B] { return func(HKT[A]) HKT[B] { return HKT[B]{} } }
+
+// Chain
+func Chain[A, B any](func(A) HKT[B]) func(HKT[A]) HKT[B] {
+ return func(HKT[A]) HKT[B] { return HKT[B]{} }
+}
+func ChainTo[A, B any](HKT[B]) func(HKT[A]) HKT[B] {
+ return func(HKT[A]) HKT[B] { return HKT[B]{} }
+}
+func ChainFirst[A, B any](func(A) HKT[B]) func(HKT[A]) HKT[A] {
+ return func(HKT[A]) HKT[A] { return HKT[A]{} }
+}
+
+// Apply
+func Ap[A, B any](HKT[A]) func(HKT[func(A) B]) HKT[B] {
+ return func(HKT[func(A) B]) HKT[B] { return HKT[B]{} }
+}
+
+// Derived
+func Flatten[A, B any](HKT[HKT[A]]) HKT[A] {
+ return HKT[A]{}
+}
+func Reduce[A, B any](func(B, A) B, B) func(HKT[A]) HKT[B] {
+ return func(HKT[A]) HKT[B] { return HKT[B]{} }
+}
diff --git a/v2/samples/presentation/introduction.pptx b/v2/samples/presentation/introduction.pptx
new file mode 100644
index 0000000..6c1042d
Binary files /dev/null and b/v2/samples/presentation/introduction.pptx differ
diff --git a/v2/samples/readerioeither/example1/reader_test.go b/v2/samples/readerioeither/example1/reader_test.go
new file mode 100644
index 0000000..b3b9d60
--- /dev/null
+++ b/v2/samples/readerioeither/example1/reader_test.go
@@ -0,0 +1,89 @@
+// Copyright (c) 2023 - 2025 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 example1
+
+import (
+ "os"
+
+ B "github.com/IBM/fp-go/v2/bytes"
+ E "github.com/IBM/fp-go/v2/either"
+ F "github.com/IBM/fp-go/v2/function"
+ I "github.com/IBM/fp-go/v2/identity"
+ IOE "github.com/IBM/fp-go/v2/ioeither"
+ J "github.com/IBM/fp-go/v2/json"
+ RIOE "github.com/IBM/fp-go/v2/readerioeither"
+)
+
+type (
+ WriterType = func([]byte) IOE.IOEither[error, []byte]
+
+ Dependencies struct {
+ Writer WriterType
+ }
+)
+
+func getWriter(deps *Dependencies) WriterType {
+ return deps.Writer
+}
+
+// SerializeToWriter marshals the input to JSON and persists the result via the [Writer] passed in via the [*Dependencies]
+func SerializeToWriter[A any](data A) RIOE.ReaderIOEither[*Dependencies, error, []byte] {
+ return F.Pipe1(
+ RIOE.Ask[*Dependencies, error](),
+ RIOE.ChainIOEitherK[*Dependencies](F.Flow2(
+ getWriter,
+ F.Pipe2(
+ data,
+ J.Marshal[A],
+ E.Fold(F.Flow2(
+ IOE.Left[[]byte, error],
+ F.Constant1[WriterType, IOE.IOEither[error, []byte]],
+ ), I.Ap[IOE.IOEither[error, []byte], []byte]),
+ ),
+ )),
+ )
+}
+
+func ExampleReaderIOEither() {
+
+ // writeToStdOut implements a writer to stdout
+ writeToStdOut := func(data []byte) IOE.IOEither[error, []byte] {
+ return IOE.TryCatchError(func() ([]byte, error) {
+ _, err := os.Stdout.Write(data)
+ return data, err
+ })
+ }
+
+ deps := Dependencies{
+ Writer: writeToStdOut,
+ }
+
+ data := map[string]string{
+ "a": "b",
+ "c": "d",
+ }
+
+ // writeData will persist to a configurable target
+ writeData := F.Pipe1(
+ SerializeToWriter(data),
+ RIOE.Map[*Dependencies, error](B.ToString),
+ )
+
+ _ = writeData(&deps)()
+
+ // Output:
+ // {"a":"b","c":"d"}
+}
diff --git a/v2/samples/readfile/data/file.json b/v2/samples/readfile/data/file.json
new file mode 100644
index 0000000..6f6b333
--- /dev/null
+++ b/v2/samples/readfile/data/file.json
@@ -0,0 +1,3 @@
+{
+ "data": "Carsten"
+}
\ No newline at end of file
diff --git a/v2/samples/readfile/data/file1.json b/v2/samples/readfile/data/file1.json
new file mode 100644
index 0000000..5d25584
--- /dev/null
+++ b/v2/samples/readfile/data/file1.json
@@ -0,0 +1,3 @@
+{
+ "data": "file1"
+}
\ No newline at end of file
diff --git a/v2/samples/readfile/data/file2.json b/v2/samples/readfile/data/file2.json
new file mode 100644
index 0000000..03f5d1a
--- /dev/null
+++ b/v2/samples/readfile/data/file2.json
@@ -0,0 +1,3 @@
+{
+ "data": "file2"
+}
\ No newline at end of file
diff --git a/v2/samples/readfile/data/file3.json b/v2/samples/readfile/data/file3.json
new file mode 100644
index 0000000..27ed7e8
--- /dev/null
+++ b/v2/samples/readfile/data/file3.json
@@ -0,0 +1,3 @@
+{
+ "data": "file3"
+}
\ No newline at end of file
diff --git a/v2/samples/readfile/readfile_test.go b/v2/samples/readfile/readfile_test.go
new file mode 100644
index 0000000..1a62a17
--- /dev/null
+++ b/v2/samples/readfile/readfile_test.go
@@ -0,0 +1,73 @@
+// Copyright (c) 2023 - 2025 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 readfile
+
+import (
+ "context"
+ "fmt"
+ "testing"
+
+ A "github.com/IBM/fp-go/v2/array"
+ R "github.com/IBM/fp-go/v2/context/readerioeither"
+ "github.com/IBM/fp-go/v2/context/readerioeither/file"
+ E "github.com/IBM/fp-go/v2/either"
+ F "github.com/IBM/fp-go/v2/function"
+ IO "github.com/IBM/fp-go/v2/io"
+ J "github.com/IBM/fp-go/v2/json"
+ "github.com/stretchr/testify/assert"
+)
+
+type RecordType struct {
+ Data string `json:"data"`
+}
+
+// TestReadSingleFile reads the content of a file from disk and parses it into
+// a struct
+func TestReadSingleFile(t *testing.T) {
+
+ data := F.Pipe2(
+ file.ReadFile("./data/file.json"),
+ R.ChainEitherK(J.Unmarshal[RecordType]),
+ R.ChainFirstIOK(IO.Logf[RecordType]("Log: %v")),
+ )
+
+ result := data(context.Background())
+
+ assert.Equal(t, E.Of[error](RecordType{"Carsten"}), result())
+}
+
+func idxToFilename(idx int) string {
+ return fmt.Sprintf("./data/file%d.json", idx+1)
+}
+
+// TestReadMultipleFiles reads the content of a multiple from disk and parses them into
+// structs
+func TestReadMultipleFiles(t *testing.T) {
+
+ data := F.Pipe2(
+ A.MakeBy(3, idxToFilename),
+ R.TraverseArray(F.Flow3(
+ file.ReadFile,
+ R.ChainEitherK(J.Unmarshal[RecordType]),
+ R.ChainFirstIOK(IO.Logf[RecordType]("Log Single: %v")),
+ )),
+ R.ChainFirstIOK(IO.Logf[[]RecordType]("Log Result: %v")),
+ )
+
+ result := data(context.Background())
+
+ assert.Equal(t, E.Of[error](A.From(RecordType{"file1"}, RecordType{"file2"}, RecordType{"file3"})), result())
+}
diff --git a/v2/samples/tuples/option_test.go b/v2/samples/tuples/option_test.go
new file mode 100644
index 0000000..39bde40
--- /dev/null
+++ b/v2/samples/tuples/option_test.go
@@ -0,0 +1,59 @@
+// Copyright (c) 2023 - 2025 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 tuples
+
+import (
+ "fmt"
+ "os"
+ "path/filepath"
+ "testing"
+
+ F "github.com/IBM/fp-go/v2/function"
+ IOE "github.com/IBM/fp-go/v2/ioeither"
+ IOEF "github.com/IBM/fp-go/v2/ioeither/file"
+ IOEG "github.com/IBM/fp-go/v2/ioeither/generic"
+ IOO "github.com/IBM/fp-go/v2/iooption"
+)
+
+func TestIOEitherToOption1(t *testing.T) {
+ tmpDir := t.TempDir()
+ content := []byte("abc")
+
+ resIOO := F.Pipe2(
+ content,
+ IOEF.WriteFile(filepath.Join(tmpDir, "test.txt"), os.ModePerm),
+ IOEG.Fold[IOE.IOEither[error, []byte]](
+ IOO.Of[error],
+ F.Ignore1of1[[]byte](IOO.None[error]),
+ ),
+ )
+
+ fmt.Println(resIOO())
+}
+
+func TestIOEitherToOption2(t *testing.T) {
+ tmpDir := t.TempDir()
+ content := []byte("abc")
+
+ resIOO := F.Pipe3(
+ content,
+ IOEF.WriteFile(filepath.Join(tmpDir, "test.txt"), os.ModePerm),
+ IOE.Swap[error, []byte],
+ IOE.ToIOOption[[]byte, error],
+ )
+
+ fmt.Println(resIOO())
+}
diff --git a/v2/samples/tuples/samples/data.txt b/v2/samples/tuples/samples/data.txt
new file mode 100644
index 0000000..f2ba8f8
--- /dev/null
+++ b/v2/samples/tuples/samples/data.txt
@@ -0,0 +1 @@
+abc
\ No newline at end of file
diff --git a/v2/samples/tuples/tuple_test.go b/v2/samples/tuples/tuple_test.go
new file mode 100644
index 0000000..162da27
--- /dev/null
+++ b/v2/samples/tuples/tuple_test.go
@@ -0,0 +1,128 @@
+// Copyright (c) 2023 - 2025 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 tuples
+
+import (
+ "bytes"
+ "io"
+ "strings"
+ "testing"
+
+ E "github.com/IBM/fp-go/v2/either"
+ F "github.com/IBM/fp-go/v2/function"
+ IOE "github.com/IBM/fp-go/v2/ioeither"
+ IOEF "github.com/IBM/fp-go/v2/ioeither/file"
+ T "github.com/IBM/fp-go/v2/tuple"
+ "github.com/stretchr/testify/assert"
+)
+
+func sampleConvertDocx(r io.Reader) (string, map[string]string, error) {
+ content, err := io.ReadAll(r)
+ return string(content), map[string]string{}, err
+}
+
+func TestSampleConvertDocx1(t *testing.T) {
+ // this conversion approach has the disadvantage that it exhausts the reader
+ // so we cannot invoke the resulting IOEither multiple times
+ convertDocx := func(r io.Reader) IOE.IOEither[error, T.Tuple2[string, map[string]string]] {
+ return IOE.TryCatchError(func() (T.Tuple2[string, map[string]string], error) {
+ text, meta, err := sampleConvertDocx(r)
+ return T.MakeTuple2(text, meta), err
+ })
+ }
+
+ rdr := strings.NewReader("abc")
+ resIOE := convertDocx(rdr)
+
+ resE := resIOE()
+
+ assert.True(t, E.IsRight(resE))
+}
+
+func TestSampleConvertDocx2(t *testing.T) {
+ // this approach assumes that `sampleConvertDocx` does not have any side effects
+ // other than reading from a `Reader`. As a consequence it can be a pure function itself.
+ // The disadvantage is that its input has to exist in memory which is probably not a good
+ // idea for large inputs
+ convertDocx := func(data []byte) Either[T.Tuple2[string, map[string]string]] {
+ text, meta, err := sampleConvertDocx(bytes.NewReader(data))
+ return E.TryCatchError(T.MakeTuple2(text, meta), err)
+ }
+
+ resE := convertDocx([]byte("abc"))
+
+ assert.True(t, E.IsRight(resE))
+}
+
+// onClose closes a closeable resource
+func onClose[R io.Closer](r R) IOE.IOEither[error, R] {
+ return IOE.TryCatchError(func() (R, error) {
+ return r, r.Close()
+ })
+}
+
+// convertDocx3 takes an `acquire` function that creates an instance or a [ReaderCloser] whenever the resulting [IOEither] is invoked. Since
+// we return a [Closer] the instance will be closed after use, automatically. This design makes sure that the resulting [IOEither] can be invoked
+// as many times as necessary
+func convertDocx3[R io.ReadCloser](acquire IOE.IOEither[error, R]) IOE.IOEither[error, T.Tuple2[string, map[string]string]] {
+ return IOE.WithResource[T.Tuple2[string, map[string]string]](
+ acquire,
+ onClose[R])(
+ func(r R) IOE.IOEither[error, T.Tuple2[string, map[string]string]] {
+ return IOE.TryCatchError(func() (T.Tuple2[string, map[string]string], error) {
+ text, meta, err := sampleConvertDocx(r)
+ return T.MakeTuple2(text, meta), err
+ })
+ },
+ )
+}
+
+// convertDocx4 takes an `acquire` function that creates an instance or a [Reader] whenever the resulting [IOEither] is invoked.
+// This design makes sure that the resulting [IOEither] can be invoked
+// as many times as necessary
+func convertDocx4[R io.Reader](acquire IOE.IOEither[error, R]) IOE.IOEither[error, T.Tuple2[string, map[string]string]] {
+ return F.Pipe1(
+ acquire,
+ IOE.Chain(func(r R) IOE.IOEither[error, T.Tuple2[string, map[string]string]] {
+ return IOE.TryCatchError(func() (T.Tuple2[string, map[string]string], error) {
+ text, meta, err := sampleConvertDocx(r)
+ return T.MakeTuple2(text, meta), err
+ })
+ }),
+ )
+}
+
+func TestSampleConvertDocx3(t *testing.T) {
+ // IOEither that creates the reader
+ acquire := IOEF.Open("./samples/data.txt")
+
+ resIOE := convertDocx3(acquire)
+ resE := resIOE()
+
+ assert.True(t, E.IsRight(resE))
+}
+
+func TestSampleConvertDocx4(t *testing.T) {
+ // IOEither that creates the reader
+ acquire := IOE.FromIO[error](func() *strings.Reader {
+ return strings.NewReader("abc")
+ })
+
+ resIOE := convertDocx4(acquire)
+ resE := resIOE()
+
+ assert.True(t, E.IsRight(resE))
+}
diff --git a/v2/samples/tuples/types.go b/v2/samples/tuples/types.go
new file mode 100644
index 0000000..bf5938f
--- /dev/null
+++ b/v2/samples/tuples/types.go
@@ -0,0 +1,22 @@
+// Copyright (c) 2023 - 2025 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 tuples
+
+import "github.com/IBM/fp-go/v2/either"
+
+type (
+ Either[A any] = either.Either[error, A]
+)
diff --git a/v2/semigroup/alt.go b/v2/semigroup/alt.go
new file mode 100644
index 0000000..8d8a4ed
--- /dev/null
+++ b/v2/semigroup/alt.go
@@ -0,0 +1,28 @@
+// Copyright (c) 2023 - 2025 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 semigroup
+
+func AltSemigroup[HKTA any, LAZYHKTA ~func() HKTA](
+ falt func(HKTA, LAZYHKTA) HKTA,
+
+) Semigroup[HKTA] {
+
+ return MakeSemigroup(
+ func(first, second HKTA) HKTA {
+ return falt(first, func() HKTA { return second })
+ },
+ )
+}
diff --git a/v2/semigroup/apply.go b/v2/semigroup/apply.go
new file mode 100644
index 0000000..6571a01
--- /dev/null
+++ b/v2/semigroup/apply.go
@@ -0,0 +1,38 @@
+// Copyright (c) 2023 - 2025 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 semigroup
+
+import (
+ F "github.com/IBM/fp-go/v2/function"
+)
+
+/*
+*
+HKTA = HKT
+HKTFA = HKT
+*/
+func ApplySemigroup[A, HKTA, HKTFA any](
+ fmap func(HKTA, func(A) func(A) A) HKTFA,
+ fap func(HKTFA, HKTA) HKTA,
+
+ s Semigroup[A],
+) Semigroup[HKTA] {
+
+ cb := F.Curry2(s.Concat)
+ return MakeSemigroup(func(first HKTA, second HKTA) HKTA {
+ return fap(fmap(first, cb), second)
+ })
+}
diff --git a/v2/semigroup/array.go b/v2/semigroup/array.go
new file mode 100644
index 0000000..7f818f0
--- /dev/null
+++ b/v2/semigroup/array.go
@@ -0,0 +1,36 @@
+// Copyright (c) 2023 - 2025 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 semigroup
+
+import (
+ M "github.com/IBM/fp-go/v2/magma"
+)
+
+func GenericMonadConcatAll[GA ~[]A, A any](s Semigroup[A]) func(GA, A) A {
+ return M.GenericMonadConcatAll[GA](M.MakeMagma(s.Concat))
+}
+
+func GenericConcatAll[GA ~[]A, A any](s Semigroup[A]) func(A) func(GA) A {
+ return M.GenericConcatAll[GA](M.MakeMagma(s.Concat))
+}
+
+func MonadConcatAll[A any](s Semigroup[A]) func([]A, A) A {
+ return GenericMonadConcatAll[[]A](s)
+}
+
+func ConcatAll[A any](s Semigroup[A]) func(A) func([]A) A {
+ return GenericConcatAll[[]A](s)
+}
diff --git a/v2/semigroup/doc.go b/v2/semigroup/doc.go
new file mode 100644
index 0000000..569ac05
--- /dev/null
+++ b/v2/semigroup/doc.go
@@ -0,0 +1,303 @@
+// Copyright (c) 2023 - 2025 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 semigroup provides implementations of the Semigroup algebraic structure.
+
+# Semigroup
+
+A Semigroup is an algebraic structure consisting of a set together with an associative
+binary operation. It extends the Magma structure by adding the associativity law.
+
+Mathematical Definition:
+
+A semigroup is a pair (S, •) where:
+ - S is a set
+ - • is a binary operation: S × S → S
+ - The operation must be associative: (a • b) • c = a • (b • c)
+
+The key difference from Magma is the associativity requirement, which allows operations
+to be chained without worrying about parentheses.
+
+# Basic Usage
+
+Creating and using a semigroup:
+
+ import (
+ "fmt"
+ SG "github.com/IBM/fp-go/v2/semigroup"
+ )
+
+ // Create a semigroup for string concatenation
+ stringConcat := SG.MakeSemigroup(func(a, b string) string {
+ return a + b
+ })
+
+ result := stringConcat.Concat("Hello, ", "World!")
+ fmt.Println(result) // Output: Hello, World!
+
+ // Associativity holds
+ s1 := stringConcat.Concat(stringConcat.Concat("a", "b"), "c")
+ s2 := stringConcat.Concat("a", stringConcat.Concat("b", "c"))
+ fmt.Println(s1 == s2) // Output: true
+
+# Built-in Semigroups
+
+The package provides several pre-defined semigroups:
+
+First - Always returns the first argument:
+
+ first := SG.First[int]()
+ result := first.Concat(1, 2) // Returns: 1
+
+Last - Always returns the last argument:
+
+ last := SG.Last[int]()
+ result := last.Concat(1, 2) // Returns: 2
+
+# Semigroup Transformations
+
+Reverse - Swaps the order of arguments:
+
+ import N "github.com/IBM/fp-go/v2/number"
+
+ sub := SG.MakeSemigroup(func(a, b int) int { return a - b })
+ reversed := SG.Reverse(sub)
+
+ result1 := sub.Concat(10, 3) // 10 - 3 = 7
+ result2 := reversed.Concat(10, 3) // 3 - 10 = -7
+
+FunctionSemigroup - Lifts a semigroup to work with functions:
+
+ import N "github.com/IBM/fp-go/v2/number"
+
+ // Semigroup for integers
+ intSum := N.SemigroupSum[int]()
+
+ // Lift to functions that return integers
+ funcSG := SG.FunctionSemigroup[string](intSum)
+
+ f := func(s string) int { return len(s) }
+ g := func(s string) int { return len(s) * 2 }
+
+ // Combine functions
+ combined := funcSG.Concat(f, g)
+ result := combined("hello") // len("hello") + len("hello")*2 = 5 + 10 = 15
+
+# Array Operations
+
+ConcatAll - Concatenates all elements in an array with a starting value:
+
+ import N "github.com/IBM/fp-go/v2/number"
+
+ sum := N.SemigroupSum[int]()
+ concatAll := SG.ConcatAll(sum)
+
+ result := concatAll(10)([]int{1, 2, 3, 4}) // 10 + 1 + 2 + 3 + 4 = 20
+
+MonadConcatAll - Concatenates all elements with a starting value (uncurried):
+
+ import N "github.com/IBM/fp-go/v2/number"
+
+ sum := N.SemigroupSum[int]()
+ result := SG.MonadConcatAll(sum)([]int{1, 2, 3, 4}, 10) // 20
+
+GenericConcatAll - Generic version for custom slice types:
+
+ type MyInts []int
+
+ sum := N.SemigroupSum[int]()
+ concatAll := SG.GenericConcatAll[MyInts](sum)
+
+ result := concatAll(0)(MyInts{1, 2, 3}) // 6
+
+# Higher-Kinded Type Semigroups
+
+ApplySemigroup - Creates a semigroup for applicative functors:
+
+ // For a type HKT with map and ap operations
+ applySG := SG.ApplySemigroup(
+ fmap, // func(HKT, func(A) func(A) A) HKT
+ fap, // func(HKT, HKT) HKT
+ baseSemigroup,
+ )
+
+AltSemigroup - Creates a semigroup for alternative functors:
+
+ // For a type HKT with an alt operation
+ altSG := SG.AltSemigroup(
+ falt, // func(HKT, func() HKT) HKT
+ )
+
+# Practical Examples
+
+Example 1: Merging Configurations
+
+ type Config struct {
+ Timeout int
+ Retries int
+ }
+
+ configSG := SG.MakeSemigroup(func(a, b Config) Config {
+ return Config{
+ Timeout: max(a.Timeout, b.Timeout),
+ Retries: a.Retries + b.Retries,
+ }
+ })
+
+ default := Config{Timeout: 30, Retries: 3}
+ user := Config{Timeout: 60, Retries: 5}
+ override := Config{Timeout: 45, Retries: 2}
+
+ // Merge configurations (associative)
+ final := configSG.Concat(configSG.Concat(default, user), override)
+ // Result: Config{Timeout: 60, Retries: 10}
+
+Example 2: Combining Validators
+
+ type Validator func(string) []string // Returns list of errors
+
+ validatorSG := SG.MakeSemigroup(func(v1, v2 Validator) Validator {
+ return func(s string) []string {
+ errors1 := v1(s)
+ errors2 := v2(s)
+ return append(errors1, errors2...)
+ }
+ })
+
+ notEmpty := func(s string) []string {
+ if s == "" {
+ return []string{"must not be empty"}
+ }
+ return nil
+ }
+
+ minLength := func(s string) []string {
+ if len(s) < 3 {
+ return []string{"must be at least 3 characters"}
+ }
+ return nil
+ }
+
+ // Combine validators
+ combined := validatorSG.Concat(notEmpty, minLength)
+ errors := combined("ab") // ["must be at least 3 characters"]
+
+Example 3: Aggregating Statistics
+
+ type Stats struct {
+ Count int
+ Sum float64
+ Min float64
+ Max float64
+ }
+
+ statsSG := SG.MakeSemigroup(func(a, b Stats) Stats {
+ return Stats{
+ Count: a.Count + b.Count,
+ Sum: a.Sum + b.Sum,
+ Min: min(a.Min, b.Min),
+ Max: max(a.Max, b.Max),
+ }
+ })
+
+ s1 := Stats{Count: 3, Sum: 15.0, Min: 2.0, Max: 8.0}
+ s2 := Stats{Count: 2, Sum: 12.0, Min: 5.0, Max: 7.0}
+ s3 := Stats{Count: 4, Sum: 20.0, Min: 1.0, Max: 9.0}
+
+ // Aggregate statistics (order doesn't matter due to associativity)
+ total := statsSG.Concat(statsSG.Concat(s1, s2), s3)
+ // Result: Stats{Count: 9, Sum: 47.0, Min: 1.0, Max: 9.0}
+
+Example 4: Building Query Strings
+
+ querySG := SG.MakeSemigroup(func(a, b string) string {
+ if a == "" {
+ return b
+ }
+ if b == "" {
+ return a
+ }
+ return a + "&" + b
+ })
+
+ base := "api/users"
+ filter := "status=active"
+ sort := "sort=name"
+ page := "page=1"
+
+ // Build query string
+ query := querySG.Concat(querySG.Concat(base+"?"+filter, sort), page)
+ // Result: "api/users?status=active&sort=name&page=1"
+
+# Relationship to Other Structures
+
+Semigroup extends Magma by adding the associativity law:
+ - Magma: Has a binary operation
+ - Semigroup: Has an associative binary operation
+ - Monoid: Semigroup with an identity element
+
+Converting between structures:
+
+ // Semigroup to Magma
+ magma := SG.ToMagma(semigroup)
+
+ // Semigroup to Monoid (requires identity element)
+ // See the monoid package
+
+# Laws
+
+A valid Semigroup must satisfy the associativity law:
+
+ // Associativity: (a • b) • c = a • (b • c)
+ s.Concat(s.Concat(a, b), c) == s.Concat(a, s.Concat(b, c))
+
+This law ensures that the order of evaluation doesn't matter, allowing for
+parallel computation and optimization.
+
+# Function Reference
+
+Core Functions:
+ - MakeSemigroup[A](func(A, A) A) Semigroup[A] - Creates a semigroup from a binary operation
+ - Reverse[A](Semigroup[A]) Semigroup[A] - Returns the dual semigroup with swapped arguments
+ - ToMagma[A](Semigroup[A]) Magma[A] - Converts a semigroup to a magma
+
+Built-in Semigroups:
+ - First[A]() Semigroup[A] - Always returns the first argument
+ - Last[A]() Semigroup[A] - Always returns the last argument
+
+Higher-Order Functions:
+ - FunctionSemigroup[A, B](Semigroup[B]) Semigroup[func(A) B] - Lifts a semigroup to functions
+
+Array Operations:
+ - ConcatAll[A](Semigroup[A]) func(A) func([]A) A - Concatenates array elements with initial value
+ - MonadConcatAll[A](Semigroup[A]) func([]A, A) A - Uncurried version of ConcatAll
+ - GenericConcatAll[GA ~[]A, A](Semigroup[A]) func(A) func(GA) A - Generic version for custom slices
+ - GenericMonadConcatAll[GA ~[]A, A](Semigroup[A]) func(GA, A) A - Generic uncurried version
+
+Higher-Kinded Type Operations:
+ - ApplySemigroup[A, HKTA, HKTFA](fmap, fap, Semigroup[A]) Semigroup[HKTA] - Semigroup for applicatives
+ - AltSemigroup[HKTA, LAZYHKTA](falt) Semigroup[HKTA] - Semigroup for alternatives
+
+# Related Packages
+
+ - github.com/IBM/fp-go/v2/magma - Base algebraic structure without associativity
+ - github.com/IBM/fp-go/v2/monoid - Semigroup with identity element
+ - github.com/IBM/fp-go/v2/number - Numeric semigroups (sum, product, min, max)
+ - github.com/IBM/fp-go/v2/string - String semigroups
+ - github.com/IBM/fp-go/v2/array - Array operations using semigroups
+ - github.com/IBM/fp-go/v2/function - Function composition utilities
+*/
+package semigroup
diff --git a/v2/semigroup/ord/semigroup.go b/v2/semigroup/ord/semigroup.go
new file mode 100644
index 0000000..5402e9d
--- /dev/null
+++ b/v2/semigroup/ord/semigroup.go
@@ -0,0 +1,31 @@
+// Copyright (c) 2023 - 2025 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 ord
+
+import (
+ "github.com/IBM/fp-go/v2/ord"
+ S "github.com/IBM/fp-go/v2/semigroup"
+)
+
+// Max gets a semigroup where `concat` will return the maximum, based on the provided order.
+func Max[A any](o ord.Ord[A]) S.Semigroup[A] {
+ return S.MakeSemigroup(ord.Max(o))
+}
+
+// Min gets a semigroup where `concat` will return the minimum, based on the provided order.
+func Min[A any](o ord.Ord[A]) S.Semigroup[A] {
+ return S.MakeSemigroup(ord.Min(o))
+}
diff --git a/v2/semigroup/semigroup.go b/v2/semigroup/semigroup.go
new file mode 100644
index 0000000..882f1ae
--- /dev/null
+++ b/v2/semigroup/semigroup.go
@@ -0,0 +1,66 @@
+// Copyright (c) 2023 - 2025 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 semigroup
+
+import (
+ F "github.com/IBM/fp-go/v2/function"
+ M "github.com/IBM/fp-go/v2/magma"
+)
+
+type Semigroup[A any] interface {
+ M.Magma[A]
+}
+
+type semigroup[A any] struct {
+ c func(A, A) A
+}
+
+func (self semigroup[A]) Concat(x A, y A) A {
+ return self.c(x, y)
+}
+
+func MakeSemigroup[A any](c func(A, A) A) Semigroup[A] {
+ return semigroup[A]{c: c}
+}
+
+// Reverse returns The dual of a `Semigroup`, obtained by swapping the arguments of `concat`.
+func Reverse[A any](m Semigroup[A]) Semigroup[A] {
+ return MakeSemigroup(M.Reverse[A](m).Concat)
+}
+
+// FunctionSemigroup forms a semigroup as long as you can provide a semigroup for the codomain.
+func FunctionSemigroup[A, B any](s Semigroup[B]) Semigroup[func(A) B] {
+ return MakeSemigroup(func(f func(A) B, g func(A) B) func(A) B {
+ return func(a A) B {
+ return s.Concat(f(a), g(a))
+ }
+ })
+}
+
+// First always returns the first argument.
+func First[A any]() Semigroup[A] {
+ return MakeSemigroup(F.First[A, A])
+}
+
+// Last always returns the last argument.
+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
+}
diff --git a/v2/semigroup/semigroup_test.go b/v2/semigroup/semigroup_test.go
new file mode 100644
index 0000000..9f5b481
--- /dev/null
+++ b/v2/semigroup/semigroup_test.go
@@ -0,0 +1,446 @@
+// Copyright (c) 2023 - 2025 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 semigroup
+
+import (
+ "testing"
+
+ M "github.com/IBM/fp-go/v2/magma"
+ "github.com/stretchr/testify/assert"
+)
+
+// Test basic First semigroup
+func TestFirst(t *testing.T) {
+ first := First[int]()
+ assert.Equal(t, 1, first.Concat(1, 2))
+ assert.Equal(t, 10, first.Concat(10, 20))
+ assert.Equal(t, "a", First[string]().Concat("a", "b"))
+}
+
+// Test basic Last semigroup
+func TestLast(t *testing.T) {
+ last := Last[int]()
+ assert.Equal(t, 2, last.Concat(1, 2))
+ assert.Equal(t, 20, last.Concat(10, 20))
+ assert.Equal(t, "b", Last[string]().Concat("a", "b"))
+}
+
+// Test MakeSemigroup
+func TestMakeSemigroup(t *testing.T) {
+ // Integer addition semigroup
+ add := MakeSemigroup(func(a, b int) int { return a + b })
+ assert.Equal(t, 5, add.Concat(2, 3))
+ assert.Equal(t, 10, add.Concat(4, 6))
+
+ // String concatenation semigroup
+ concat := MakeSemigroup(func(a, b string) string { return a + b })
+ assert.Equal(t, "hello", concat.Concat("hel", "lo"))
+ assert.Equal(t, "foobar", concat.Concat("foo", "bar"))
+
+ // Max semigroup
+ max := MakeSemigroup(func(a, b int) int {
+ if a > b {
+ return a
+ }
+ return b
+ })
+ assert.Equal(t, 10, max.Concat(5, 10))
+ assert.Equal(t, 20, max.Concat(20, 15))
+}
+
+// Test Reverse semigroup
+func TestReverse(t *testing.T) {
+ // Subtraction is not commutative, so reverse changes the result
+ sub := MakeSemigroup(func(a, b int) int { return a - b })
+ reversed := Reverse(sub)
+
+ assert.Equal(t, 7, sub.Concat(10, 3)) // 10 - 3 = 7
+ assert.Equal(t, -7, reversed.Concat(10, 3)) // 3 - 10 = -7
+
+ // String concatenation
+ concat := MakeSemigroup(func(a, b string) string { return a + b })
+ reversedConcat := Reverse(concat)
+
+ assert.Equal(t, "ab", concat.Concat("a", "b"))
+ assert.Equal(t, "ba", reversedConcat.Concat("a", "b"))
+}
+
+// Test FunctionSemigroup
+func TestFunctionSemigroup(t *testing.T) {
+ // Base semigroup for integers (addition)
+ add := MakeSemigroup(func(a, b int) int { return a + b })
+
+ // Lift to functions
+ funcSG := FunctionSemigroup[string](add)
+
+ // Create two functions
+ f := func(s string) int { return len(s) }
+ g := func(s string) int { return len(s) * 2 }
+
+ // Combine functions
+ combined := funcSG.Concat(f, g)
+
+ // Test with different strings
+ assert.Equal(t, 15, combined("hello")) // 5 + 10 = 15
+ assert.Equal(t, 9, combined("abc")) // 3 + 6 = 9
+ assert.Equal(t, 0, combined("")) // 0 + 0 = 0
+}
+
+// Test FunctionSemigroup with different types
+func TestFunctionSemigroupMultipleTypes(t *testing.T) {
+ // String concatenation semigroup
+ concat := MakeSemigroup(func(a, b string) string { return a + b })
+
+ // Lift to functions from int to string
+ funcSG := FunctionSemigroup[int](concat)
+
+ f := func(n int) string { return "a" }
+ g := func(n int) string { return "b" }
+
+ combined := funcSG.Concat(f, g)
+ assert.Equal(t, "ab", combined(42))
+}
+
+// Test ToMagma conversion
+func TestToMagma(t *testing.T) {
+ sg := MakeSemigroup(func(a, b int) int { return a + b })
+ magma := ToMagma(sg)
+
+ // Should work as a magma
+ assert.Equal(t, 5, magma.Concat(2, 3))
+ assert.Equal(t, 10, magma.Concat(4, 6))
+
+ // Verify it's a Magma interface
+ var _ M.Magma[int] = magma
+}
+
+// Test ConcatAll
+func TestConcatAll(t *testing.T) {
+ add := MakeSemigroup(func(a, b int) int { return a + b })
+ concatAll := ConcatAll(add)
+
+ // Test with various arrays
+ assert.Equal(t, 10, concatAll(0)([]int{1, 2, 3, 4}))
+ assert.Equal(t, 20, concatAll(10)([]int{1, 2, 3, 4}))
+ assert.Equal(t, 5, concatAll(5)([]int{}))
+ assert.Equal(t, 15, concatAll(0)([]int{15}))
+
+ // Test with string concatenation
+ concat := MakeSemigroup(func(a, b string) string { return a + b })
+ concatAllStr := ConcatAll(concat)
+
+ assert.Equal(t, "hello", concatAllStr("")([]string{"h", "e", "l", "l", "o"}))
+ assert.Equal(t, "prefix_abc", concatAllStr("prefix_")([]string{"a", "b", "c"}))
+}
+
+// Test MonadConcatAll
+func TestMonadConcatAll(t *testing.T) {
+ add := MakeSemigroup(func(a, b int) int { return a + b })
+ monadConcatAll := MonadConcatAll(add)
+
+ // Test with various arrays
+ assert.Equal(t, 10, monadConcatAll([]int{1, 2, 3, 4}, 0))
+ assert.Equal(t, 20, monadConcatAll([]int{1, 2, 3, 4}, 10))
+ assert.Equal(t, 5, monadConcatAll([]int{}, 5))
+ assert.Equal(t, 15, monadConcatAll([]int{15}, 0))
+
+ // Test with multiplication
+ mul := MakeSemigroup(func(a, b int) int { return a * b })
+ monadConcatAllMul := MonadConcatAll(mul)
+
+ assert.Equal(t, 24, monadConcatAllMul([]int{2, 3, 4}, 1))
+ assert.Equal(t, 120, monadConcatAllMul([]int{2, 3, 4, 5}, 1))
+}
+
+// Test GenericConcatAll with custom slice type
+func TestGenericConcatAll(t *testing.T) {
+ type MyInts []int
+
+ add := MakeSemigroup(func(a, b int) int { return a + b })
+ concatAll := GenericConcatAll[MyInts](add)
+
+ assert.Equal(t, 6, concatAll(0)(MyInts{1, 2, 3}))
+ assert.Equal(t, 16, concatAll(10)(MyInts{1, 2, 3}))
+ assert.Equal(t, 5, concatAll(5)(MyInts{}))
+}
+
+// Test GenericMonadConcatAll with custom slice type
+func TestGenericMonadConcatAll(t *testing.T) {
+ type MyInts []int
+
+ add := MakeSemigroup(func(a, b int) int { return a + b })
+ monadConcatAll := GenericMonadConcatAll[MyInts](add)
+
+ assert.Equal(t, 6, monadConcatAll(MyInts{1, 2, 3}, 0))
+ assert.Equal(t, 16, monadConcatAll(MyInts{1, 2, 3}, 10))
+ assert.Equal(t, 5, monadConcatAll(MyInts{}, 5))
+}
+
+// Test ApplySemigroup
+func TestApplySemigroup(t *testing.T) {
+ // Base semigroup for integers
+ add := MakeSemigroup(func(a, b int) int { return a + b })
+
+ // Simple HKT simulation using slices
+ type HKT []int
+
+ fmap := func(hkt HKT, f func(int) func(int) int) []func(int) int {
+ result := make([]func(int) int, len(hkt))
+ for i, v := range hkt {
+ result[i] = f(v)
+ }
+ return result
+ }
+
+ fap := func(fs []func(int) int, hkt HKT) HKT {
+ result := make(HKT, 0)
+ for _, f := range fs {
+ for _, v := range hkt {
+ result = append(result, f(v))
+ }
+ }
+ return result
+ }
+
+ applySG := ApplySemigroup[int, HKT, []func(int) int](fmap, fap, add)
+
+ hkt1 := HKT{1, 2}
+ hkt2 := HKT{3, 4}
+
+ result := applySG.Concat(hkt1, hkt2)
+ // Should apply the semigroup operation to all combinations
+ assert.NotEmpty(t, result)
+}
+
+// Test AltSemigroup
+func TestAltSemigroup(t *testing.T) {
+ // Simple HKT simulation using Option-like type
+ type Option[A any] struct {
+ value A
+ hasValue bool
+ }
+
+ falt := func(first Option[int], second func() Option[int]) Option[int] {
+ if first.hasValue {
+ return first
+ }
+ return second()
+ }
+
+ altSG := AltSemigroup[Option[int], func() Option[int]](falt)
+
+ some := Option[int]{value: 42, hasValue: true}
+ none := Option[int]{hasValue: false}
+ other := Option[int]{value: 100, hasValue: true}
+
+ // First has value, should return first
+ result1 := altSG.Concat(some, none)
+ assert.True(t, result1.hasValue)
+ assert.Equal(t, 42, result1.value)
+
+ // First is none, should return second
+ result2 := altSG.Concat(none, other)
+ assert.True(t, result2.hasValue)
+ assert.Equal(t, 100, result2.value)
+
+ // Both have values, should return first
+ result3 := altSG.Concat(some, other)
+ assert.True(t, result3.hasValue)
+ assert.Equal(t, 42, result3.value)
+}
+
+// Test associativity law for various semigroups
+func TestAssociativityLaw(t *testing.T) {
+ testCases := []struct {
+ name string
+ sg Semigroup[int]
+ a, b, c int
+ }{
+ {"Addition", MakeSemigroup(func(a, b int) int { return a + b }), 1, 2, 3},
+ {"Multiplication", MakeSemigroup(func(a, b int) int { return a * b }), 2, 3, 4},
+ {"Max", MakeSemigroup(func(a, b int) int {
+ if a > b {
+ return a
+ }
+ return b
+ }), 5, 10, 3},
+ {"Min", MakeSemigroup(func(a, b int) int {
+ if a < b {
+ return a
+ }
+ return b
+ }), 5, 10, 3},
+ {"First", First[int](), 1, 2, 3},
+ {"Last", Last[int](), 1, 2, 3},
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ // (a • b) • c
+ left := tc.sg.Concat(tc.sg.Concat(tc.a, tc.b), tc.c)
+ // a • (b • c)
+ right := tc.sg.Concat(tc.a, tc.sg.Concat(tc.b, tc.c))
+
+ assert.Equal(t, left, right, "Associativity law failed for %s", tc.name)
+ })
+ }
+}
+
+// Test associativity law for string semigroups
+func TestAssociativityLawString(t *testing.T) {
+ concat := MakeSemigroup(func(a, b string) string { return a + b })
+
+ a, b, c := "hello", " ", "world"
+
+ left := concat.Concat(concat.Concat(a, b), c)
+ right := concat.Concat(a, concat.Concat(b, c))
+
+ assert.Equal(t, left, right)
+ assert.Equal(t, "hello world", left)
+}
+
+// Test complex types
+func TestComplexTypes(t *testing.T) {
+ type Config struct {
+ Timeout int
+ Retries int
+ }
+
+ configSG := MakeSemigroup(func(a, b Config) Config {
+ maxTimeout := a.Timeout
+ if b.Timeout > maxTimeout {
+ maxTimeout = b.Timeout
+ }
+ return Config{
+ Timeout: maxTimeout,
+ Retries: a.Retries + b.Retries,
+ }
+ })
+
+ c1 := Config{Timeout: 30, Retries: 3}
+ c2 := Config{Timeout: 60, Retries: 5}
+ c3 := Config{Timeout: 45, Retries: 2}
+
+ result := configSG.Concat(configSG.Concat(c1, c2), c3)
+ assert.Equal(t, 60, result.Timeout)
+ assert.Equal(t, 10, result.Retries)
+
+ // Test associativity
+ left := configSG.Concat(configSG.Concat(c1, c2), c3)
+ right := configSG.Concat(c1, configSG.Concat(c2, c3))
+ assert.Equal(t, left, right)
+}
+
+// Test with slices
+func TestSliceSemigroup(t *testing.T) {
+ sliceConcat := MakeSemigroup(func(a, b []int) []int {
+ result := make([]int, len(a)+len(b))
+ copy(result, a)
+ copy(result[len(a):], b)
+ return result
+ })
+
+ s1 := []int{1, 2, 3}
+ s2 := []int{4, 5}
+ s3 := []int{6}
+
+ result := sliceConcat.Concat(sliceConcat.Concat(s1, s2), s3)
+ assert.Equal(t, []int{1, 2, 3, 4, 5, 6}, result)
+
+ // Test associativity
+ left := sliceConcat.Concat(sliceConcat.Concat(s1, s2), s3)
+ right := sliceConcat.Concat(s1, sliceConcat.Concat(s2, s3))
+ assert.Equal(t, left, right)
+}
+
+// Test with maps
+func TestMapSemigroup(t *testing.T) {
+ mapMerge := MakeSemigroup(func(a, b map[string]int) map[string]int {
+ result := make(map[string]int)
+ for k, v := range a {
+ result[k] = v
+ }
+ for k, v := range b {
+ result[k] = v // Later values override
+ }
+ return result
+ })
+
+ m1 := map[string]int{"a": 1, "b": 2}
+ m2 := map[string]int{"b": 3, "c": 4}
+ m3 := map[string]int{"c": 5, "d": 6}
+
+ result := mapMerge.Concat(mapMerge.Concat(m1, m2), m3)
+ assert.Equal(t, 1, result["a"])
+ assert.Equal(t, 3, result["b"])
+ assert.Equal(t, 5, result["c"])
+ assert.Equal(t, 6, result["d"])
+}
+
+// Benchmark tests
+func BenchmarkFirst(b *testing.B) {
+ first := First[int]()
+ for i := 0; i < b.N; i++ {
+ first.Concat(1, 2)
+ }
+}
+
+func BenchmarkLast(b *testing.B) {
+ last := Last[int]()
+ for i := 0; i < b.N; i++ {
+ last.Concat(1, 2)
+ }
+}
+
+func BenchmarkMakeSemigroupAdd(b *testing.B) {
+ add := MakeSemigroup(func(a, b int) int { return a + b })
+ for i := 0; i < b.N; i++ {
+ add.Concat(1, 2)
+ }
+}
+
+func BenchmarkReverse(b *testing.B) {
+ sub := MakeSemigroup(func(a, b int) int { return a - b })
+ reversed := Reverse(sub)
+ for i := 0; i < b.N; i++ {
+ reversed.Concat(10, 3)
+ }
+}
+
+func BenchmarkConcatAll(b *testing.B) {
+ add := MakeSemigroup(func(a, b int) int { return a + b })
+ concatAll := ConcatAll(add)
+ arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ concatAll(0)(arr)
+ }
+}
+
+func BenchmarkFunctionSemigroup(b *testing.B) {
+ add := MakeSemigroup(func(a, b int) int { return a + b })
+ funcSG := FunctionSemigroup[string](add)
+
+ f := func(s string) int { return len(s) }
+ g := func(s string) int { return len(s) * 2 }
+ combined := funcSG.Concat(f, g)
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ combined("hello")
+ }
+}
diff --git a/v2/state/eq.go b/v2/state/eq.go
new file mode 100644
index 0000000..a5b5ba2
--- /dev/null
+++ b/v2/state/eq.go
@@ -0,0 +1,36 @@
+// Copyright (c) 2023 - 2025 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 state
+
+import (
+ "github.com/IBM/fp-go/v2/eq"
+ "github.com/IBM/fp-go/v2/pair"
+)
+
+// Constructs an equal predicate for a [State]
+func Eq[S, A any](w eq.Eq[S], a eq.Eq[A]) func(S) eq.Eq[State[S, A]] {
+ eqp := pair.Eq(w, a)
+ return func(s S) eq.Eq[State[S, A]] {
+ return eq.FromEquals(func(l, r State[S, A]) bool {
+ return eqp.Equals(l(s), r(s))
+ })
+ }
+}
+
+// FromStrictEquals constructs an [eq.Eq] from the canonical comparison function
+func FromStrictEquals[S, A comparable]() func(S) eq.Eq[State[S, A]] {
+ return Eq(eq.FromStrictEquals[S](), eq.FromStrictEquals[A]())
+}
diff --git a/v2/state/monad.go b/v2/state/monad.go
new file mode 100644
index 0000000..851bc96
--- /dev/null
+++ b/v2/state/monad.go
@@ -0,0 +1,87 @@
+// Copyright (c) 2024 - 2025 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 state
+
+import (
+ "github.com/IBM/fp-go/v2/internal/applicative"
+ "github.com/IBM/fp-go/v2/internal/functor"
+ "github.com/IBM/fp-go/v2/internal/monad"
+ "github.com/IBM/fp-go/v2/internal/pointed"
+)
+
+type statePointed[S, A any] struct{}
+
+type stateFunctor[S, A, B any] struct{}
+
+type stateApplicative[S, A, B any] struct{}
+
+type stateMonad[S, A, B any] struct{}
+
+func (o *statePointed[S, A]) Of(a A) State[S, A] {
+ return Of[S](a)
+}
+
+func (o *stateApplicative[S, A, B]) Of(a A) State[S, A] {
+ return Of[S](a)
+}
+
+func (o *stateMonad[S, A, B]) Of(a A) State[S, A] {
+ return Of[S](a)
+}
+
+func (o *stateFunctor[S, A, B]) Map(f func(A) B) func(State[S, A]) State[S, B] {
+ return Map[S](f)
+}
+
+func (o *stateApplicative[S, A, B]) Map(f func(A) B) func(State[S, A]) State[S, B] {
+ return Map[S](f)
+}
+
+func (o *stateMonad[S, A, B]) Map(f func(A) B) func(State[S, A]) State[S, B] {
+ return Map[S](f)
+}
+
+func (o *stateMonad[S, A, B]) Chain(f func(A) State[S, B]) func(State[S, A]) State[S, B] {
+ return Chain(f)
+}
+
+func (o *stateApplicative[S, A, B]) Ap(fa State[S, A]) func(State[S, func(A) B]) State[S, B] {
+ return Ap[B](fa)
+}
+
+func (o *stateMonad[S, A, B]) Ap(fa State[S, A]) func(State[S, func(A) B]) State[S, B] {
+ return Ap[B](fa)
+}
+
+// Pointed implements the pointed operations for [State]
+func Pointed[S, A any]() pointed.Pointed[A, State[S, A]] {
+ return &statePointed[S, A]{}
+}
+
+// Functor implements the functor operations for [State]
+func Functor[S, A, B any]() functor.Functor[A, B, State[S, A], State[S, B]] {
+ return &stateFunctor[S, A, B]{}
+}
+
+// Applicative implements the applicative operations for [State]
+func Applicative[S, A, B any]() applicative.Applicative[A, B, State[S, A], State[S, B], State[S, func(A) B]] {
+ return &stateApplicative[S, A, B]{}
+}
+
+// Monad implements the monadic operations for [State]
+func Monad[S, A, B any]() monad.Monad[A, B, State[S, A], State[S, B], State[S, func(A) B]] {
+ return &stateMonad[S, A, B]{}
+}
diff --git a/v2/state/state.go b/v2/state/state.go
new file mode 100644
index 0000000..4edd377
--- /dev/null
+++ b/v2/state/state.go
@@ -0,0 +1,133 @@
+// Copyright (c) 2024 - 2025 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 state
+
+import (
+ "github.com/IBM/fp-go/v2/function"
+ "github.com/IBM/fp-go/v2/internal/chain"
+ "github.com/IBM/fp-go/v2/internal/functor"
+ "github.com/IBM/fp-go/v2/pair"
+)
+
+var (
+ undefined any = struct{}{}
+)
+
+func Get[S any]() State[S, S] {
+ return pair.Of[S]
+}
+
+func Gets[FCT ~func(S) A, A, S any](f FCT) State[S, A] {
+ return func(s S) Pair[S, A] {
+ return pair.MakePair(s, f(s))
+ }
+}
+
+func Put[S any]() State[S, any] {
+ return function.Bind2nd(pair.MakePair[S, any], undefined)
+}
+
+func Modify[FCT ~func(S) S, S any](f FCT) State[S, any] {
+ return function.Flow2(
+ f,
+ function.Bind2nd(pair.MakePair[S, any], undefined),
+ )
+}
+
+func Of[S, A any](a A) State[S, A] {
+ return function.Bind2nd(pair.MakePair[S, A], a)
+}
+
+func MonadMap[S any, FCT ~func(A) B, A, B any](fa State[S, A], f FCT) State[S, B] {
+ return func(s S) Pair[S, B] {
+ p2 := fa(s)
+ return pair.MakePair(pair.Head(p2), f(pair.Tail(p2)))
+ }
+}
+
+func Map[S any, FCT ~func(A) B, A, B any](f FCT) Operator[S, A, B] {
+ return function.Bind2nd(MonadMap[S, FCT, A, B], f)
+}
+
+func MonadChain[S any, FCT ~func(A) State[S, B], A, B any](fa State[S, A], f FCT) State[S, B] {
+ return func(s S) Pair[S, B] {
+ a := fa(s)
+ return f(pair.Tail(a))(pair.Head(a))
+ }
+}
+
+func Chain[S any, FCT ~func(A) State[S, B], A, B any](f FCT) Operator[S, A, B] {
+ return function.Bind2nd(MonadChain[S, FCT, A, B], f)
+}
+
+func MonadAp[B, S, A any](fab State[S, func(A) B], fa State[S, A]) State[S, B] {
+ return func(s S) Pair[S, B] {
+ f := fab(s)
+ a := fa(pair.Head(f))
+
+ return pair.MakePair(pair.Head(a), pair.Tail(f)(pair.Tail(a)))
+ }
+}
+
+func Ap[B, S, A any](ga State[S, A]) Operator[S, func(A) B, B] {
+ return function.Bind2nd(MonadAp[B, S, A], ga)
+}
+
+func MonadChainFirst[S any, FCT ~func(A) State[S, B], A, B any](ma State[S, A], f FCT) State[S, A] {
+ return chain.MonadChainFirst(
+ MonadChain[S, func(A) State[S, A], A, A],
+ MonadMap[S, func(B) A],
+ ma,
+ f,
+ )
+}
+
+func ChainFirst[S any, FCT ~func(A) State[S, B], A, B any](f FCT) Operator[S, A, A] {
+ return chain.ChainFirst(
+ Chain[S, func(A) State[S, A], A, A],
+ Map[S, func(B) A],
+ f,
+ )
+}
+
+func Flatten[S, A any](mma State[S, State[S, A]]) State[S, A] {
+ return MonadChain(mma, function.Identity[State[S, A]])
+}
+
+func Execute[A, S any](s S) func(State[S, A]) S {
+ return func(fa State[S, A]) S {
+ return pair.Head(fa(s))
+ }
+}
+
+func Evaluate[A, S any](s S) func(State[S, A]) A {
+ return func(fa State[S, A]) A {
+ return pair.Tail(fa(s))
+ }
+}
+
+func MonadFlap[FAB ~func(A) B, S, A, B any](fab State[S, FAB], a A) State[S, B] {
+ return functor.MonadFlap(
+ MonadMap[S, func(FAB) B],
+ fab,
+ a)
+}
+
+func Flap[S, A, B any](a A) Operator[S, func(A) B, B] {
+ return functor.Flap(
+ Map[S, func(func(A) B) B],
+ a)
+}
diff --git a/v2/state/testing/laws.go b/v2/state/testing/laws.go
new file mode 100644
index 0000000..6b08347
--- /dev/null
+++ b/v2/state/testing/laws.go
@@ -0,0 +1,78 @@
+// Copyright (c) 2023 - 2025 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 testing
+
+import (
+ "testing"
+
+ EQ "github.com/IBM/fp-go/v2/eq"
+ L "github.com/IBM/fp-go/v2/internal/monad/testing"
+ ST "github.com/IBM/fp-go/v2/state"
+)
+
+// AssertLaws asserts the apply monad laws for the `Either` monad
+func AssertLaws[S, A, B, C any](t *testing.T,
+ eqw EQ.Eq[S],
+ eqa EQ.Eq[A],
+ eqb EQ.Eq[B],
+ eqc EQ.Eq[C],
+
+ ab func(A) B,
+ bc func(B) C,
+
+ s S,
+) func(a A) bool {
+
+ fofc := ST.Pointed[S, C]()
+ fofaa := ST.Pointed[S, func(A) A]()
+ fofbc := ST.Pointed[S, func(B) C]()
+ fofabb := ST.Pointed[S, func(func(A) B) B]()
+
+ fmap := ST.Functor[S, func(B) C, func(func(A) B) func(A) C]()
+
+ fapabb := ST.Applicative[S, func(A) B, B]()
+ fapabac := ST.Applicative[S, func(A) B, func(A) C]()
+
+ maa := ST.Monad[S, A, A]()
+ mab := ST.Monad[S, A, B]()
+ mac := ST.Monad[S, A, C]()
+ mbc := ST.Monad[S, B, C]()
+
+ return L.MonadAssertLaws(t,
+ ST.Eq(eqw, eqa)(s),
+ ST.Eq(eqw, eqb)(s),
+ ST.Eq(eqw, eqc)(s),
+
+ fofc,
+ fofaa,
+ fofbc,
+ fofabb,
+
+ fmap,
+
+ fapabb,
+ fapabac,
+
+ maa,
+ mab,
+ mac,
+ mbc,
+
+ ab,
+ bc,
+ )
+
+}
diff --git a/v2/state/testing/laws_test.go b/v2/state/testing/laws_test.go
new file mode 100644
index 0000000..32dbd51
--- /dev/null
+++ b/v2/state/testing/laws_test.go
@@ -0,0 +1,49 @@
+// Copyright (c) 2023 - 2025 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 testing
+
+import (
+ "fmt"
+ "testing"
+
+ A "github.com/IBM/fp-go/v2/array"
+ EQ "github.com/IBM/fp-go/v2/eq"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestMonadLaws(t *testing.T) {
+ // some comparison
+ eqs := A.Eq[string](EQ.FromStrictEquals[string]())
+ eqa := EQ.FromStrictEquals[bool]()
+ eqb := EQ.FromStrictEquals[int]()
+ eqc := EQ.FromStrictEquals[string]()
+
+ ab := func(a bool) int {
+ if a {
+ return 1
+ }
+ return 0
+ }
+
+ bc := func(b int) string {
+ return fmt.Sprintf("value %d", b)
+ }
+
+ laws := AssertLaws(t, eqs, eqa, eqb, eqc, ab, bc, A.Empty[string]())
+
+ assert.True(t, laws(true))
+ assert.True(t, laws(false))
+}
diff --git a/v2/state/types.go b/v2/state/types.go
new file mode 100644
index 0000000..588cf0b
--- /dev/null
+++ b/v2/state/types.go
@@ -0,0 +1,32 @@
+// Copyright (c) 2024 - 2025 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 state
+
+import (
+ "github.com/IBM/fp-go/v2/pair"
+ "github.com/IBM/fp-go/v2/reader"
+)
+
+type (
+ // some type aliases
+ Reader[R, A any] = reader.Reader[R, A]
+ Pair[L, R any] = pair.Pair[L, R]
+
+ // State represents an operation on top of a current [State] that produces a value and a new [State]
+ State[S, A any] = Reader[S, pair.Pair[S, A]]
+
+ Operator[S, A, B any] = Reader[State[S, A], State[S, B]]
+)
diff --git a/v2/statereaderioeither/eq.go b/v2/statereaderioeither/eq.go
new file mode 100644
index 0000000..1aebeb6
--- /dev/null
+++ b/v2/statereaderioeither/eq.go
@@ -0,0 +1,41 @@
+// Copyright (c) 2024 - 2025 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 statereaderioeither
+
+import (
+ "github.com/IBM/fp-go/v2/eq"
+ "github.com/IBM/fp-go/v2/function"
+ "github.com/IBM/fp-go/v2/readerioeither"
+)
+
+// Eq implements the equals predicate for values contained in the [StateReaderIOEither] monad
+func Eq[
+ S, R, E, A any](eqr eq.Eq[ReaderIOEither[R, E, Pair[S, A]]]) func(S) eq.Eq[StateReaderIOEither[S, R, E, A]] {
+ return func(s S) eq.Eq[StateReaderIOEither[S, R, E, A]] {
+ return eq.FromEquals(func(l, r StateReaderIOEither[S, R, E, A]) bool {
+ return eqr.Equals(l(s), r(s))
+ })
+ }
+}
+
+// FromStrictEquals constructs an [eq.Eq] from the canonical comparison function
+func FromStrictEquals[
+ S, R any, E, A comparable]() func(R) func(S) eq.Eq[StateReaderIOEither[S, R, E, A]] {
+ return function.Flow2(
+ readerioeither.FromStrictEquals[R, E, Pair[S, A]](),
+ Eq[S, R, E, A],
+ )
+}
diff --git a/v2/statereaderioeither/monad.go b/v2/statereaderioeither/monad.go
new file mode 100644
index 0000000..1149aae
--- /dev/null
+++ b/v2/statereaderioeither/monad.go
@@ -0,0 +1,103 @@
+// Copyright (c) 2024 - 2025 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 statereaderioeither
+
+import (
+ "github.com/IBM/fp-go/v2/internal/applicative"
+ "github.com/IBM/fp-go/v2/internal/functor"
+ "github.com/IBM/fp-go/v2/internal/monad"
+ "github.com/IBM/fp-go/v2/internal/pointed"
+)
+
+type stateReaderIOEitherPointed[
+ S, R, E, A any,
+] struct{}
+
+type stateReaderIOEitherFunctor[
+ S, R, E, A, B any,
+] struct{}
+
+type stateReaderIOEitherApplicative[
+ S, R, E, A, B any,
+] struct{}
+
+type stateReaderIOEitherMonad[
+ S, R, E, A, B any,
+] struct{}
+
+func (o *stateReaderIOEitherPointed[S, R, E, A]) Of(a A) StateReaderIOEither[S, R, E, A] {
+ return Of[S, R, E](a)
+}
+
+func (o *stateReaderIOEitherMonad[S, R, E, A, B]) Of(a A) StateReaderIOEither[S, R, E, A] {
+ return Of[S, R, E](a)
+}
+
+func (o *stateReaderIOEitherApplicative[S, R, E, A, B]) Of(a A) StateReaderIOEither[S, R, E, A] {
+ return Of[S, R, E](a)
+}
+
+func (o *stateReaderIOEitherMonad[S, R, E, A, B]) Map(f func(A) B) Operator[S, R, E, A, B] {
+ return Map[S, R, E](f)
+}
+
+func (o *stateReaderIOEitherApplicative[S, R, E, A, B]) Map(f func(A) B) Operator[S, R, E, A, B] {
+ return Map[S, R, E](f)
+}
+
+func (o *stateReaderIOEitherFunctor[S, R, E, A, B]) Map(f func(A) B) Operator[S, R, E, A, B] {
+ return Map[S, R, E](f)
+}
+
+func (o *stateReaderIOEitherMonad[S, R, E, A, B]) Chain(f func(A) StateReaderIOEither[S, R, E, B]) Operator[S, R, E, A, B] {
+ return Chain(f)
+}
+
+func (o *stateReaderIOEitherMonad[S, R, E, A, B]) Ap(fa StateReaderIOEither[S, R, E, A]) Operator[S, R, E, func(A) B, B] {
+ return Ap[B](fa)
+}
+
+func (o *stateReaderIOEitherApplicative[S, R, E, A, B]) Ap(fa StateReaderIOEither[S, R, E, A]) Operator[S, R, E, func(A) B, B] {
+ return Ap[B](fa)
+}
+
+// Pointed implements the [pointed.Pointed] operations for [StateReaderIOEither]
+func Pointed[
+ S, R, E, A any,
+]() pointed.Pointed[A, StateReaderIOEither[S, R, E, A]] {
+ return &stateReaderIOEitherPointed[S, R, E, A]{}
+}
+
+// Functor implements the [functor.Functor] operations for [StateReaderIOEither]
+func Functor[
+ S, R, E, A, B any,
+]() functor.Functor[A, B, StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B]] {
+ return &stateReaderIOEitherFunctor[S, R, E, A, B]{}
+}
+
+// Applicative implements the [applicative.Applicative] operations for [StateReaderIOEither]
+func Applicative[
+ S, R, E, A, B any,
+]() applicative.Applicative[A, B, StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B], StateReaderIOEither[S, R, E, func(A) B]] {
+ return &stateReaderIOEitherApplicative[S, R, E, A, B]{}
+}
+
+// Monad implements the [monad.Monad] operations for [StateReaderIOEither]
+func Monad[
+ S, R, E, A, B any,
+]() monad.Monad[A, B, StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B], StateReaderIOEither[S, R, E, func(A) B]] {
+ return &stateReaderIOEitherMonad[S, R, E, A, B]{}
+}
diff --git a/v2/statereaderioeither/state.go b/v2/statereaderioeither/state.go
new file mode 100644
index 0000000..640f747
--- /dev/null
+++ b/v2/statereaderioeither/state.go
@@ -0,0 +1,185 @@
+// Copyright (c) 2024 - 2025 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 statereaderioeither
+
+import (
+ "github.com/IBM/fp-go/v2/either"
+ "github.com/IBM/fp-go/v2/function"
+ "github.com/IBM/fp-go/v2/internal/statet"
+ "github.com/IBM/fp-go/v2/readerioeither"
+)
+
+func Left[S, R, A, E any](e E) StateReaderIOEither[S, R, E, A] {
+ return function.Constant1[S](readerioeither.Left[R, Pair[S, A]](e))
+}
+
+func Right[S, R, E, A any](a A) StateReaderIOEither[S, R, E, A] {
+ return statet.Of[StateReaderIOEither[S, R, E, A]](readerioeither.Of[R, E, Pair[S, A]], a)
+}
+
+func Of[S, R, E, A any](a A) StateReaderIOEither[S, R, E, A] {
+ return Right[S, R, E](a)
+}
+
+func MonadMap[S, R, E, A, B any](fa StateReaderIOEither[S, R, E, A], f func(A) B) StateReaderIOEither[S, R, E, B] {
+ return statet.MonadMap[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B]](
+ readerioeither.MonadMap[R, E, Pair[S, A], Pair[S, B]],
+ fa,
+ f,
+ )
+}
+
+func Map[S, R, E, A, B any](f func(A) B) Operator[S, R, E, A, B] {
+ return statet.Map[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B]](
+ readerioeither.Map[R, E, Pair[S, A], Pair[S, B]],
+ f,
+ )
+}
+
+func MonadChain[S, R, E, A, B any](fa StateReaderIOEither[S, R, E, A], f func(A) StateReaderIOEither[S, R, E, B]) StateReaderIOEither[S, R, E, B] {
+ return statet.MonadChain(
+ readerioeither.MonadChain[R, E, Pair[S, A], Pair[S, B]],
+ fa,
+ f,
+ )
+}
+
+func Chain[S, R, E, A, B any](f func(A) StateReaderIOEither[S, R, E, B]) Operator[S, R, E, A, B] {
+ return statet.Chain[StateReaderIOEither[S, R, E, A]](
+ readerioeither.Chain[R, E, Pair[S, A], Pair[S, B]],
+ f,
+ )
+}
+
+func MonadAp[B, S, R, E, A any](fab StateReaderIOEither[S, R, E, func(A) B], fa StateReaderIOEither[S, R, E, A]) StateReaderIOEither[S, R, E, B] {
+ return statet.MonadAp[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B]](
+ readerioeither.MonadMap[R, E, Pair[S, A], Pair[S, B]],
+ readerioeither.MonadChain[R, E, Pair[S, func(A) B], Pair[S, B]],
+ fab,
+ fa,
+ )
+}
+
+func Ap[B, S, R, E, A any](fa StateReaderIOEither[S, R, E, A]) Operator[S, R, E, func(A) B, B] {
+ return statet.Ap[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B], StateReaderIOEither[S, R, E, func(A) B]](
+ readerioeither.Map[R, E, Pair[S, A], Pair[S, B]],
+ readerioeither.Chain[R, E, Pair[S, func(A) B], Pair[S, B]],
+ fa,
+ )
+}
+
+func FromReaderIOEither[S, R, E, A any](fa readerioeither.ReaderIOEither[R, E, A]) StateReaderIOEither[S, R, E, A] {
+ return statet.FromF[StateReaderIOEither[S, R, E, A]](
+ readerioeither.MonadMap[R, E, A],
+ fa,
+ )
+}
+
+func FromReaderEither[S, R, E, A any](fa ReaderEither[R, E, A]) StateReaderIOEither[S, R, E, A] {
+ return FromReaderIOEither[S](readerioeither.FromReaderEither(fa))
+}
+
+func FromIOEither[S, R, E, A any](fa IOEither[E, A]) StateReaderIOEither[S, R, E, A] {
+ return FromReaderIOEither[S](readerioeither.FromIOEither[R](fa))
+}
+
+func FromState[R, E, S, A any](sa State[S, A]) StateReaderIOEither[S, R, E, A] {
+ return statet.FromState[StateReaderIOEither[S, R, E, A]](readerioeither.Of[R, E, Pair[S, A]], sa)
+}
+
+func FromIO[S, R, E, A any](fa IO[A]) StateReaderIOEither[S, R, E, A] {
+ return FromReaderIOEither[S](readerioeither.FromIO[R, E](fa))
+}
+
+func FromReader[S, E, R, A any](fa Reader[R, A]) StateReaderIOEither[S, R, E, A] {
+ return FromReaderIOEither[S](readerioeither.FromReader[E](fa))
+}
+
+func FromEither[S, R, E, A any](ma Either[E, A]) StateReaderIOEither[S, R, E, A] {
+ return either.MonadFold(ma, Left[S, R, A, E], Right[S, R, E, A])
+}
+
+// Combinators
+
+func Local[S, E, A, B, R1, R2 any](f func(R2) R1) func(StateReaderIOEither[S, R1, E, A]) StateReaderIOEither[S, R2, E, A] {
+ return func(ma StateReaderIOEither[S, R1, E, A]) StateReaderIOEither[S, R2, E, A] {
+ return function.Flow2(ma, readerioeither.Local[R1, R2, E, Pair[S, A]](f))
+ }
+}
+
+func Asks[
+ S, R, E, A any,
+](f func(R) StateReaderIOEither[S, R, E, A]) StateReaderIOEither[S, R, E, A] {
+ return func(s S) ReaderIOEither[R, E, Pair[S, A]] {
+ return func(r R) IOEither[E, Pair[S, A]] {
+ return f(r)(s)(r)
+ }
+ }
+}
+
+func FromEitherK[S, R, E, A, B any](f func(A) Either[E, B]) func(A) StateReaderIOEither[S, R, E, B] {
+ return function.Flow2(
+ f,
+ FromEither[S, R, E, B],
+ )
+}
+
+func FromIOK[S, R, E, A, B any](f func(A) IO[B]) func(A) StateReaderIOEither[S, R, E, B] {
+ return function.Flow2(
+ f,
+ FromIO[S, R, E, B],
+ )
+}
+
+func FromIOEitherK[
+ S, R, E, A, B any,
+](f func(A) IOEither[E, B]) func(A) StateReaderIOEither[S, R, E, B] {
+ return function.Flow2(
+ f,
+ FromIOEither[S, R, E, B],
+ )
+}
+
+func FromReaderIOEitherK[S, R, E, A, B any](f func(A) readerioeither.ReaderIOEither[R, E, B]) func(A) StateReaderIOEither[S, R, E, B] {
+ return function.Flow2(
+ f,
+ FromReaderIOEither[S, R, E, B],
+ )
+}
+
+func MonadChainReaderIOEitherK[S, R, E, A, B any](ma StateReaderIOEither[S, R, E, A], f func(A) readerioeither.ReaderIOEither[R, E, B]) StateReaderIOEither[S, R, E, B] {
+ return MonadChain(ma, FromReaderIOEitherK[S](f))
+}
+
+func ChainReaderIOEitherK[S, R, E, A, B any](f func(A) readerioeither.ReaderIOEither[R, E, B]) Operator[S, R, E, A, B] {
+ return Chain(FromReaderIOEitherK[S](f))
+}
+
+func MonadChainIOEitherK[S, R, E, A, B any](ma StateReaderIOEither[S, R, E, A], f func(A) IOEither[E, B]) StateReaderIOEither[S, R, E, B] {
+ return MonadChain(ma, FromIOEitherK[S, R](f))
+}
+
+func ChainIOEitherK[S, R, E, A, B any](f func(A) IOEither[E, B]) Operator[S, R, E, A, B] {
+ return Chain(FromIOEitherK[S, R](f))
+}
+
+func MonadChainEitherK[S, R, E, A, B any](ma StateReaderIOEither[S, R, E, A], f func(A) Either[E, B]) StateReaderIOEither[S, R, E, B] {
+ return MonadChain(ma, FromEitherK[S, R](f))
+}
+
+func ChainEitherK[S, R, E, A, B any](f func(A) Either[E, B]) Operator[S, R, E, A, B] {
+ return Chain(FromEitherK[S, R](f))
+}
diff --git a/v2/statereaderioeither/testing/laws.go b/v2/statereaderioeither/testing/laws.go
new file mode 100644
index 0000000..afdb9cd
--- /dev/null
+++ b/v2/statereaderioeither/testing/laws.go
@@ -0,0 +1,87 @@
+// Copyright (c) 2024 - 2025 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 testing
+
+import (
+ "testing"
+
+ ET "github.com/IBM/fp-go/v2/either"
+ EQ "github.com/IBM/fp-go/v2/eq"
+ L "github.com/IBM/fp-go/v2/internal/monad/testing"
+ P "github.com/IBM/fp-go/v2/pair"
+ RIOE "github.com/IBM/fp-go/v2/readerioeither"
+ ST "github.com/IBM/fp-go/v2/statereaderioeither"
+)
+
+// AssertLaws asserts the apply monad laws for the `Either` monad
+func AssertLaws[S, E, R, A, B, C any](t *testing.T,
+ eqs EQ.Eq[S],
+ eqe EQ.Eq[E],
+ eqa EQ.Eq[A],
+ eqb EQ.Eq[B],
+ eqc EQ.Eq[C],
+
+ ab func(A) B,
+ bc func(B) C,
+
+ s S,
+ r R,
+) func(a A) bool {
+
+ eqra := RIOE.Eq[R](ET.Eq(eqe, P.Eq(eqs, eqa)))(r)
+ eqrb := RIOE.Eq[R](ET.Eq(eqe, P.Eq(eqs, eqb)))(r)
+ eqrc := RIOE.Eq[R](ET.Eq(eqe, P.Eq(eqs, eqc)))(r)
+
+ fofc := ST.Pointed[S, R, E, C]()
+ fofaa := ST.Pointed[S, R, E, func(A) A]()
+ fofbc := ST.Pointed[S, R, E, func(B) C]()
+ fofabb := ST.Pointed[S, R, E, func(func(A) B) B]()
+
+ fmap := ST.Functor[S, R, E, func(B) C, func(func(A) B) func(A) C]()
+
+ fapabb := ST.Applicative[S, R, E, func(A) B, B]()
+ fapabac := ST.Applicative[S, R, E, func(A) B, func(A) C]()
+
+ maa := ST.Monad[S, R, E, A, A]()
+ mab := ST.Monad[S, R, E, A, B]()
+ mac := ST.Monad[S, R, E, A, C]()
+ mbc := ST.Monad[S, R, E, B, C]()
+
+ return L.MonadAssertLaws(t,
+ ST.Eq(eqra)(s),
+ ST.Eq(eqrb)(s),
+ ST.Eq(eqrc)(s),
+
+ fofc,
+ fofaa,
+ fofbc,
+ fofabb,
+
+ fmap,
+
+ fapabb,
+ fapabac,
+
+ maa,
+ mab,
+ mac,
+ mbc,
+
+ ab,
+ bc,
+ )
+
+}
diff --git a/v2/statereaderioeither/testing/laws_test.go b/v2/statereaderioeither/testing/laws_test.go
new file mode 100644
index 0000000..c05ffaa
--- /dev/null
+++ b/v2/statereaderioeither/testing/laws_test.go
@@ -0,0 +1,51 @@
+// Copyright (c) 2023 - 2025 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 testing
+
+import (
+ "context"
+ "fmt"
+ "testing"
+
+ A "github.com/IBM/fp-go/v2/array"
+ EQ "github.com/IBM/fp-go/v2/eq"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestMonadLaws(t *testing.T) {
+ // some comparison
+ eqs := A.Eq(EQ.FromStrictEquals[string]())
+ eqe := EQ.FromStrictEquals[error]()
+ eqa := EQ.FromStrictEquals[bool]()
+ eqb := EQ.FromStrictEquals[int]()
+ eqc := EQ.FromStrictEquals[string]()
+
+ ab := func(a bool) int {
+ if a {
+ return 1
+ }
+ return 0
+ }
+
+ bc := func(b int) string {
+ return fmt.Sprintf("value %d", b)
+ }
+
+ laws := AssertLaws(t, eqs, eqe, eqa, eqb, eqc, ab, bc, A.Empty[string](), context.Background())
+
+ assert.True(t, laws(true))
+ assert.True(t, laws(false))
+}
diff --git a/v2/statereaderioeither/type.go b/v2/statereaderioeither/type.go
new file mode 100644
index 0000000..df28f61
--- /dev/null
+++ b/v2/statereaderioeither/type.go
@@ -0,0 +1,40 @@
+// Copyright (c) 2024 - 2025 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 statereaderioeither
+
+import (
+ "github.com/IBM/fp-go/v2/either"
+ "github.com/IBM/fp-go/v2/io"
+ "github.com/IBM/fp-go/v2/ioeither"
+ "github.com/IBM/fp-go/v2/pair"
+ "github.com/IBM/fp-go/v2/reader"
+ "github.com/IBM/fp-go/v2/readereither"
+ "github.com/IBM/fp-go/v2/readerioeither"
+ "github.com/IBM/fp-go/v2/state"
+)
+
+type (
+ State[S, A any] = state.State[S, A]
+ Pair[L, R any] = pair.Pair[L, R]
+ Reader[R, A any] = reader.Reader[R, A]
+ Either[E, A any] = either.Either[E, A]
+ IO[A any] = io.IO[A]
+ IOEither[E, A any] = ioeither.IOEither[E, A]
+ ReaderIOEither[R, E, A any] = readerioeither.ReaderIOEither[R, E, A]
+ ReaderEither[R, E, A any] = readereither.ReaderEither[R, E, A]
+ StateReaderIOEither[S, R, E, A any] = Reader[S, ReaderIOEither[R, E, Pair[S, A]]]
+ Operator[S, R, E, A, B any] = Reader[StateReaderIOEither[S, R, E, A], StateReaderIOEither[S, R, E, B]]
+)
diff --git a/v2/string/generic/string.go b/v2/string/generic/string.go
new file mode 100644
index 0000000..584cdb9
--- /dev/null
+++ b/v2/string/generic/string.go
@@ -0,0 +1,41 @@
+// Copyright (c) 2023 - 2025 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
+
+// ToBytes converts the string to bytes
+func ToBytes[T ~string](s T) []byte {
+ return []byte(s)
+}
+
+// ToRunes converts the string to runes
+func ToRunes[T ~string](s T) []rune {
+ return []rune(s)
+}
+
+// IsEmpty tests if the string is empty
+func IsEmpty[T ~string](s T) bool {
+ return len(s) == 0
+}
+
+// IsNonEmpty tests if the string is not empty
+func IsNonEmpty[T ~string](s T) bool {
+ return len(s) > 0
+}
+
+// Size returns the size of the string
+func Size[T ~string](s T) int {
+ return len(s)
+}
diff --git a/v2/string/monoid.go b/v2/string/monoid.go
new file mode 100644
index 0000000..04e8a3f
--- /dev/null
+++ b/v2/string/monoid.go
@@ -0,0 +1,23 @@
+// Copyright (c) 2023 - 2025 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 string
+
+import (
+ M "github.com/IBM/fp-go/v2/monoid"
+)
+
+// Monoid is the monoid implementing string concatenation
+var Monoid = M.MakeMonoid(concat, "")
diff --git a/v2/string/monoid_test.go b/v2/string/monoid_test.go
new file mode 100644
index 0000000..ef77f42
--- /dev/null
+++ b/v2/string/monoid_test.go
@@ -0,0 +1,26 @@
+// Copyright (c) 2023 - 2025 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 string
+
+import (
+ "testing"
+
+ M "github.com/IBM/fp-go/v2/monoid/testing"
+)
+
+func TestMonoid(t *testing.T) {
+ M.AssertLaws(t, Monoid)([]string{"", "a", "some value"})
+}
diff --git a/v2/string/semigroup.go b/v2/string/semigroup.go
new file mode 100644
index 0000000..e1c000a
--- /dev/null
+++ b/v2/string/semigroup.go
@@ -0,0 +1,30 @@
+// Copyright (c) 2023 - 2025 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 string
+
+import (
+ "fmt"
+
+ S "github.com/IBM/fp-go/v2/semigroup"
+)
+
+func concat(left string, right string) string {
+ return fmt.Sprintf("%s%s", left, right)
+}
+
+func Semigroup() S.Semigroup[string] {
+ return S.MakeSemigroup(concat)
+}
diff --git a/v2/string/string.go b/v2/string/string.go
new file mode 100644
index 0000000..398ddbf
--- /dev/null
+++ b/v2/string/string.go
@@ -0,0 +1,75 @@
+// Copyright (c) 2023 - 2025 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 string
+
+import (
+ "fmt"
+ "strings"
+
+ F "github.com/IBM/fp-go/v2/function"
+ "github.com/IBM/fp-go/v2/ord"
+)
+
+var (
+ // ToUpperCase converts the string to uppercase
+ ToUpperCase = strings.ToUpper
+
+ // ToLowerCase converts the string to lowercase
+ ToLowerCase = strings.ToLower
+
+ // Ord implements the default ordering for strings
+ Ord = ord.FromStrictCompare[string]()
+
+ // Join joins strings
+ Join = F.Curry2(F.Bind2nd[[]string, string, string])(strings.Join)
+
+ // Equals returns a predicate that tests if a string is equal
+ Equals = F.Curry2(Eq)
+
+ // Includes returns a predicate that tests for the existence of the search string
+ Includes = F.Curry2(F.Swap(strings.Contains))
+)
+
+func Eq(left string, right string) bool {
+ return left == right
+}
+
+func ToBytes(s string) []byte {
+ return []byte(s)
+}
+
+func ToRunes(s string) []rune {
+ return []rune(s)
+}
+
+func IsEmpty(s string) bool {
+ return len(s) == 0
+}
+
+func IsNonEmpty(s string) bool {
+ return len(s) > 0
+}
+
+func Size(s string) int {
+ return len(s)
+}
+
+// Format applies a format string to an arbitrary value
+func Format[T any](format string) func(t T) string {
+ return func(t T) string {
+ return fmt.Sprintf(format, t)
+ }
+}
diff --git a/v2/string/string_test.go b/v2/string/string_test.go
new file mode 100644
index 0000000..a966208
--- /dev/null
+++ b/v2/string/string_test.go
@@ -0,0 +1,50 @@
+// Copyright (c) 2023 - 2025 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 string
+
+import (
+ "testing"
+
+ A "github.com/IBM/fp-go/v2/array"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestEmpty(t *testing.T) {
+ assert.True(t, IsEmpty(""))
+ assert.False(t, IsEmpty("Carsten"))
+}
+
+func TestJoin(t *testing.T) {
+
+ x := Join(",")(A.From("a", "b", "c"))
+ assert.Equal(t, x, x)
+
+ assert.Equal(t, "a,b,c", Join(",")(A.From("a", "b", "c")))
+ assert.Equal(t, "a", Join(",")(A.From("a")))
+ assert.Equal(t, "", Join(",")(A.Empty[string]()))
+}
+
+func TestEquals(t *testing.T) {
+ assert.True(t, Equals("a")("a"))
+ assert.False(t, Equals("a")("b"))
+ assert.False(t, Equals("b")("a"))
+}
+
+func TestIncludes(t *testing.T) {
+ assert.True(t, Includes("a")("bab"))
+ assert.False(t, Includes("bab")("a"))
+ assert.False(t, Includes("b")("a"))
+}
diff --git a/v2/tuple/doc.go b/v2/tuple/doc.go
new file mode 100644
index 0000000..52b04ef
--- /dev/null
+++ b/v2/tuple/doc.go
@@ -0,0 +1,169 @@
+// Copyright (c) 2023 - 2025 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 tuple provides type-safe heterogeneous tuple data structures and operations.
+//
+// Tuples are immutable data structures that can hold a fixed number of values of different types.
+// Unlike arrays or slices which hold homogeneous data, tuples can contain values of different types
+// at compile-time known positions.
+//
+// # Tuple Types
+//
+// The package provides tuple types from Tuple1 to Tuple15, where the number indicates how many
+// elements the tuple contains. Each tuple type is generic over its element types:
+//
+// Tuple1[T1] // Single element
+// Tuple2[T1, T2] // Pair
+// Tuple3[T1, T2, T3] // Triple
+// // ... up to Tuple15
+//
+// # Creating Tuples
+//
+// Tuples can be created using the MakeTupleN functions:
+//
+// t2 := tuple.MakeTuple2("hello", 42) // Tuple2[string, int]
+// t3 := tuple.MakeTuple3(1.5, true, "world") // Tuple3[float64, bool, string]
+//
+// For single-element tuples, you can also use the Of function:
+//
+// t1 := tuple.Of(42) // Equivalent to MakeTuple1(42)
+//
+// # Accessing Elements
+//
+// Tuple elements are accessed via their F1, F2, F3, ... fields:
+//
+// t := tuple.MakeTuple2("hello", 42)
+// s := t.F1 // "hello"
+// n := t.F2 // 42
+//
+// For Tuple2, convenience accessors are provided:
+//
+// s := tuple.First(t) // Same as t.F1
+// n := tuple.Second(t) // Same as t.F2
+//
+// # Transforming Tuples
+//
+// The package provides several transformation functions:
+//
+// Map functions transform each element independently:
+//
+// t := tuple.MakeTuple2(5, "hello")
+// mapper := tuple.Map2(
+// func(n int) string { return fmt.Sprintf("%d", n) },
+// func(s string) int { return len(s) },
+// )
+// result := mapper(t) // Tuple2[string, int]{"5", 5}
+//
+// BiMap transforms both elements of a Tuple2:
+//
+// mapper := tuple.BiMap(
+// func(s string) int { return len(s) },
+// func(n int) string { return fmt.Sprintf("%d", n*2) },
+// )
+//
+// Swap exchanges the elements of a Tuple2:
+//
+// t := tuple.MakeTuple2("hello", 42)
+// swapped := tuple.Swap(t) // Tuple2[int, string]{42, "hello"}
+//
+// # Function Conversion
+//
+// Tupled and Untupled functions convert between regular multi-parameter functions
+// and functions that take/return tuples:
+//
+// // Regular function
+// add := func(a, b int) int { return a + b }
+//
+// // Convert to tuple-taking function
+// tupledAdd := tuple.Tupled2(add)
+// result := tupledAdd(tuple.MakeTuple2(3, 4)) // 7
+//
+// // Convert back
+// untupledAdd := tuple.Untupled2(tupledAdd)
+// result = untupledAdd(3, 4) // 7
+//
+// # Array Conversion
+//
+// Tuples can be converted to and from arrays using transformation functions:
+//
+// t := tuple.MakeTuple3(1, 2, 3)
+// toArray := tuple.ToArray3(
+// func(n int) int { return n },
+// func(n int) int { return n },
+// func(n int) int { return n },
+// )
+// arr := toArray(t) // []int{1, 2, 3}
+//
+// # Algebraic Operations
+//
+// The package supports algebraic structures:
+//
+// Monoid operations for combining tuples:
+//
+// import "github.com/IBM/fp-go/v2/monoid"
+// import "github.com/IBM/fp-go/v2/string"
+//
+// m := tuple.Monoid2(string.Monoid, monoid.MonoidSum[int]())
+// t1 := tuple.MakeTuple2("hello", 5)
+// t2 := tuple.MakeTuple2(" world", 3)
+// result := m.Concat(t1, t2) // Tuple2[string, int]{"hello world", 8}
+//
+// Ord operations for comparing tuples:
+//
+// import "github.com/IBM/fp-go/v2/ord"
+//
+// o := tuple.Ord2(ord.FromStrictCompare[string](), ord.FromStrictCompare[int]())
+// t1 := tuple.MakeTuple2("a", 1)
+// t2 := tuple.MakeTuple2("b", 2)
+// cmp := o.Compare(t1, t2) // -1 (t1 < t2)
+//
+// # JSON Serialization
+//
+// Tuples support JSON marshaling and unmarshaling as arrays:
+//
+// t := tuple.MakeTuple2("hello", 42)
+// data, _ := json.Marshal(t) // ["hello", 42]
+//
+// var t2 tuple.Tuple2[string, int]
+// json.Unmarshal(data, &t2) // Reconstructs the tuple
+//
+// # Building Tuples Incrementally
+//
+// The Push functions allow building larger tuples from smaller ones:
+//
+// t1 := tuple.MakeTuple1(42)
+// push := tuple.Push1[int, string]("hello")
+// t2 := push(t1) // Tuple2[int, string]{42, "hello"}
+//
+// # Replication
+//
+// Create tuples with all elements set to the same value:
+//
+// t := tuple.Replicate3(42) // Tuple3[int, int, int]{42, 42, 42}
+//
+// # Use Cases
+//
+// Tuples are useful when you need to:
+// - Return multiple values from a function in a type-safe way
+// - Group related but differently-typed values together
+// - Work with fixed-size heterogeneous collections
+// - Implement functional programming patterns like bifunctors
+// - Avoid defining custom struct types for simple data groupings
+//
+// For homogeneous collections of unknown or variable size, consider using
+// arrays or slices instead.
+package tuple
+
+//go:generate go run .. tuple --count 15 --filename gen.go
diff --git a/v2/tuple/gen.go b/v2/tuple/gen.go
new file mode 100644
index 0000000..4b7b494
--- /dev/null
+++ b/v2/tuple/gen.go
@@ -0,0 +1,2014 @@
+// Code generated by go generate; DO NOT EDIT.
+// This file was generated by robots at
+// 2025-03-09 23:53:14.1811403 +0100 CET m=+0.002096201
+
+package tuple
+
+
+import (
+ M "github.com/IBM/fp-go/v2/monoid"
+ O "github.com/IBM/fp-go/v2/ord"
+)
+
+// Tuple1 is a struct that carries 1 independently typed values
+type Tuple1[T1 any] struct {
+ F1 T1
+}
+
+// Tuple2 is a struct that carries 2 independently typed values
+type Tuple2[T1, T2 any] struct {
+ F1 T1
+ F2 T2
+}
+
+// Tuple3 is a struct that carries 3 independently typed values
+type Tuple3[T1, T2, T3 any] struct {
+ F1 T1
+ F2 T2
+ F3 T3
+}
+
+// Tuple4 is a struct that carries 4 independently typed values
+type Tuple4[T1, T2, T3, T4 any] struct {
+ F1 T1
+ F2 T2
+ F3 T3
+ F4 T4
+}
+
+// Tuple5 is a struct that carries 5 independently typed values
+type Tuple5[T1, T2, T3, T4, T5 any] struct {
+ F1 T1
+ F2 T2
+ F3 T3
+ F4 T4
+ F5 T5
+}
+
+// Tuple6 is a struct that carries 6 independently typed values
+type Tuple6[T1, T2, T3, T4, T5, T6 any] struct {
+ F1 T1
+ F2 T2
+ F3 T3
+ F4 T4
+ F5 T5
+ F6 T6
+}
+
+// Tuple7 is a struct that carries 7 independently typed values
+type Tuple7[T1, T2, T3, T4, T5, T6, T7 any] struct {
+ F1 T1
+ F2 T2
+ F3 T3
+ F4 T4
+ F5 T5
+ F6 T6
+ F7 T7
+}
+
+// Tuple8 is a struct that carries 8 independently typed values
+type Tuple8[T1, T2, T3, T4, T5, T6, T7, T8 any] struct {
+ F1 T1
+ F2 T2
+ F3 T3
+ F4 T4
+ F5 T5
+ F6 T6
+ F7 T7
+ F8 T8
+}
+
+// Tuple9 is a struct that carries 9 independently typed values
+type Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any] struct {
+ F1 T1
+ F2 T2
+ F3 T3
+ F4 T4
+ F5 T5
+ F6 T6
+ F7 T7
+ F8 T8
+ F9 T9
+}
+
+// Tuple10 is a struct that carries 10 independently typed values
+type Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any] struct {
+ F1 T1
+ F2 T2
+ F3 T3
+ F4 T4
+ F5 T5
+ F6 T6
+ F7 T7
+ F8 T8
+ F9 T9
+ F10 T10
+}
+
+// Tuple11 is a struct that carries 11 independently typed values
+type Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any] struct {
+ F1 T1
+ F2 T2
+ F3 T3
+ F4 T4
+ F5 T5
+ F6 T6
+ F7 T7
+ F8 T8
+ F9 T9
+ F10 T10
+ F11 T11
+}
+
+// Tuple12 is a struct that carries 12 independently typed values
+type Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any] struct {
+ F1 T1
+ F2 T2
+ F3 T3
+ F4 T4
+ F5 T5
+ F6 T6
+ F7 T7
+ F8 T8
+ F9 T9
+ F10 T10
+ F11 T11
+ F12 T12
+}
+
+// Tuple13 is a struct that carries 13 independently typed values
+type Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any] struct {
+ F1 T1
+ F2 T2
+ F3 T3
+ F4 T4
+ F5 T5
+ F6 T6
+ F7 T7
+ F8 T8
+ F9 T9
+ F10 T10
+ F11 T11
+ F12 T12
+ F13 T13
+}
+
+// Tuple14 is a struct that carries 14 independently typed values
+type Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any] struct {
+ F1 T1
+ F2 T2
+ F3 T3
+ F4 T4
+ F5 T5
+ F6 T6
+ F7 T7
+ F8 T8
+ F9 T9
+ F10 T10
+ F11 T11
+ F12 T12
+ F13 T13
+ F14 T14
+}
+
+// Tuple15 is a struct that carries 15 independently typed values
+type Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any] struct {
+ F1 T1
+ F2 T2
+ F3 T3
+ F4 T4
+ F5 T5
+ F6 T6
+ F7 T7
+ F8 T8
+ F9 T9
+ F10 T10
+ F11 T11
+ F12 T12
+ F13 T13
+ F14 T14
+ F15 T15
+}
+
+// MakeTuple1 is a function that converts its 1 parameters into a [Tuple1]
+func MakeTuple1[T1 any](t1 T1) Tuple1[T1] {
+ return Tuple1[T1]{t1}
+}
+
+// Tupled1 converts a function with 1 parameters into a function taking a Tuple1
+// The inverse function is [Untupled1]
+func Tupled1[F ~func(T1) R, T1, R any](f F) func(Tuple1[T1]) R {
+ return func(t Tuple1[T1]) R {
+ return f(t.F1)
+ }
+}
+
+// Untupled1 converts a function with a [Tuple1] parameter into a function with 1 parameters
+// The inverse function is [Tupled1]
+func Untupled1[F ~func(Tuple1[T1]) R, T1, R any](f F) func(T1) R {
+ return func(t1 T1) R {
+ return f(MakeTuple1(t1))
+ }
+}
+
+// Monoid1 creates a [Monoid] for a [Tuple1] based on 1 monoids for the contained types
+func Monoid1[T1 any](m1 M.Monoid[T1]) M.Monoid[Tuple1[T1]] {
+ return M.MakeMonoid(func(l, r Tuple1[T1]) Tuple1[T1]{
+ return MakeTuple1(m1.Concat(l.F1, r.F1))
+ }, MakeTuple1(m1.Empty()))
+}
+
+// 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}
+ return 0
+ }, func(l, r Tuple1[T1]) bool {
+ return o1.Equals(l.F1, r.F1)
+ })
+}
+
+// Map1 maps each value of a [Tuple1] via a mapping function
+func Map1[F1 ~func(T1) R1, T1, R1 any](f1 F1) func(Tuple1[T1]) Tuple1[R1] {
+ return func(t Tuple1[T1]) Tuple1[R1] {
+ return MakeTuple1(
+ f1(t.F1),
+ )
+ }
+}
+
+// Replicate1 creates a [Tuple1] with all fields set to the input value `t`
+func Replicate1[T any](t T) Tuple1[T] {
+ return MakeTuple1(t)
+}
+
+// String prints some debug info for the [Tuple1]
+func (t Tuple1[T1]) String() string {
+ return tupleString(t.F1)
+}
+
+// MarshalJSON marshals the [Tuple1] into a JSON array
+func (t Tuple1[T1]) MarshalJSON() ([]byte, error) {
+ return tupleMarshalJSON(t.F1)
+}
+
+// UnmarshalJSON unmarshals a JSON array into a [Tuple1]
+func (t *Tuple1[T1]) UnmarshalJSON(data []byte) error {
+ return tupleUnmarshalJSON(data, &t.F1)
+}
+
+// ToArray converts the [Tuple1] into an array of type [R] using 1 transformation functions from [T] to [R]
+// The inverse function is [FromArray1]
+func ToArray1[F1 ~func(T1) R, T1, R any](f1 F1) func(t Tuple1[T1]) []R {
+ return func(t Tuple1[T1]) []R {
+ return []R{
+ f1(t.F1),
+ }
+ }
+}
+
+// FromArray converts an array of [R] into a [Tuple1] using 1 functions from [R] to [T]
+// The inverse function is [ToArray1]
+func FromArray1[F1 ~func(R) T1, T1, R any](f1 F1) func(r []R) Tuple1[T1] {
+ return func(r []R) Tuple1[T1] {
+ return MakeTuple1(
+ f1(r[0]),
+ )
+ }
+}
+
+// Push1 creates a [Tuple2] from a [Tuple1] by appending a constant value
+func Push1[T1, T2 any](value T2) func(Tuple1[T1]) Tuple2[T1, T2] {
+ return func(t Tuple1[T1]) Tuple2[T1, T2] {
+ return MakeTuple2(t.F1, value)
+ }
+}
+
+// MakeTuple2 is a function that converts its 2 parameters into a [Tuple2]
+func MakeTuple2[T1, T2 any](t1 T1, t2 T2) Tuple2[T1, T2] {
+ return Tuple2[T1, T2]{t1, t2}
+}
+
+// Tupled2 converts a function with 2 parameters into a function taking a Tuple2
+// The inverse function is [Untupled2]
+func Tupled2[F ~func(T1, T2) R, T1, T2, R any](f F) func(Tuple2[T1, T2]) R {
+ return func(t Tuple2[T1, T2]) R {
+ return f(t.F1, t.F2)
+ }
+}
+
+// Untupled2 converts a function with a [Tuple2] parameter into a function with 2 parameters
+// The inverse function is [Tupled2]
+func Untupled2[F ~func(Tuple2[T1, T2]) R, T1, T2, R any](f F) func(T1, T2) R {
+ return func(t1 T1, t2 T2) R {
+ return f(MakeTuple2(t1, t2))
+ }
+}
+
+// Monoid2 creates a [Monoid] for a [Tuple2] based on 2 monoids for the contained types
+func Monoid2[T1, T2 any](m1 M.Monoid[T1], m2 M.Monoid[T2]) M.Monoid[Tuple2[T1, T2]] {
+ return M.MakeMonoid(func(l, r Tuple2[T1, T2]) Tuple2[T1, T2]{
+ return MakeTuple2(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2))
+ }, MakeTuple2(m1.Empty(), m2.Empty()))
+}
+
+// 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}
+ return 0
+ }, func(l, r Tuple2[T1, T2]) bool {
+ return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2)
+ })
+}
+
+// Map2 maps each value of a [Tuple2] via a mapping function
+func Map2[F1 ~func(T1) R1, F2 ~func(T2) R2, T1, R1, T2, R2 any](f1 F1, f2 F2) func(Tuple2[T1, T2]) Tuple2[R1, R2] {
+ return func(t Tuple2[T1, T2]) Tuple2[R1, R2] {
+ return MakeTuple2(
+ f1(t.F1),
+ f2(t.F2),
+ )
+ }
+}
+
+// Replicate2 creates a [Tuple2] with all fields set to the input value `t`
+func Replicate2[T any](t T) Tuple2[T, T] {
+ return MakeTuple2(t, t)
+}
+
+// String prints some debug info for the [Tuple2]
+func (t Tuple2[T1, T2]) String() string {
+ return tupleString(t.F1, t.F2)
+}
+
+// MarshalJSON marshals the [Tuple2] into a JSON array
+func (t Tuple2[T1, T2]) MarshalJSON() ([]byte, error) {
+ return tupleMarshalJSON(t.F1, t.F2)
+}
+
+// UnmarshalJSON unmarshals a JSON array into a [Tuple2]
+func (t *Tuple2[T1, T2]) UnmarshalJSON(data []byte) error {
+ return tupleUnmarshalJSON(data, &t.F1, &t.F2)
+}
+
+// ToArray converts the [Tuple2] into an array of type [R] using 2 transformation functions from [T] to [R]
+// The inverse function is [FromArray2]
+func ToArray2[F1 ~func(T1) R, F2 ~func(T2) R, T1, T2, R any](f1 F1, f2 F2) func(t Tuple2[T1, T2]) []R {
+ return func(t Tuple2[T1, T2]) []R {
+ return []R{
+ f1(t.F1),
+ f2(t.F2),
+ }
+ }
+}
+
+// FromArray converts an array of [R] into a [Tuple2] using 2 functions from [R] to [T]
+// The inverse function is [ToArray2]
+func FromArray2[F1 ~func(R) T1, F2 ~func(R) T2, T1, T2, R any](f1 F1, f2 F2) func(r []R) Tuple2[T1, T2] {
+ return func(r []R) Tuple2[T1, T2] {
+ return MakeTuple2(
+ f1(r[0]),
+ f2(r[1]),
+ )
+ }
+}
+
+// Push2 creates a [Tuple3] from a [Tuple2] by appending a constant value
+func Push2[T1, T2, T3 any](value T3) func(Tuple2[T1, T2]) Tuple3[T1, T2, T3] {
+ return func(t Tuple2[T1, T2]) Tuple3[T1, T2, T3] {
+ return MakeTuple3(t.F1, t.F2, value)
+ }
+}
+
+// MakeTuple3 is a function that converts its 3 parameters into a [Tuple3]
+func MakeTuple3[T1, T2, T3 any](t1 T1, t2 T2, t3 T3) Tuple3[T1, T2, T3] {
+ return Tuple3[T1, T2, T3]{t1, t2, t3}
+}
+
+// Tupled3 converts a function with 3 parameters into a function taking a Tuple3
+// The inverse function is [Untupled3]
+func Tupled3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(Tuple3[T1, T2, T3]) R {
+ return func(t Tuple3[T1, T2, T3]) R {
+ return f(t.F1, t.F2, t.F3)
+ }
+}
+
+// Untupled3 converts a function with a [Tuple3] parameter into a function with 3 parameters
+// The inverse function is [Tupled3]
+func Untupled3[F ~func(Tuple3[T1, T2, T3]) R, T1, T2, T3, R any](f F) func(T1, T2, T3) R {
+ return func(t1 T1, t2 T2, t3 T3) R {
+ return f(MakeTuple3(t1, t2, t3))
+ }
+}
+
+// Monoid3 creates a [Monoid] for a [Tuple3] based on 3 monoids for the contained types
+func Monoid3[T1, T2, T3 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3]) M.Monoid[Tuple3[T1, T2, T3]] {
+ return M.MakeMonoid(func(l, r Tuple3[T1, T2, T3]) Tuple3[T1, T2, T3]{
+ return MakeTuple3(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3))
+ }, MakeTuple3(m1.Empty(), m2.Empty(), m3.Empty()))
+}
+
+// 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}
+ 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)
+ })
+}
+
+// Map3 maps each value of a [Tuple3] via a mapping function
+func Map3[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, T1, R1, T2, R2, T3, R3 any](f1 F1, f2 F2, f3 F3) func(Tuple3[T1, T2, T3]) Tuple3[R1, R2, R3] {
+ return func(t Tuple3[T1, T2, T3]) Tuple3[R1, R2, R3] {
+ return MakeTuple3(
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ )
+ }
+}
+
+// Replicate3 creates a [Tuple3] with all fields set to the input value `t`
+func Replicate3[T any](t T) Tuple3[T, T, T] {
+ return MakeTuple3(t, t, t)
+}
+
+// String prints some debug info for the [Tuple3]
+func (t Tuple3[T1, T2, T3]) String() string {
+ return tupleString(t.F1, t.F2, t.F3)
+}
+
+// MarshalJSON marshals the [Tuple3] into a JSON array
+func (t Tuple3[T1, T2, T3]) MarshalJSON() ([]byte, error) {
+ return tupleMarshalJSON(t.F1, t.F2, t.F3)
+}
+
+// UnmarshalJSON unmarshals a JSON array into a [Tuple3]
+func (t *Tuple3[T1, T2, T3]) UnmarshalJSON(data []byte) error {
+ return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3)
+}
+
+// ToArray converts the [Tuple3] into an array of type [R] using 3 transformation functions from [T] to [R]
+// The inverse function is [FromArray3]
+func ToArray3[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, T1, T2, T3, R any](f1 F1, f2 F2, f3 F3) func(t Tuple3[T1, T2, T3]) []R {
+ return func(t Tuple3[T1, T2, T3]) []R {
+ return []R{
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ }
+ }
+}
+
+// FromArray converts an array of [R] into a [Tuple3] using 3 functions from [R] to [T]
+// The inverse function is [ToArray3]
+func FromArray3[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, T1, T2, T3, R any](f1 F1, f2 F2, f3 F3) func(r []R) Tuple3[T1, T2, T3] {
+ return func(r []R) Tuple3[T1, T2, T3] {
+ return MakeTuple3(
+ f1(r[0]),
+ f2(r[1]),
+ f3(r[2]),
+ )
+ }
+}
+
+// Push3 creates a [Tuple4] from a [Tuple3] by appending a constant value
+func Push3[T1, T2, T3, T4 any](value T4) func(Tuple3[T1, T2, T3]) Tuple4[T1, T2, T3, T4] {
+ return func(t Tuple3[T1, T2, T3]) Tuple4[T1, T2, T3, T4] {
+ return MakeTuple4(t.F1, t.F2, t.F3, value)
+ }
+}
+
+// MakeTuple4 is a function that converts its 4 parameters into a [Tuple4]
+func MakeTuple4[T1, T2, T3, T4 any](t1 T1, t2 T2, t3 T3, t4 T4) Tuple4[T1, T2, T3, T4] {
+ return Tuple4[T1, T2, T3, T4]{t1, t2, t3, t4}
+}
+
+// Tupled4 converts a function with 4 parameters into a function taking a Tuple4
+// The inverse function is [Untupled4]
+func Tupled4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(Tuple4[T1, T2, T3, T4]) R {
+ return func(t Tuple4[T1, T2, T3, T4]) R {
+ return f(t.F1, t.F2, t.F3, t.F4)
+ }
+}
+
+// Untupled4 converts a function with a [Tuple4] parameter into a function with 4 parameters
+// The inverse function is [Tupled4]
+func Untupled4[F ~func(Tuple4[T1, T2, T3, T4]) R, T1, T2, T3, T4, R any](f F) func(T1, T2, T3, T4) R {
+ return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+ return f(MakeTuple4(t1, t2, t3, t4))
+ }
+}
+
+// Monoid4 creates a [Monoid] for a [Tuple4] based on 4 monoids for the contained types
+func Monoid4[T1, T2, T3, T4 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4]) M.Monoid[Tuple4[T1, T2, T3, T4]] {
+ return M.MakeMonoid(func(l, r Tuple4[T1, T2, T3, T4]) Tuple4[T1, T2, T3, T4]{
+ return MakeTuple4(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4))
+ }, MakeTuple4(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty()))
+}
+
+// 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}
+ 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)
+ })
+}
+
+// Map4 maps each value of a [Tuple4] via a mapping function
+func Map4[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, T1, R1, T2, R2, T3, R3, T4, R4 any](f1 F1, f2 F2, f3 F3, f4 F4) func(Tuple4[T1, T2, T3, T4]) Tuple4[R1, R2, R3, R4] {
+ return func(t Tuple4[T1, T2, T3, T4]) Tuple4[R1, R2, R3, R4] {
+ return MakeTuple4(
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ )
+ }
+}
+
+// Replicate4 creates a [Tuple4] with all fields set to the input value `t`
+func Replicate4[T any](t T) Tuple4[T, T, T, T] {
+ return MakeTuple4(t, t, t, t)
+}
+
+// String prints some debug info for the [Tuple4]
+func (t Tuple4[T1, T2, T3, T4]) String() string {
+ return tupleString(t.F1, t.F2, t.F3, t.F4)
+}
+
+// MarshalJSON marshals the [Tuple4] into a JSON array
+func (t Tuple4[T1, T2, T3, T4]) MarshalJSON() ([]byte, error) {
+ return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4)
+}
+
+// UnmarshalJSON unmarshals a JSON array into a [Tuple4]
+func (t *Tuple4[T1, T2, T3, T4]) UnmarshalJSON(data []byte) error {
+ return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4)
+}
+
+// ToArray converts the [Tuple4] into an array of type [R] using 4 transformation functions from [T] to [R]
+// The inverse function is [FromArray4]
+func ToArray4[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, T1, T2, T3, T4, R any](f1 F1, f2 F2, f3 F3, f4 F4) func(t Tuple4[T1, T2, T3, T4]) []R {
+ return func(t Tuple4[T1, T2, T3, T4]) []R {
+ return []R{
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ }
+ }
+}
+
+// FromArray converts an array of [R] into a [Tuple4] using 4 functions from [R] to [T]
+// The inverse function is [ToArray4]
+func FromArray4[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, T1, T2, T3, T4, R any](f1 F1, f2 F2, f3 F3, f4 F4) func(r []R) Tuple4[T1, T2, T3, T4] {
+ return func(r []R) Tuple4[T1, T2, T3, T4] {
+ return MakeTuple4(
+ f1(r[0]),
+ f2(r[1]),
+ f3(r[2]),
+ f4(r[3]),
+ )
+ }
+}
+
+// Push4 creates a [Tuple5] from a [Tuple4] by appending a constant value
+func Push4[T1, T2, T3, T4, T5 any](value T5) func(Tuple4[T1, T2, T3, T4]) Tuple5[T1, T2, T3, T4, T5] {
+ return func(t Tuple4[T1, T2, T3, T4]) Tuple5[T1, T2, T3, T4, T5] {
+ return MakeTuple5(t.F1, t.F2, t.F3, t.F4, value)
+ }
+}
+
+// MakeTuple5 is a function that converts its 5 parameters into a [Tuple5]
+func MakeTuple5[T1, T2, T3, T4, T5 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) Tuple5[T1, T2, T3, T4, T5] {
+ return Tuple5[T1, T2, T3, T4, T5]{t1, t2, t3, t4, t5}
+}
+
+// Tupled5 converts a function with 5 parameters into a function taking a Tuple5
+// The inverse function is [Untupled5]
+func Tupled5[F ~func(T1, T2, T3, T4, T5) R, T1, T2, T3, T4, T5, R any](f F) func(Tuple5[T1, T2, T3, T4, T5]) R {
+ return func(t Tuple5[T1, T2, T3, T4, T5]) R {
+ return f(t.F1, t.F2, t.F3, t.F4, t.F5)
+ }
+}
+
+// Untupled5 converts a function with a [Tuple5] parameter into a function with 5 parameters
+// The inverse function is [Tupled5]
+func Untupled5[F ~func(Tuple5[T1, T2, T3, T4, T5]) R, T1, T2, T3, T4, T5, R any](f F) func(T1, T2, T3, T4, T5) R {
+ return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) R {
+ return f(MakeTuple5(t1, t2, t3, t4, t5))
+ }
+}
+
+// Monoid5 creates a [Monoid] for a [Tuple5] based on 5 monoids for the contained types
+func Monoid5[T1, T2, T3, T4, T5 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5]) M.Monoid[Tuple5[T1, T2, T3, T4, T5]] {
+ return M.MakeMonoid(func(l, r Tuple5[T1, T2, T3, T4, T5]) Tuple5[T1, T2, T3, T4, T5]{
+ return MakeTuple5(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5))
+ }, MakeTuple5(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty()))
+}
+
+// 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}
+ 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)
+ })
+}
+
+// Map5 maps each value of a [Tuple5] via a mapping function
+func Map5[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func(Tuple5[T1, T2, T3, T4, T5]) Tuple5[R1, R2, R3, R4, R5] {
+ return func(t Tuple5[T1, T2, T3, T4, T5]) Tuple5[R1, R2, R3, R4, R5] {
+ return MakeTuple5(
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ )
+ }
+}
+
+// Replicate5 creates a [Tuple5] with all fields set to the input value `t`
+func Replicate5[T any](t T) Tuple5[T, T, T, T, T] {
+ return MakeTuple5(t, t, t, t, t)
+}
+
+// String prints some debug info for the [Tuple5]
+func (t Tuple5[T1, T2, T3, T4, T5]) String() string {
+ return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5)
+}
+
+// MarshalJSON marshals the [Tuple5] into a JSON array
+func (t Tuple5[T1, T2, T3, T4, T5]) MarshalJSON() ([]byte, error) {
+ return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5)
+}
+
+// UnmarshalJSON unmarshals a JSON array into a [Tuple5]
+func (t *Tuple5[T1, T2, T3, T4, T5]) UnmarshalJSON(data []byte) error {
+ return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5)
+}
+
+// ToArray converts the [Tuple5] into an array of type [R] using 5 transformation functions from [T] to [R]
+// The inverse function is [FromArray5]
+func ToArray5[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, F5 ~func(T5) R, T1, T2, T3, T4, T5, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func(t Tuple5[T1, T2, T3, T4, T5]) []R {
+ return func(t Tuple5[T1, T2, T3, T4, T5]) []R {
+ return []R{
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ }
+ }
+}
+
+// FromArray converts an array of [R] into a [Tuple5] using 5 functions from [R] to [T]
+// The inverse function is [ToArray5]
+func FromArray5[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, F5 ~func(R) T5, T1, T2, T3, T4, T5, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func(r []R) Tuple5[T1, T2, T3, T4, T5] {
+ return func(r []R) Tuple5[T1, T2, T3, T4, T5] {
+ return MakeTuple5(
+ f1(r[0]),
+ f2(r[1]),
+ f3(r[2]),
+ f4(r[3]),
+ f5(r[4]),
+ )
+ }
+}
+
+// Push5 creates a [Tuple6] from a [Tuple5] by appending a constant value
+func Push5[T1, T2, T3, T4, T5, T6 any](value T6) func(Tuple5[T1, T2, T3, T4, T5]) Tuple6[T1, T2, T3, T4, T5, T6] {
+ return func(t Tuple5[T1, T2, T3, T4, T5]) Tuple6[T1, T2, T3, T4, T5, T6] {
+ return MakeTuple6(t.F1, t.F2, t.F3, t.F4, t.F5, value)
+ }
+}
+
+// MakeTuple6 is a function that converts its 6 parameters into a [Tuple6]
+func MakeTuple6[T1, T2, T3, T4, T5, T6 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) Tuple6[T1, T2, T3, T4, T5, T6] {
+ return Tuple6[T1, T2, T3, T4, T5, T6]{t1, t2, t3, t4, t5, t6}
+}
+
+// Tupled6 converts a function with 6 parameters into a function taking a Tuple6
+// The inverse function is [Untupled6]
+func Tupled6[F ~func(T1, T2, T3, T4, T5, T6) R, T1, T2, T3, T4, T5, T6, R any](f F) func(Tuple6[T1, T2, T3, T4, T5, T6]) R {
+ return func(t Tuple6[T1, T2, T3, T4, T5, T6]) R {
+ return f(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6)
+ }
+}
+
+// Untupled6 converts a function with a [Tuple6] parameter into a function with 6 parameters
+// The inverse function is [Tupled6]
+func Untupled6[F ~func(Tuple6[T1, T2, T3, T4, T5, T6]) R, T1, T2, T3, T4, T5, T6, R any](f F) func(T1, T2, T3, T4, T5, T6) R {
+ return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) R {
+ return f(MakeTuple6(t1, t2, t3, t4, t5, t6))
+ }
+}
+
+// Monoid6 creates a [Monoid] for a [Tuple6] based on 6 monoids for the contained types
+func Monoid6[T1, T2, T3, T4, T5, T6 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6]) M.Monoid[Tuple6[T1, T2, T3, T4, T5, T6]] {
+ return M.MakeMonoid(func(l, r Tuple6[T1, T2, T3, T4, T5, T6]) Tuple6[T1, T2, T3, T4, T5, T6]{
+ return MakeTuple6(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6))
+ }, MakeTuple6(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty()))
+}
+
+// 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}
+ 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)
+ })
+}
+
+// Map6 maps each value of a [Tuple6] via a mapping function
+func Map6[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func(Tuple6[T1, T2, T3, T4, T5, T6]) Tuple6[R1, R2, R3, R4, R5, R6] {
+ return func(t Tuple6[T1, T2, T3, T4, T5, T6]) Tuple6[R1, R2, R3, R4, R5, R6] {
+ return MakeTuple6(
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ )
+ }
+}
+
+// Replicate6 creates a [Tuple6] with all fields set to the input value `t`
+func Replicate6[T any](t T) Tuple6[T, T, T, T, T, T] {
+ return MakeTuple6(t, t, t, t, t, t)
+}
+
+// String prints some debug info for the [Tuple6]
+func (t Tuple6[T1, T2, T3, T4, T5, T6]) String() string {
+ return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6)
+}
+
+// MarshalJSON marshals the [Tuple6] into a JSON array
+func (t Tuple6[T1, T2, T3, T4, T5, T6]) MarshalJSON() ([]byte, error) {
+ return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6)
+}
+
+// UnmarshalJSON unmarshals a JSON array into a [Tuple6]
+func (t *Tuple6[T1, T2, T3, T4, T5, T6]) UnmarshalJSON(data []byte) error {
+ return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6)
+}
+
+// ToArray converts the [Tuple6] into an array of type [R] using 6 transformation functions from [T] to [R]
+// The inverse function is [FromArray6]
+func ToArray6[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, F5 ~func(T5) R, F6 ~func(T6) R, T1, T2, T3, T4, T5, T6, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func(t Tuple6[T1, T2, T3, T4, T5, T6]) []R {
+ return func(t Tuple6[T1, T2, T3, T4, T5, T6]) []R {
+ return []R{
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ }
+ }
+}
+
+// FromArray converts an array of [R] into a [Tuple6] using 6 functions from [R] to [T]
+// The inverse function is [ToArray6]
+func FromArray6[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, F5 ~func(R) T5, F6 ~func(R) T6, T1, T2, T3, T4, T5, T6, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func(r []R) Tuple6[T1, T2, T3, T4, T5, T6] {
+ return func(r []R) Tuple6[T1, T2, T3, T4, T5, T6] {
+ return MakeTuple6(
+ f1(r[0]),
+ f2(r[1]),
+ f3(r[2]),
+ f4(r[3]),
+ f5(r[4]),
+ f6(r[5]),
+ )
+ }
+}
+
+// Push6 creates a [Tuple7] from a [Tuple6] by appending a constant value
+func Push6[T1, T2, T3, T4, T5, T6, T7 any](value T7) func(Tuple6[T1, T2, T3, T4, T5, T6]) Tuple7[T1, T2, T3, T4, T5, T6, T7] {
+ return func(t Tuple6[T1, T2, T3, T4, T5, T6]) Tuple7[T1, T2, T3, T4, T5, T6, T7] {
+ return MakeTuple7(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, value)
+ }
+}
+
+// MakeTuple7 is a function that converts its 7 parameters into a [Tuple7]
+func MakeTuple7[T1, T2, T3, T4, T5, T6, T7 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) Tuple7[T1, T2, T3, T4, T5, T6, T7] {
+ return Tuple7[T1, T2, T3, T4, T5, T6, T7]{t1, t2, t3, t4, t5, t6, t7}
+}
+
+// Tupled7 converts a function with 7 parameters into a function taking a Tuple7
+// The inverse function is [Untupled7]
+func Tupled7[F ~func(T1, T2, T3, T4, T5, T6, T7) R, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(Tuple7[T1, T2, T3, T4, T5, T6, T7]) R {
+ return func(t Tuple7[T1, T2, T3, T4, T5, T6, T7]) R {
+ return f(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7)
+ }
+}
+
+// Untupled7 converts a function with a [Tuple7] parameter into a function with 7 parameters
+// The inverse function is [Tupled7]
+func Untupled7[F ~func(Tuple7[T1, T2, T3, T4, T5, T6, T7]) R, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T1, T2, T3, T4, T5, T6, T7) R {
+ return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) R {
+ return f(MakeTuple7(t1, t2, t3, t4, t5, t6, t7))
+ }
+}
+
+// Monoid7 creates a [Monoid] for a [Tuple7] based on 7 monoids for the contained types
+func Monoid7[T1, T2, T3, T4, T5, T6, T7 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7]) M.Monoid[Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
+ return M.MakeMonoid(func(l, r Tuple7[T1, T2, T3, T4, T5, T6, T7]) Tuple7[T1, T2, T3, T4, T5, T6, T7]{
+ return MakeTuple7(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7))
+ }, MakeTuple7(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty()))
+}
+
+// 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}
+ 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)
+ })
+}
+
+// Map7 maps each value of a [Tuple7] via a mapping function
+func Map7[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func(Tuple7[T1, T2, T3, T4, T5, T6, T7]) Tuple7[R1, R2, R3, R4, R5, R6, R7] {
+ return func(t Tuple7[T1, T2, T3, T4, T5, T6, T7]) Tuple7[R1, R2, R3, R4, R5, R6, R7] {
+ return MakeTuple7(
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ )
+ }
+}
+
+// Replicate7 creates a [Tuple7] with all fields set to the input value `t`
+func Replicate7[T any](t T) Tuple7[T, T, T, T, T, T, T] {
+ return MakeTuple7(t, t, t, t, t, t, t)
+}
+
+// String prints some debug info for the [Tuple7]
+func (t Tuple7[T1, T2, T3, T4, T5, T6, T7]) String() string {
+ return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7)
+}
+
+// MarshalJSON marshals the [Tuple7] into a JSON array
+func (t Tuple7[T1, T2, T3, T4, T5, T6, T7]) MarshalJSON() ([]byte, error) {
+ return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7)
+}
+
+// UnmarshalJSON unmarshals a JSON array into a [Tuple7]
+func (t *Tuple7[T1, T2, T3, T4, T5, T6, T7]) UnmarshalJSON(data []byte) error {
+ return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7)
+}
+
+// ToArray converts the [Tuple7] into an array of type [R] using 7 transformation functions from [T] to [R]
+// The inverse function is [FromArray7]
+func ToArray7[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, F5 ~func(T5) R, F6 ~func(T6) R, F7 ~func(T7) R, T1, T2, T3, T4, T5, T6, T7, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func(t Tuple7[T1, T2, T3, T4, T5, T6, T7]) []R {
+ return func(t Tuple7[T1, T2, T3, T4, T5, T6, T7]) []R {
+ return []R{
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ }
+ }
+}
+
+// FromArray converts an array of [R] into a [Tuple7] using 7 functions from [R] to [T]
+// The inverse function is [ToArray7]
+func FromArray7[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, F5 ~func(R) T5, F6 ~func(R) T6, F7 ~func(R) T7, T1, T2, T3, T4, T5, T6, T7, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func(r []R) Tuple7[T1, T2, T3, T4, T5, T6, T7] {
+ return func(r []R) Tuple7[T1, T2, T3, T4, T5, T6, T7] {
+ return MakeTuple7(
+ f1(r[0]),
+ f2(r[1]),
+ f3(r[2]),
+ f4(r[3]),
+ f5(r[4]),
+ f6(r[5]),
+ f7(r[6]),
+ )
+ }
+}
+
+// Push7 creates a [Tuple8] from a [Tuple7] by appending a constant value
+func Push7[T1, T2, T3, T4, T5, T6, T7, T8 any](value T8) func(Tuple7[T1, T2, T3, T4, T5, T6, T7]) Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
+ return func(t Tuple7[T1, T2, T3, T4, T5, T6, T7]) Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
+ return MakeTuple8(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, value)
+ }
+}
+
+// MakeTuple8 is a function that converts its 8 parameters into a [Tuple8]
+func MakeTuple8[T1, T2, T3, T4, T5, T6, T7, T8 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
+ return Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]{t1, t2, t3, t4, t5, t6, t7, t8}
+}
+
+// Tupled8 converts a function with 8 parameters into a function taking a Tuple8
+// The inverse function is [Untupled8]
+func Tupled8[F ~func(T1, T2, T3, T4, T5, T6, T7, T8) R, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) R {
+ return func(t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) R {
+ return f(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8)
+ }
+}
+
+// Untupled8 converts a function with a [Tuple8] parameter into a function with 8 parameters
+// The inverse function is [Tupled8]
+func Untupled8[F ~func(Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) R, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8) R {
+ return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) R {
+ return f(MakeTuple8(t1, t2, t3, t4, t5, t6, t7, t8))
+ }
+}
+
+// Monoid8 creates a [Monoid] for a [Tuple8] based on 8 monoids for the contained types
+func Monoid8[T1, T2, T3, T4, T5, T6, T7, T8 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8]) M.Monoid[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
+ return M.MakeMonoid(func(l, r Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]{
+ return MakeTuple8(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8))
+ }, MakeTuple8(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty()))
+}
+
+// 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}
+ 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)
+ })
+}
+
+// Map8 maps each value of a [Tuple8] via a mapping function
+func Map8[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, F8 ~func(T8) R8, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7, T8, R8 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func(Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) Tuple8[R1, R2, R3, R4, R5, R6, R7, R8] {
+ return func(t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) Tuple8[R1, R2, R3, R4, R5, R6, R7, R8] {
+ return MakeTuple8(
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ f8(t.F8),
+ )
+ }
+}
+
+// Replicate8 creates a [Tuple8] with all fields set to the input value `t`
+func Replicate8[T any](t T) Tuple8[T, T, T, T, T, T, T, T] {
+ return MakeTuple8(t, t, t, t, t, t, t, t)
+}
+
+// String prints some debug info for the [Tuple8]
+func (t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) String() string {
+ return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8)
+}
+
+// MarshalJSON marshals the [Tuple8] into a JSON array
+func (t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) MarshalJSON() ([]byte, error) {
+ return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8)
+}
+
+// UnmarshalJSON unmarshals a JSON array into a [Tuple8]
+func (t *Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) UnmarshalJSON(data []byte) error {
+ return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8)
+}
+
+// ToArray converts the [Tuple8] into an array of type [R] using 8 transformation functions from [T] to [R]
+// The inverse function is [FromArray8]
+func ToArray8[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, F5 ~func(T5) R, F6 ~func(T6) R, F7 ~func(T7) R, F8 ~func(T8) R, T1, T2, T3, T4, T5, T6, T7, T8, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func(t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) []R {
+ return func(t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) []R {
+ return []R{
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ f8(t.F8),
+ }
+ }
+}
+
+// FromArray converts an array of [R] into a [Tuple8] using 8 functions from [R] to [T]
+// The inverse function is [ToArray8]
+func FromArray8[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, F5 ~func(R) T5, F6 ~func(R) T6, F7 ~func(R) T7, F8 ~func(R) T8, T1, T2, T3, T4, T5, T6, T7, T8, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func(r []R) Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
+ return func(r []R) Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
+ return MakeTuple8(
+ f1(r[0]),
+ f2(r[1]),
+ f3(r[2]),
+ f4(r[3]),
+ f5(r[4]),
+ f6(r[5]),
+ f7(r[6]),
+ f8(r[7]),
+ )
+ }
+}
+
+// Push8 creates a [Tuple9] from a [Tuple8] by appending a constant value
+func Push8[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](value T9) func(Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
+ return func(t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
+ return MakeTuple9(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, value)
+ }
+}
+
+// MakeTuple9 is a function that converts its 9 parameters into a [Tuple9]
+func MakeTuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
+ return Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]{t1, t2, t3, t4, t5, t6, t7, t8, t9}
+}
+
+// Tupled9 converts a function with 9 parameters into a function taking a Tuple9
+// The inverse function is [Untupled9]
+func Tupled9[F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f F) func(Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) R {
+ return func(t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) R {
+ return f(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9)
+ }
+}
+
+// Untupled9 converts a function with a [Tuple9] parameter into a function with 9 parameters
+// The inverse function is [Tupled9]
+func Untupled9[F ~func(Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R {
+ return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) R {
+ return f(MakeTuple9(t1, t2, t3, t4, t5, t6, t7, t8, t9))
+ }
+}
+
+// Monoid9 creates a [Monoid] for a [Tuple9] based on 9 monoids for the contained types
+func Monoid9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8], m9 M.Monoid[T9]) M.Monoid[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
+ return M.MakeMonoid(func(l, r Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]{
+ return MakeTuple9(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8), m9.Concat(l.F9, r.F9))
+ }, MakeTuple9(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty(), m9.Empty()))
+}
+
+// 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}
+ 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)
+ })
+}
+
+// Map9 maps each value of a [Tuple9] via a mapping function
+func Map9[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, F8 ~func(T8) R8, F9 ~func(T9) R9, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7, T8, R8, T9, R9 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func(Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) Tuple9[R1, R2, R3, R4, R5, R6, R7, R8, R9] {
+ return func(t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) Tuple9[R1, R2, R3, R4, R5, R6, R7, R8, R9] {
+ return MakeTuple9(
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ f8(t.F8),
+ f9(t.F9),
+ )
+ }
+}
+
+// Replicate9 creates a [Tuple9] with all fields set to the input value `t`
+func Replicate9[T any](t T) Tuple9[T, T, T, T, T, T, T, T, T] {
+ return MakeTuple9(t, t, t, t, t, t, t, t, t)
+}
+
+// String prints some debug info for the [Tuple9]
+func (t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) String() string {
+ return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9)
+}
+
+// MarshalJSON marshals the [Tuple9] into a JSON array
+func (t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) MarshalJSON() ([]byte, error) {
+ return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9)
+}
+
+// UnmarshalJSON unmarshals a JSON array into a [Tuple9]
+func (t *Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) UnmarshalJSON(data []byte) error {
+ return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8, &t.F9)
+}
+
+// ToArray converts the [Tuple9] into an array of type [R] using 9 transformation functions from [T] to [R]
+// The inverse function is [FromArray9]
+func ToArray9[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, F5 ~func(T5) R, F6 ~func(T6) R, F7 ~func(T7) R, F8 ~func(T8) R, F9 ~func(T9) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func(t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) []R {
+ return func(t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) []R {
+ return []R{
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ f8(t.F8),
+ f9(t.F9),
+ }
+ }
+}
+
+// FromArray converts an array of [R] into a [Tuple9] using 9 functions from [R] to [T]
+// The inverse function is [ToArray9]
+func FromArray9[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, F5 ~func(R) T5, F6 ~func(R) T6, F7 ~func(R) T7, F8 ~func(R) T8, F9 ~func(R) T9, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func(r []R) Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
+ return func(r []R) Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
+ return MakeTuple9(
+ f1(r[0]),
+ f2(r[1]),
+ f3(r[2]),
+ f4(r[3]),
+ f5(r[4]),
+ f6(r[5]),
+ f7(r[6]),
+ f8(r[7]),
+ f9(r[8]),
+ )
+ }
+}
+
+// Push9 creates a [Tuple10] from a [Tuple9] by appending a constant value
+func Push9[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](value T10) func(Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
+ return func(t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
+ return MakeTuple10(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, value)
+ }
+}
+
+// MakeTuple10 is a function that converts its 10 parameters into a [Tuple10]
+func MakeTuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
+ return Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10}
+}
+
+// Tupled10 converts a function with 10 parameters into a function taking a Tuple10
+// The inverse function is [Untupled10]
+func Tupled10[F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f F) func(Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) R {
+ return func(t Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) R {
+ return f(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10)
+ }
+}
+
+// Untupled10 converts a function with a [Tuple10] parameter into a function with 10 parameters
+// The inverse function is [Tupled10]
+func Untupled10[F ~func(Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) R {
+ return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) R {
+ return f(MakeTuple10(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10))
+ }
+}
+
+// Monoid10 creates a [Monoid] for a [Tuple10] based on 10 monoids for the contained types
+func Monoid10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8], m9 M.Monoid[T9], m10 M.Monoid[T10]) M.Monoid[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
+ return M.MakeMonoid(func(l, r Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]{
+ return MakeTuple10(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8), m9.Concat(l.F9, r.F9), m10.Concat(l.F10, r.F10))
+ }, MakeTuple10(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty(), m9.Empty(), m10.Empty()))
+}
+
+// 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}
+ 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)
+ })
+}
+
+// Map10 maps each value of a [Tuple10] via a mapping function
+func Map10[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, F8 ~func(T8) R8, F9 ~func(T9) R9, F10 ~func(T10) R10, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7, T8, R8, T9, R9, T10, R10 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func(Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) Tuple10[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10] {
+ return func(t Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) Tuple10[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10] {
+ return MakeTuple10(
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ f8(t.F8),
+ f9(t.F9),
+ f10(t.F10),
+ )
+ }
+}
+
+// Replicate10 creates a [Tuple10] with all fields set to the input value `t`
+func Replicate10[T any](t T) Tuple10[T, T, T, T, T, T, T, T, T, T] {
+ return MakeTuple10(t, t, t, t, t, t, t, t, t, t)
+}
+
+// String prints some debug info for the [Tuple10]
+func (t Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) String() string {
+ return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10)
+}
+
+// MarshalJSON marshals the [Tuple10] into a JSON array
+func (t Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) MarshalJSON() ([]byte, error) {
+ return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10)
+}
+
+// UnmarshalJSON unmarshals a JSON array into a [Tuple10]
+func (t *Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) UnmarshalJSON(data []byte) error {
+ return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8, &t.F9, &t.F10)
+}
+
+// ToArray converts the [Tuple10] into an array of type [R] using 10 transformation functions from [T] to [R]
+// The inverse function is [FromArray10]
+func ToArray10[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, F5 ~func(T5) R, F6 ~func(T6) R, F7 ~func(T7) R, F8 ~func(T8) R, F9 ~func(T9) R, F10 ~func(T10) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func(t Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) []R {
+ return func(t Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) []R {
+ return []R{
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ f8(t.F8),
+ f9(t.F9),
+ f10(t.F10),
+ }
+ }
+}
+
+// FromArray converts an array of [R] into a [Tuple10] using 10 functions from [R] to [T]
+// The inverse function is [ToArray10]
+func FromArray10[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, F5 ~func(R) T5, F6 ~func(R) T6, F7 ~func(R) T7, F8 ~func(R) T8, F9 ~func(R) T9, F10 ~func(R) T10, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func(r []R) Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
+ return func(r []R) Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
+ return MakeTuple10(
+ f1(r[0]),
+ f2(r[1]),
+ f3(r[2]),
+ f4(r[3]),
+ f5(r[4]),
+ f6(r[5]),
+ f7(r[6]),
+ f8(r[7]),
+ f9(r[8]),
+ f10(r[9]),
+ )
+ }
+}
+
+// Push10 creates a [Tuple11] from a [Tuple10] by appending a constant value
+func Push10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](value T11) func(Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] {
+ return func(t Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] {
+ return MakeTuple11(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, value)
+ }
+}
+
+// MakeTuple11 is a function that converts its 11 parameters into a [Tuple11]
+func MakeTuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11) Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] {
+ return Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11}
+}
+
+// Tupled11 converts a function with 11 parameters into a function taking a Tuple11
+// The inverse function is [Untupled11]
+func Tupled11[F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R any](f F) func(Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) R {
+ return func(t Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) R {
+ return f(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11)
+ }
+}
+
+// Untupled11 converts a function with a [Tuple11] parameter into a function with 11 parameters
+// The inverse function is [Tupled11]
+func Untupled11[F ~func(Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) 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) R {
+ return f(MakeTuple11(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11))
+ }
+}
+
+// Monoid11 creates a [Monoid] for a [Tuple11] based on 11 monoids for the contained types
+func Monoid11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8], m9 M.Monoid[T9], m10 M.Monoid[T10], m11 M.Monoid[T11]) M.Monoid[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] {
+ return M.MakeMonoid(func(l, r Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]{
+ return MakeTuple11(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8), m9.Concat(l.F9, r.F9), m10.Concat(l.F10, r.F10), m11.Concat(l.F11, r.F11))
+ }, MakeTuple11(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty(), m9.Empty(), m10.Empty(), m11.Empty()))
+}
+
+// Ord11 creates n [Ord] for a [Tuple11] based on 11 [Ord]s for the contained types
+func Ord11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 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], o11 O.Ord[T11]) O.Ord[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] {
+ return O.MakeOrd(func(l, r Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) 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:= o11.Compare(l.F11, r.F11); c != 0 {return c}
+ return 0
+ }, func(l, r Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) 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) && o11.Equals(l.F11, r.F11)
+ })
+}
+
+// Map11 maps each value of a [Tuple11] via a mapping function
+func Map11[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, F8 ~func(T8) R8, F9 ~func(T9) R9, F10 ~func(T10) R10, F11 ~func(T11) R11, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7, T8, R8, T9, R9, T10, R10, T11, R11 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11) func(Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) Tuple11[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11] {
+ return func(t Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) Tuple11[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11] {
+ return MakeTuple11(
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ f8(t.F8),
+ f9(t.F9),
+ f10(t.F10),
+ f11(t.F11),
+ )
+ }
+}
+
+// Replicate11 creates a [Tuple11] with all fields set to the input value `t`
+func Replicate11[T any](t T) Tuple11[T, T, T, T, T, T, T, T, T, T, T] {
+ return MakeTuple11(t, t, t, t, t, t, t, t, t, t, t)
+}
+
+// String prints some debug info for the [Tuple11]
+func (t Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) String() string {
+ return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11)
+}
+
+// MarshalJSON marshals the [Tuple11] into a JSON array
+func (t Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) MarshalJSON() ([]byte, error) {
+ return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11)
+}
+
+// UnmarshalJSON unmarshals a JSON array into a [Tuple11]
+func (t *Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) UnmarshalJSON(data []byte) error {
+ return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8, &t.F9, &t.F10, &t.F11)
+}
+
+// ToArray converts the [Tuple11] into an array of type [R] using 11 transformation functions from [T] to [R]
+// The inverse function is [FromArray11]
+func ToArray11[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, F5 ~func(T5) R, F6 ~func(T6) R, F7 ~func(T7) R, F8 ~func(T8) R, F9 ~func(T9) R, F10 ~func(T10) R, F11 ~func(T11) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11) func(t Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) []R {
+ return func(t Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) []R {
+ return []R{
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ f8(t.F8),
+ f9(t.F9),
+ f10(t.F10),
+ f11(t.F11),
+ }
+ }
+}
+
+// FromArray converts an array of [R] into a [Tuple11] using 11 functions from [R] to [T]
+// The inverse function is [ToArray11]
+func FromArray11[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, F5 ~func(R) T5, F6 ~func(R) T6, F7 ~func(R) T7, F8 ~func(R) T8, F9 ~func(R) T9, F10 ~func(R) T10, F11 ~func(R) T11, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11) func(r []R) Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] {
+ return func(r []R) Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] {
+ return MakeTuple11(
+ f1(r[0]),
+ f2(r[1]),
+ f3(r[2]),
+ f4(r[3]),
+ f5(r[4]),
+ f6(r[5]),
+ f7(r[6]),
+ f8(r[7]),
+ f9(r[8]),
+ f10(r[9]),
+ f11(r[10]),
+ )
+ }
+}
+
+// Push11 creates a [Tuple12] from a [Tuple11] by appending a constant value
+func Push11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](value T12) func(Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] {
+ return func(t Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] {
+ return MakeTuple12(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, value)
+ }
+}
+
+// MakeTuple12 is a function that converts its 12 parameters into a [Tuple12]
+func MakeTuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12) Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] {
+ return Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12}
+}
+
+// Tupled12 converts a function with 12 parameters into a function taking a Tuple12
+// The inverse function is [Untupled12]
+func Tupled12[F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R any](f F) func(Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) R {
+ return func(t Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) R {
+ return f(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12)
+ }
+}
+
+// Untupled12 converts a function with a [Tuple12] parameter into a function with 12 parameters
+// The inverse function is [Tupled12]
+func Untupled12[F ~func(Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) 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) R {
+ return f(MakeTuple12(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12))
+ }
+}
+
+// Monoid12 creates a [Monoid] for a [Tuple12] based on 12 monoids for the contained types
+func Monoid12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8], m9 M.Monoid[T9], m10 M.Monoid[T10], m11 M.Monoid[T11], m12 M.Monoid[T12]) M.Monoid[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] {
+ return M.MakeMonoid(func(l, r Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]{
+ return MakeTuple12(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8), m9.Concat(l.F9, r.F9), m10.Concat(l.F10, r.F10), m11.Concat(l.F11, r.F11), m12.Concat(l.F12, r.F12))
+ }, MakeTuple12(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty(), m9.Empty(), m10.Empty(), m11.Empty(), m12.Empty()))
+}
+
+// Ord12 creates n [Ord] for a [Tuple12] based on 12 [Ord]s for the contained types
+func Ord12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 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], o11 O.Ord[T11], o12 O.Ord[T12]) O.Ord[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] {
+ return O.MakeOrd(func(l, r Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) 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:= o11.Compare(l.F11, r.F11); c != 0 {return c}
+ if c:= o12.Compare(l.F12, r.F12); c != 0 {return c}
+ return 0
+ }, func(l, r Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) 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) && o11.Equals(l.F11, r.F11) && o12.Equals(l.F12, r.F12)
+ })
+}
+
+// Map12 maps each value of a [Tuple12] via a mapping function
+func Map12[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, F8 ~func(T8) R8, F9 ~func(T9) R9, F10 ~func(T10) R10, F11 ~func(T11) R11, F12 ~func(T12) R12, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7, T8, R8, T9, R9, T10, R10, T11, R11, T12, R12 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12) func(Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) Tuple12[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12] {
+ return func(t Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) Tuple12[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12] {
+ return MakeTuple12(
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ f8(t.F8),
+ f9(t.F9),
+ f10(t.F10),
+ f11(t.F11),
+ f12(t.F12),
+ )
+ }
+}
+
+// Replicate12 creates a [Tuple12] with all fields set to the input value `t`
+func Replicate12[T any](t T) Tuple12[T, T, T, T, T, T, T, T, T, T, T, T] {
+ return MakeTuple12(t, t, t, t, t, t, t, t, t, t, t, t)
+}
+
+// String prints some debug info for the [Tuple12]
+func (t Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) String() string {
+ return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12)
+}
+
+// MarshalJSON marshals the [Tuple12] into a JSON array
+func (t Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) MarshalJSON() ([]byte, error) {
+ return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12)
+}
+
+// UnmarshalJSON unmarshals a JSON array into a [Tuple12]
+func (t *Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) UnmarshalJSON(data []byte) error {
+ return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8, &t.F9, &t.F10, &t.F11, &t.F12)
+}
+
+// ToArray converts the [Tuple12] into an array of type [R] using 12 transformation functions from [T] to [R]
+// The inverse function is [FromArray12]
+func ToArray12[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, F5 ~func(T5) R, F6 ~func(T6) R, F7 ~func(T7) R, F8 ~func(T8) R, F9 ~func(T9) R, F10 ~func(T10) R, F11 ~func(T11) R, F12 ~func(T12) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12) func(t Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) []R {
+ return func(t Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) []R {
+ return []R{
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ f8(t.F8),
+ f9(t.F9),
+ f10(t.F10),
+ f11(t.F11),
+ f12(t.F12),
+ }
+ }
+}
+
+// FromArray converts an array of [R] into a [Tuple12] using 12 functions from [R] to [T]
+// The inverse function is [ToArray12]
+func FromArray12[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, F5 ~func(R) T5, F6 ~func(R) T6, F7 ~func(R) T7, F8 ~func(R) T8, F9 ~func(R) T9, F10 ~func(R) T10, F11 ~func(R) T11, F12 ~func(R) T12, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12) func(r []R) Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] {
+ return func(r []R) Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] {
+ return MakeTuple12(
+ f1(r[0]),
+ f2(r[1]),
+ f3(r[2]),
+ f4(r[3]),
+ f5(r[4]),
+ f6(r[5]),
+ f7(r[6]),
+ f8(r[7]),
+ f9(r[8]),
+ f10(r[9]),
+ f11(r[10]),
+ f12(r[11]),
+ )
+ }
+}
+
+// Push12 creates a [Tuple13] from a [Tuple12] by appending a constant value
+func Push12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](value T13) func(Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] {
+ return func(t Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] {
+ return MakeTuple13(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, value)
+ }
+}
+
+// MakeTuple13 is a function that converts its 13 parameters into a [Tuple13]
+func MakeTuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](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) Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] {
+ return Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13}
+}
+
+// Tupled13 converts a function with 13 parameters into a function taking a Tuple13
+// The inverse function is [Untupled13]
+func Tupled13[F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R any](f F) func(Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) R {
+ return func(t Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) R {
+ return f(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13)
+ }
+}
+
+// Untupled13 converts a function with a [Tuple13] parameter into a function with 13 parameters
+// The inverse function is [Tupled13]
+func Untupled13[F ~func(Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) 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) R {
+ return f(MakeTuple13(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13))
+ }
+}
+
+// Monoid13 creates a [Monoid] for a [Tuple13] based on 13 monoids for the contained types
+func Monoid13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8], m9 M.Monoid[T9], m10 M.Monoid[T10], m11 M.Monoid[T11], m12 M.Monoid[T12], m13 M.Monoid[T13]) M.Monoid[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] {
+ return M.MakeMonoid(func(l, r Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]{
+ return MakeTuple13(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8), m9.Concat(l.F9, r.F9), m10.Concat(l.F10, r.F10), m11.Concat(l.F11, r.F11), m12.Concat(l.F12, r.F12), m13.Concat(l.F13, r.F13))
+ }, MakeTuple13(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty(), m9.Empty(), m10.Empty(), m11.Empty(), m12.Empty(), m13.Empty()))
+}
+
+// Ord13 creates n [Ord] for a [Tuple13] based on 13 [Ord]s for the contained types
+func Ord13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 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], o11 O.Ord[T11], o12 O.Ord[T12], o13 O.Ord[T13]) O.Ord[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] {
+ return O.MakeOrd(func(l, r Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) 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:= o11.Compare(l.F11, r.F11); c != 0 {return c}
+ if c:= o12.Compare(l.F12, r.F12); c != 0 {return c}
+ if c:= o13.Compare(l.F13, r.F13); c != 0 {return c}
+ return 0
+ }, func(l, r Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) 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) && o11.Equals(l.F11, r.F11) && o12.Equals(l.F12, r.F12) && o13.Equals(l.F13, r.F13)
+ })
+}
+
+// Map13 maps each value of a [Tuple13] via a mapping function
+func Map13[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, F8 ~func(T8) R8, F9 ~func(T9) R9, F10 ~func(T10) R10, F11 ~func(T11) R11, F12 ~func(T12) R12, F13 ~func(T13) R13, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7, T8, R8, T9, R9, T10, R10, T11, R11, T12, R12, T13, R13 any](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) func(Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) Tuple13[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13] {
+ return func(t Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) Tuple13[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13] {
+ return MakeTuple13(
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ f8(t.F8),
+ f9(t.F9),
+ f10(t.F10),
+ f11(t.F11),
+ f12(t.F12),
+ f13(t.F13),
+ )
+ }
+}
+
+// Replicate13 creates a [Tuple13] with all fields set to the input value `t`
+func Replicate13[T any](t T) Tuple13[T, T, T, T, T, T, T, T, T, T, T, T, T] {
+ return MakeTuple13(t, t, t, t, t, t, t, t, t, t, t, t, t)
+}
+
+// String prints some debug info for the [Tuple13]
+func (t Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) String() string {
+ return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13)
+}
+
+// MarshalJSON marshals the [Tuple13] into a JSON array
+func (t Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) MarshalJSON() ([]byte, error) {
+ return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13)
+}
+
+// UnmarshalJSON unmarshals a JSON array into a [Tuple13]
+func (t *Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) UnmarshalJSON(data []byte) error {
+ return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8, &t.F9, &t.F10, &t.F11, &t.F12, &t.F13)
+}
+
+// ToArray converts the [Tuple13] into an array of type [R] using 13 transformation functions from [T] to [R]
+// The inverse function is [FromArray13]
+func ToArray13[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, F5 ~func(T5) R, F6 ~func(T6) R, F7 ~func(T7) R, F8 ~func(T8) R, F9 ~func(T9) R, F10 ~func(T10) R, F11 ~func(T11) R, F12 ~func(T12) R, F13 ~func(T13) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R any](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) func(t Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) []R {
+ return func(t Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) []R {
+ return []R{
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ f8(t.F8),
+ f9(t.F9),
+ f10(t.F10),
+ f11(t.F11),
+ f12(t.F12),
+ f13(t.F13),
+ }
+ }
+}
+
+// FromArray converts an array of [R] into a [Tuple13] using 13 functions from [R] to [T]
+// The inverse function is [ToArray13]
+func FromArray13[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, F5 ~func(R) T5, F6 ~func(R) T6, F7 ~func(R) T7, F8 ~func(R) T8, F9 ~func(R) T9, F10 ~func(R) T10, F11 ~func(R) T11, F12 ~func(R) T12, F13 ~func(R) T13, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R any](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) func(r []R) Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] {
+ return func(r []R) Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] {
+ return MakeTuple13(
+ f1(r[0]),
+ f2(r[1]),
+ f3(r[2]),
+ f4(r[3]),
+ f5(r[4]),
+ f6(r[5]),
+ f7(r[6]),
+ f8(r[7]),
+ f9(r[8]),
+ f10(r[9]),
+ f11(r[10]),
+ f12(r[11]),
+ f13(r[12]),
+ )
+ }
+}
+
+// Push13 creates a [Tuple14] from a [Tuple13] by appending a constant value
+func Push13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](value T14) func(Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] {
+ return func(t Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] {
+ return MakeTuple14(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13, value)
+ }
+}
+
+// MakeTuple14 is a function that converts its 14 parameters into a [Tuple14]
+func MakeTuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](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) Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] {
+ return Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14}
+}
+
+// Tupled14 converts a function with 14 parameters into a function taking a Tuple14
+// The inverse function is [Untupled14]
+func Tupled14[F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R any](f F) func(Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) R {
+ return func(t Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) R {
+ return f(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13, t.F14)
+ }
+}
+
+// Untupled14 converts a function with a [Tuple14] parameter into a function with 14 parameters
+// The inverse function is [Tupled14]
+func Untupled14[F ~func(Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) 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) R {
+ return f(MakeTuple14(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14))
+ }
+}
+
+// Monoid14 creates a [Monoid] for a [Tuple14] based on 14 monoids for the contained types
+func Monoid14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8], m9 M.Monoid[T9], m10 M.Monoid[T10], m11 M.Monoid[T11], m12 M.Monoid[T12], m13 M.Monoid[T13], m14 M.Monoid[T14]) M.Monoid[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] {
+ return M.MakeMonoid(func(l, r Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]{
+ return MakeTuple14(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8), m9.Concat(l.F9, r.F9), m10.Concat(l.F10, r.F10), m11.Concat(l.F11, r.F11), m12.Concat(l.F12, r.F12), m13.Concat(l.F13, r.F13), m14.Concat(l.F14, r.F14))
+ }, MakeTuple14(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty(), m9.Empty(), m10.Empty(), m11.Empty(), m12.Empty(), m13.Empty(), m14.Empty()))
+}
+
+// Ord14 creates n [Ord] for a [Tuple14] based on 14 [Ord]s for the contained types
+func Ord14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 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], o11 O.Ord[T11], o12 O.Ord[T12], o13 O.Ord[T13], o14 O.Ord[T14]) O.Ord[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] {
+ return O.MakeOrd(func(l, r Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) 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:= o11.Compare(l.F11, r.F11); c != 0 {return c}
+ if c:= o12.Compare(l.F12, r.F12); c != 0 {return c}
+ if c:= o13.Compare(l.F13, r.F13); c != 0 {return c}
+ if c:= o14.Compare(l.F14, r.F14); c != 0 {return c}
+ return 0
+ }, func(l, r Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) 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) && o11.Equals(l.F11, r.F11) && o12.Equals(l.F12, r.F12) && o13.Equals(l.F13, r.F13) && o14.Equals(l.F14, r.F14)
+ })
+}
+
+// Map14 maps each value of a [Tuple14] via a mapping function
+func Map14[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, F8 ~func(T8) R8, F9 ~func(T9) R9, F10 ~func(T10) R10, F11 ~func(T11) R11, F12 ~func(T12) R12, F13 ~func(T13) R13, F14 ~func(T14) R14, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7, T8, R8, T9, R9, T10, R10, T11, R11, T12, R12, T13, R13, T14, R14 any](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) func(Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) Tuple14[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14] {
+ return func(t Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) Tuple14[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14] {
+ return MakeTuple14(
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ f8(t.F8),
+ f9(t.F9),
+ f10(t.F10),
+ f11(t.F11),
+ f12(t.F12),
+ f13(t.F13),
+ f14(t.F14),
+ )
+ }
+}
+
+// Replicate14 creates a [Tuple14] with all fields set to the input value `t`
+func Replicate14[T any](t T) Tuple14[T, T, T, T, T, T, T, T, T, T, T, T, T, T] {
+ return MakeTuple14(t, t, t, t, t, t, t, t, t, t, t, t, t, t)
+}
+
+// String prints some debug info for the [Tuple14]
+func (t Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) String() string {
+ return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13, t.F14)
+}
+
+// MarshalJSON marshals the [Tuple14] into a JSON array
+func (t Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) MarshalJSON() ([]byte, error) {
+ return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13, t.F14)
+}
+
+// UnmarshalJSON unmarshals a JSON array into a [Tuple14]
+func (t *Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) UnmarshalJSON(data []byte) error {
+ return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8, &t.F9, &t.F10, &t.F11, &t.F12, &t.F13, &t.F14)
+}
+
+// ToArray converts the [Tuple14] into an array of type [R] using 14 transformation functions from [T] to [R]
+// The inverse function is [FromArray14]
+func ToArray14[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, F5 ~func(T5) R, F6 ~func(T6) R, F7 ~func(T7) R, F8 ~func(T8) R, F9 ~func(T9) R, F10 ~func(T10) R, F11 ~func(T11) R, F12 ~func(T12) R, F13 ~func(T13) R, F14 ~func(T14) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R any](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) func(t Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) []R {
+ return func(t Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) []R {
+ return []R{
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ f8(t.F8),
+ f9(t.F9),
+ f10(t.F10),
+ f11(t.F11),
+ f12(t.F12),
+ f13(t.F13),
+ f14(t.F14),
+ }
+ }
+}
+
+// FromArray converts an array of [R] into a [Tuple14] using 14 functions from [R] to [T]
+// The inverse function is [ToArray14]
+func FromArray14[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, F5 ~func(R) T5, F6 ~func(R) T6, F7 ~func(R) T7, F8 ~func(R) T8, F9 ~func(R) T9, F10 ~func(R) T10, F11 ~func(R) T11, F12 ~func(R) T12, F13 ~func(R) T13, F14 ~func(R) T14, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R any](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) func(r []R) Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] {
+ return func(r []R) Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] {
+ return MakeTuple14(
+ f1(r[0]),
+ f2(r[1]),
+ f3(r[2]),
+ f4(r[3]),
+ f5(r[4]),
+ f6(r[5]),
+ f7(r[6]),
+ f8(r[7]),
+ f9(r[8]),
+ f10(r[9]),
+ f11(r[10]),
+ f12(r[11]),
+ f13(r[12]),
+ f14(r[13]),
+ )
+ }
+}
+
+// Push14 creates a [Tuple15] from a [Tuple14] by appending a constant value
+func Push14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](value T15) func(Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] {
+ return func(t Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] {
+ return MakeTuple15(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13, t.F14, value)
+ }
+}
+
+// MakeTuple15 is a function that converts its 15 parameters into a [Tuple15]
+func MakeTuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](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) Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] {
+ return Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15}
+}
+
+// Tupled15 converts a function with 15 parameters into a function taking a Tuple15
+// The inverse function is [Untupled15]
+func Tupled15[F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R any](f F) func(Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) R {
+ return func(t Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) R {
+ return f(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13, t.F14, t.F15)
+ }
+}
+
+// Untupled15 converts a function with a [Tuple15] parameter into a function with 15 parameters
+// The inverse function is [Tupled15]
+func Untupled15[F ~func(Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) 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) R {
+ return f(MakeTuple15(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15))
+ }
+}
+
+// Monoid15 creates a [Monoid] for a [Tuple15] based on 15 monoids for the contained types
+func Monoid15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3], m4 M.Monoid[T4], m5 M.Monoid[T5], m6 M.Monoid[T6], m7 M.Monoid[T7], m8 M.Monoid[T8], m9 M.Monoid[T9], m10 M.Monoid[T10], m11 M.Monoid[T11], m12 M.Monoid[T12], m13 M.Monoid[T13], m14 M.Monoid[T14], m15 M.Monoid[T15]) M.Monoid[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] {
+ return M.MakeMonoid(func(l, r Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]{
+ return MakeTuple15(m1.Concat(l.F1, r.F1), m2.Concat(l.F2, r.F2), m3.Concat(l.F3, r.F3), m4.Concat(l.F4, r.F4), m5.Concat(l.F5, r.F5), m6.Concat(l.F6, r.F6), m7.Concat(l.F7, r.F7), m8.Concat(l.F8, r.F8), m9.Concat(l.F9, r.F9), m10.Concat(l.F10, r.F10), m11.Concat(l.F11, r.F11), m12.Concat(l.F12, r.F12), m13.Concat(l.F13, r.F13), m14.Concat(l.F14, r.F14), m15.Concat(l.F15, r.F15))
+ }, MakeTuple15(m1.Empty(), m2.Empty(), m3.Empty(), m4.Empty(), m5.Empty(), m6.Empty(), m7.Empty(), m8.Empty(), m9.Empty(), m10.Empty(), m11.Empty(), m12.Empty(), m13.Empty(), m14.Empty(), m15.Empty()))
+}
+
+// Ord15 creates n [Ord] for a [Tuple15] based on 15 [Ord]s for the contained types
+func Ord15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 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], o11 O.Ord[T11], o12 O.Ord[T12], o13 O.Ord[T13], o14 O.Ord[T14], o15 O.Ord[T15]) O.Ord[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] {
+ return O.MakeOrd(func(l, r Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) 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:= o11.Compare(l.F11, r.F11); c != 0 {return c}
+ if c:= o12.Compare(l.F12, r.F12); c != 0 {return c}
+ if c:= o13.Compare(l.F13, r.F13); c != 0 {return c}
+ if c:= o14.Compare(l.F14, r.F14); c != 0 {return c}
+ if c:= o15.Compare(l.F15, r.F15); c != 0 {return c}
+ return 0
+ }, func(l, r Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) 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) && o11.Equals(l.F11, r.F11) && o12.Equals(l.F12, r.F12) && o13.Equals(l.F13, r.F13) && o14.Equals(l.F14, r.F14) && o15.Equals(l.F15, r.F15)
+ })
+}
+
+// Map15 maps each value of a [Tuple15] via a mapping function
+func Map15[F1 ~func(T1) R1, F2 ~func(T2) R2, F3 ~func(T3) R3, F4 ~func(T4) R4, F5 ~func(T5) R5, F6 ~func(T6) R6, F7 ~func(T7) R7, F8 ~func(T8) R8, F9 ~func(T9) R9, F10 ~func(T10) R10, F11 ~func(T11) R11, F12 ~func(T12) R12, F13 ~func(T13) R13, F14 ~func(T14) R14, F15 ~func(T15) R15, T1, R1, T2, R2, T3, R3, T4, R4, T5, R5, T6, R6, T7, R7, T8, R8, T9, R9, T10, R10, T11, R11, T12, R12, T13, R13, T14, R14, T15, R15 any](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) func(Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) Tuple15[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15] {
+ return func(t Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) Tuple15[R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15] {
+ return MakeTuple15(
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ f8(t.F8),
+ f9(t.F9),
+ f10(t.F10),
+ f11(t.F11),
+ f12(t.F12),
+ f13(t.F13),
+ f14(t.F14),
+ f15(t.F15),
+ )
+ }
+}
+
+// Replicate15 creates a [Tuple15] with all fields set to the input value `t`
+func Replicate15[T any](t T) Tuple15[T, T, T, T, T, T, T, T, T, T, T, T, T, T, T] {
+ return MakeTuple15(t, t, t, t, t, t, t, t, t, t, t, t, t, t, t)
+}
+
+// String prints some debug info for the [Tuple15]
+func (t Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) String() string {
+ return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13, t.F14, t.F15)
+}
+
+// MarshalJSON marshals the [Tuple15] into a JSON array
+func (t Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) MarshalJSON() ([]byte, error) {
+ return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F11, t.F12, t.F13, t.F14, t.F15)
+}
+
+// UnmarshalJSON unmarshals a JSON array into a [Tuple15]
+func (t *Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) UnmarshalJSON(data []byte) error {
+ return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8, &t.F9, &t.F10, &t.F11, &t.F12, &t.F13, &t.F14, &t.F15)
+}
+
+// ToArray converts the [Tuple15] into an array of type [R] using 15 transformation functions from [T] to [R]
+// The inverse function is [FromArray15]
+func ToArray15[F1 ~func(T1) R, F2 ~func(T2) R, F3 ~func(T3) R, F4 ~func(T4) R, F5 ~func(T5) R, F6 ~func(T6) R, F7 ~func(T7) R, F8 ~func(T8) R, F9 ~func(T9) R, F10 ~func(T10) R, F11 ~func(T11) R, F12 ~func(T12) R, F13 ~func(T13) R, F14 ~func(T14) R, F15 ~func(T15) R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R any](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) func(t Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) []R {
+ return func(t Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) []R {
+ return []R{
+ f1(t.F1),
+ f2(t.F2),
+ f3(t.F3),
+ f4(t.F4),
+ f5(t.F5),
+ f6(t.F6),
+ f7(t.F7),
+ f8(t.F8),
+ f9(t.F9),
+ f10(t.F10),
+ f11(t.F11),
+ f12(t.F12),
+ f13(t.F13),
+ f14(t.F14),
+ f15(t.F15),
+ }
+ }
+}
+
+// FromArray converts an array of [R] into a [Tuple15] using 15 functions from [R] to [T]
+// The inverse function is [ToArray15]
+func FromArray15[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4, F5 ~func(R) T5, F6 ~func(R) T6, F7 ~func(R) T7, F8 ~func(R) T8, F9 ~func(R) T9, F10 ~func(R) T10, F11 ~func(R) T11, F12 ~func(R) T12, F13 ~func(R) T13, F14 ~func(R) T14, F15 ~func(R) T15, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R any](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) func(r []R) Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] {
+ return func(r []R) Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] {
+ return MakeTuple15(
+ f1(r[0]),
+ f2(r[1]),
+ f3(r[2]),
+ f4(r[3]),
+ f5(r[4]),
+ f6(r[5]),
+ f7(r[6]),
+ f8(r[7]),
+ f9(r[8]),
+ f10(r[9]),
+ f11(r[10]),
+ f12(r[11]),
+ f13(r[12]),
+ f14(r[13]),
+ f15(r[14]),
+ )
+ }
+}
diff --git a/v2/tuple/tuple.go b/v2/tuple/tuple.go
new file mode 100644
index 0000000..1d8f879
--- /dev/null
+++ b/v2/tuple/tuple.go
@@ -0,0 +1,134 @@
+// Copyright (c) 2023 - 2025 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 tuple contains type definitions and functions for data structures for tuples of heterogenous types. For homogeneous types
+// consider to use arrays for simplicity
+package tuple
+
+import (
+ "encoding/json"
+ "fmt"
+ "strings"
+
+ N "github.com/IBM/fp-go/v2/number"
+)
+
+// Of creates a [Tuple1] from a single value.
+// This is a convenience function equivalent to [MakeTuple1].
+//
+// Example:
+//
+// t := tuple.Of(42) // Creates Tuple1[int]{F1: 42}
+func Of[T1 any](t T1) Tuple1[T1] {
+ return MakeTuple1(t)
+}
+
+// First returns the first element of a [Tuple2].
+// This is a convenience accessor for the F1 field.
+//
+// Example:
+//
+// t := tuple.MakeTuple2("hello", 42)
+// s := tuple.First(t) // Returns "hello"
+func First[T1, T2 any](t Tuple2[T1, T2]) T1 {
+ return t.F1
+}
+
+// Second returns the second element of a [Tuple2].
+// This is a convenience accessor for the F2 field.
+//
+// Example:
+//
+// t := tuple.MakeTuple2("hello", 42)
+// n := tuple.Second(t) // Returns 42
+func Second[T1, T2 any](t Tuple2[T1, T2]) T2 {
+ return t.F2
+}
+
+// Swap exchanges the positions of the two elements in a [Tuple2].
+// The first element becomes the second, and the second becomes the first.
+//
+// Example:
+//
+// t := tuple.MakeTuple2("hello", 42)
+// swapped := tuple.Swap(t) // Returns Tuple2[int, string]{F1: 42, F2: "hello"}
+func Swap[T1, T2 any](t Tuple2[T1, T2]) Tuple2[T2, T1] {
+ return MakeTuple2(t.F2, t.F1)
+}
+
+// Of2 creates a curried function that pairs a value with a constant second element.
+// It returns a function that takes a value of type T1 and creates a [Tuple2] with
+// the provided constant value e as the second element.
+//
+// This is useful for partial application and functional composition.
+//
+// Example:
+//
+// pairWith42 := tuple.Of2[string](42)
+// t := pairWith42("hello") // Returns Tuple2[string, int]{F1: "hello", F2: 42}
+func Of2[T1, T2 any](e T2) func(T1) Tuple2[T1, T2] {
+ return func(t T1) Tuple2[T1, T2] {
+ return MakeTuple2(t, e)
+ }
+}
+
+// BiMap applies two mapping functions to both elements of a [Tuple2].
+// The first function (mapSnd) is applied to the second element,
+// and the second function (mapFst) is applied to the first element.
+//
+// This is a bifunctor map operation that allows independent transformation
+// of both tuple elements.
+//
+// Example:
+//
+// t := tuple.MakeTuple2(5, "hello")
+// mapper := tuple.BiMap(
+// func(s string) int { return len(s) },
+// func(n int) string { return fmt.Sprintf("%d", n*2) },
+// )
+// result := mapper(t) // Returns Tuple2[string, int]{F1: "10", F2: 5}
+func BiMap[E, G, A, B any](mapSnd func(E) G, mapFst func(A) B) func(Tuple2[A, E]) Tuple2[B, G] {
+ return func(t Tuple2[A, E]) Tuple2[B, G] {
+ return MakeTuple2(mapFst(First(t)), mapSnd(Second(t)))
+ }
+}
+
+// marshalJSON marshals the tuple into a JSON array
+func tupleMarshalJSON(src ...any) ([]byte, error) {
+ return json.Marshal(src)
+}
+
+// tupleUnmarshalJSON unmarshals a JSON array into a tuple
+func tupleUnmarshalJSON(data []byte, dst ...any) error {
+ var src []json.RawMessage
+ if err := json.Unmarshal(data, &src); err != nil {
+ return err
+ }
+ l := N.Min(len(src), len(dst))
+ // unmarshal
+ for i := 0; i < l; i++ {
+ if err := json.Unmarshal(src[i], dst[i]); err != nil {
+ return err
+ }
+ }
+ // successfully decoded the tuple
+ return nil
+}
+
+// tupleString converts a tuple to a string
+func tupleString(src ...any) string {
+ l := len(src)
+ return fmt.Sprintf("Tuple%d[%s](%s)", l, fmt.Sprintf(strings.Repeat(", %T", l)[2:], src...), fmt.Sprintf(strings.Repeat(", %v", l)[2:], src...))
+}
diff --git a/v2/tuple/tuple.test.exe b/v2/tuple/tuple.test.exe
new file mode 100644
index 0000000..8522482
Binary files /dev/null and b/v2/tuple/tuple.test.exe differ
diff --git a/v2/tuple/tuple_test.go b/v2/tuple/tuple_test.go
new file mode 100644
index 0000000..3e10f01
--- /dev/null
+++ b/v2/tuple/tuple_test.go
@@ -0,0 +1,2013 @@
+// Copyright (c) 2023 - 2025 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 tuple
+
+import (
+ "encoding/json"
+ "fmt"
+ "testing"
+
+ "github.com/IBM/fp-go/v2/number"
+ O "github.com/IBM/fp-go/v2/ord"
+ S "github.com/IBM/fp-go/v2/string"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+func TestString(t *testing.T) {
+ value := MakeTuple2("Carsten", 1)
+ assert.Equal(t, "Tuple2[string, int](Carsten, 1)", value.String())
+}
+
+func TestMarshal(t *testing.T) {
+ value := MakeTuple3("Carsten", 1, true)
+
+ data, err := json.Marshal(value)
+ require.NoError(t, err)
+
+ var unmarshaled Tuple3[string, int, bool]
+ err = json.Unmarshal(data, &unmarshaled)
+ require.NoError(t, err)
+
+ assert.Equal(t, value, unmarshaled)
+}
+
+func TestMarshalSmallArray(t *testing.T) {
+ value := `["Carsten"]`
+
+ var unmarshaled Tuple3[string, int, bool]
+ err := json.Unmarshal([]byte(value), &unmarshaled)
+ require.NoError(t, err)
+
+ assert.Equal(t, MakeTuple3("Carsten", 0, false), unmarshaled)
+}
+
+// Test Of function
+func TestOf(t *testing.T) {
+ t1 := Of(42)
+ assert.Equal(t, Tuple1[int]{F1: 42}, t1)
+ assert.Equal(t, 42, t1.F1)
+}
+
+// Test First and Second functions
+func TestFirstSecond(t *testing.T) {
+ t2 := MakeTuple2("hello", 42)
+ assert.Equal(t, "hello", First(t2))
+ assert.Equal(t, 42, Second(t2))
+}
+
+// Test Swap function
+func TestSwap(t *testing.T) {
+ t2 := MakeTuple2("hello", 42)
+ swapped := Swap(t2)
+ assert.Equal(t, MakeTuple2(42, "hello"), swapped)
+ assert.Equal(t, 42, swapped.F1)
+ assert.Equal(t, "hello", swapped.F2)
+}
+
+// Test Of2 function
+func TestOf2(t *testing.T) {
+ pairWith42 := Of2[string](42)
+ result := pairWith42("hello")
+ assert.Equal(t, MakeTuple2("hello", 42), result)
+}
+
+// Test BiMap function
+func TestBiMap(t *testing.T) {
+ t2 := MakeTuple2(5, "hello")
+ mapper := BiMap(
+ func(s string) int { return len(s) },
+ func(n int) string { return fmt.Sprintf("%d", n*2) },
+ )
+ result := mapper(t2)
+ assert.Equal(t, MakeTuple2("10", 5), result)
+}
+
+// Test Tupled and Untupled functions
+func TestTupled2Untupled2(t *testing.T) {
+ add := func(a, b int) int { return a + b }
+
+ // Test Tupled2
+ tupledAdd := Tupled2(add)
+ result := tupledAdd(MakeTuple2(3, 4))
+ assert.Equal(t, 7, result)
+
+ // Test Untupled2
+ untupledAdd := Untupled2(tupledAdd)
+ result2 := untupledAdd(5, 6)
+ assert.Equal(t, 11, result2)
+}
+
+func TestTupled3Untupled3(t *testing.T) {
+ sum3 := func(a, b, c int) int { return a + b + c }
+
+ tupled := Tupled3(sum3)
+ result := tupled(MakeTuple3(1, 2, 3))
+ assert.Equal(t, 6, result)
+
+ untupled := Untupled3(tupled)
+ result2 := untupled(4, 5, 6)
+ assert.Equal(t, 15, result2)
+}
+
+// Test Map functions
+func TestMap1(t *testing.T) {
+ t1 := MakeTuple1(5)
+ mapper := Map1(func(n int) string { return fmt.Sprintf("%d", n*2) })
+ result := mapper(t1)
+ assert.Equal(t, MakeTuple1("10"), result)
+}
+
+func TestMap2(t *testing.T) {
+ t2 := MakeTuple2(5, "hello")
+ mapper := Map2(
+ func(n int) string { return fmt.Sprintf("%d", n*2) },
+ func(s string) int { return len(s) },
+ )
+ result := mapper(t2)
+ assert.Equal(t, MakeTuple2("10", 5), result)
+}
+
+func TestMap3(t *testing.T) {
+ t3 := MakeTuple3(1, 2, 3)
+ mapper := Map3(
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 3 },
+ func(n int) int { return n * 4 },
+ )
+ result := mapper(t3)
+ assert.Equal(t, MakeTuple3(2, 6, 12), result)
+}
+
+// Test Replicate functions
+func TestReplicate1(t *testing.T) {
+ result := Replicate1(42)
+ assert.Equal(t, MakeTuple1(42), result)
+}
+
+func TestReplicate2(t *testing.T) {
+ result := Replicate2(42)
+ assert.Equal(t, MakeTuple2(42, 42), result)
+}
+
+func TestReplicate3(t *testing.T) {
+ result := Replicate3(42)
+ assert.Equal(t, MakeTuple3(42, 42, 42), result)
+}
+
+// Test ToArray and FromArray functions
+func TestToArray1FromArray1(t *testing.T) {
+ t1 := MakeTuple1(42)
+ toArray := ToArray1(func(n int) int { return n })
+ arr := toArray(t1)
+ assert.Equal(t, []int{42}, arr)
+
+ fromArray := FromArray1(func(n int) int { return n })
+ result := fromArray(arr)
+ assert.Equal(t, t1, result)
+}
+
+func TestToArray2FromArray2(t *testing.T) {
+ t2 := MakeTuple2(1, 2)
+ toArray := ToArray2(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ arr := toArray(t2)
+ assert.Equal(t, []int{1, 2}, arr)
+
+ fromArray := FromArray2(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ result := fromArray(arr)
+ assert.Equal(t, t2, result)
+}
+
+func TestToArray3FromArray3(t *testing.T) {
+ t3 := MakeTuple3(1, 2, 3)
+ toArray := ToArray3(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ arr := toArray(t3)
+ assert.Equal(t, []int{1, 2, 3}, arr)
+
+ fromArray := FromArray3(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ result := fromArray(arr)
+ assert.Equal(t, t3, result)
+}
+
+// Test Push functions
+func TestPush1(t *testing.T) {
+ t1 := MakeTuple1(42)
+ push := Push1[int, string]("hello")
+ result := push(t1)
+ assert.Equal(t, MakeTuple2(42, "hello"), result)
+}
+
+func TestPush2(t *testing.T) {
+ t2 := MakeTuple2(1, 2)
+ push := Push2[int, int, int](3)
+ result := push(t2)
+ assert.Equal(t, MakeTuple3(1, 2, 3), result)
+}
+
+func TestPush3(t *testing.T) {
+ t3 := MakeTuple3(1, 2, 3)
+ push := Push3[int, int, int, int](4)
+ result := push(t3)
+ assert.Equal(t, MakeTuple4(1, 2, 3, 4), result)
+}
+
+// Test Monoid functions
+func TestMonoid1(t *testing.T) {
+ m := Monoid1(number.MonoidSum[int]())
+ t1 := MakeTuple1(5)
+ t2 := MakeTuple1(3)
+ result := m.Concat(t1, t2)
+ assert.Equal(t, MakeTuple1(8), result)
+ assert.Equal(t, MakeTuple1(0), m.Empty())
+}
+
+func TestMonoid2(t *testing.T) {
+ m := Monoid2(S.Monoid, number.MonoidSum[int]())
+ t1 := MakeTuple2("hello", 5)
+ t2 := MakeTuple2(" world", 3)
+ result := m.Concat(t1, t2)
+ assert.Equal(t, MakeTuple2("hello world", 8), result)
+ assert.Equal(t, MakeTuple2("", 0), m.Empty())
+}
+
+func TestMonoid3(t *testing.T) {
+ m := Monoid3(S.Monoid, number.MonoidSum[int](), number.MonoidProduct[int]())
+ t1 := MakeTuple3("a", 2, 3)
+ t2 := MakeTuple3("b", 4, 5)
+ result := m.Concat(t1, t2)
+ assert.Equal(t, MakeTuple3("ab", 6, 15), result)
+}
+
+// Test Ord functions
+func TestOrd1(t *testing.T) {
+ o := Ord1(O.FromStrictCompare[int]())
+ t1 := MakeTuple1(5)
+ t2 := MakeTuple1(3)
+ t3 := MakeTuple1(5)
+
+ assert.Equal(t, 1, o.Compare(t1, t2))
+ assert.Equal(t, -1, o.Compare(t2, t1))
+ assert.Equal(t, 0, o.Compare(t1, t3))
+ assert.True(t, o.Equals(t1, t3))
+ assert.False(t, o.Equals(t1, t2))
+}
+
+func TestOrd2(t *testing.T) {
+ o := Ord2(O.FromStrictCompare[string](), O.FromStrictCompare[int]())
+ t1 := MakeTuple2("a", 1)
+ t2 := MakeTuple2("b", 2)
+ t3 := MakeTuple2("a", 1)
+ t4 := MakeTuple2("a", 2)
+
+ assert.Equal(t, -1, o.Compare(t1, t2))
+ assert.Equal(t, 1, o.Compare(t2, t1))
+ assert.Equal(t, 0, o.Compare(t1, t3))
+ assert.Equal(t, -1, o.Compare(t1, t4))
+ assert.True(t, o.Equals(t1, t3))
+ assert.False(t, o.Equals(t1, t2))
+}
+
+func TestOrd3(t *testing.T) {
+ o := Ord3(O.FromStrictCompare[int](), O.FromStrictCompare[int](), O.FromStrictCompare[int]())
+ t1 := MakeTuple3(1, 2, 3)
+ t2 := MakeTuple3(1, 2, 4)
+ t3 := MakeTuple3(1, 2, 3)
+
+ assert.Equal(t, -1, o.Compare(t1, t2))
+ assert.Equal(t, 0, o.Compare(t1, t3))
+ assert.True(t, o.Equals(t1, t3))
+}
+
+// Test String methods for different tuple sizes
+func TestTuple1String(t *testing.T) {
+ t1 := MakeTuple1(42)
+ assert.Equal(t, "Tuple1[int](42)", t1.String())
+}
+
+func TestTuple3String(t *testing.T) {
+ t3 := MakeTuple3("test", 42, true)
+ assert.Equal(t, "Tuple3[string, int, bool](test, 42, true)", t3.String())
+}
+
+func TestTuple4String(t *testing.T) {
+ t4 := MakeTuple4(1, 2, 3, 4)
+ assert.Equal(t, "Tuple4[int, int, int, int](1, 2, 3, 4)", t4.String())
+}
+
+// Test JSON marshaling for different tuple sizes
+func TestTuple1JSON(t *testing.T) {
+ t1 := MakeTuple1(42)
+ data, err := json.Marshal(t1)
+ require.NoError(t, err)
+ assert.Equal(t, "[42]", string(data))
+
+ var unmarshaled Tuple1[int]
+ err = json.Unmarshal(data, &unmarshaled)
+ require.NoError(t, err)
+ assert.Equal(t, t1, unmarshaled)
+}
+
+func TestTuple2JSON(t *testing.T) {
+ t2 := MakeTuple2("hello", 42)
+ data, err := json.Marshal(t2)
+ require.NoError(t, err)
+
+ var unmarshaled Tuple2[string, int]
+ err = json.Unmarshal(data, &unmarshaled)
+ require.NoError(t, err)
+ assert.Equal(t, t2, unmarshaled)
+}
+
+func TestTuple4JSON(t *testing.T) {
+ t4 := MakeTuple4(1, 2, 3, 4)
+ data, err := json.Marshal(t4)
+ require.NoError(t, err)
+
+ var unmarshaled Tuple4[int, int, int, int]
+ err = json.Unmarshal(data, &unmarshaled)
+ require.NoError(t, err)
+ assert.Equal(t, t4, unmarshaled)
+}
+
+func TestTuple5JSON(t *testing.T) {
+ t5 := MakeTuple5(1, 2, 3, 4, 5)
+ data, err := json.Marshal(t5)
+ require.NoError(t, err)
+
+ var unmarshaled Tuple5[int, int, int, int, int]
+ err = json.Unmarshal(data, &unmarshaled)
+ require.NoError(t, err)
+ assert.Equal(t, t5, unmarshaled)
+}
+
+// Test JSON unmarshal error cases
+func TestUnmarshalInvalidJSON(t *testing.T) {
+ var t2 Tuple2[string, int]
+ err := json.Unmarshal([]byte("invalid json"), &t2)
+ assert.Error(t, err)
+}
+
+func TestUnmarshalInvalidType(t *testing.T) {
+ var t2 Tuple2[int, int]
+ err := json.Unmarshal([]byte(`["string", 42]`), &t2)
+ assert.Error(t, err)
+}
+
+// Test MakeTuple functions for various sizes
+func TestMakeTuple4(t *testing.T) {
+ t4 := MakeTuple4(1, "two", 3.0, true)
+ assert.Equal(t, 1, t4.F1)
+ assert.Equal(t, "two", t4.F2)
+ assert.Equal(t, 3.0, t4.F3)
+ assert.Equal(t, true, t4.F4)
+}
+
+func TestMakeTuple5(t *testing.T) {
+ t5 := MakeTuple5(1, 2, 3, 4, 5)
+ assert.Equal(t, 1, t5.F1)
+ assert.Equal(t, 5, t5.F5)
+}
+
+func TestMakeTuple6(t *testing.T) {
+ t6 := MakeTuple6(1, 2, 3, 4, 5, 6)
+ assert.Equal(t, 1, t6.F1)
+ assert.Equal(t, 6, t6.F6)
+}
+
+// Test Tupled/Untupled for larger tuples
+func TestTupled4Untupled4(t *testing.T) {
+ sum4 := func(a, b, c, d int) int { return a + b + c + d }
+
+ tupled := Tupled4(sum4)
+ result := tupled(MakeTuple4(1, 2, 3, 4))
+ assert.Equal(t, 10, result)
+
+ untupled := Untupled4(tupled)
+ result2 := untupled(2, 3, 4, 5)
+ assert.Equal(t, 14, result2)
+}
+
+func TestTupled5Untupled5(t *testing.T) {
+ sum5 := func(a, b, c, d, e int) int { return a + b + c + d + e }
+
+ tupled := Tupled5(sum5)
+ result := tupled(MakeTuple5(1, 2, 3, 4, 5))
+ assert.Equal(t, 15, result)
+
+ untupled := Untupled5(tupled)
+ result2 := untupled(1, 1, 1, 1, 1)
+ assert.Equal(t, 5, result2)
+}
+
+// Test Map for larger tuples
+func TestMap4(t *testing.T) {
+ t4 := MakeTuple4(1, 2, 3, 4)
+ mapper := Map4(
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 3 },
+ func(n int) int { return n * 4 },
+ func(n int) int { return n * 5 },
+ )
+ result := mapper(t4)
+ assert.Equal(t, MakeTuple4(2, 6, 12, 20), result)
+}
+
+func TestMap5(t *testing.T) {
+ t5 := MakeTuple5(1, 2, 3, 4, 5)
+ mapper := Map5(
+ func(n int) int { return n + 1 },
+ func(n int) int { return n + 2 },
+ func(n int) int { return n + 3 },
+ func(n int) int { return n + 4 },
+ func(n int) int { return n + 5 },
+ )
+ result := mapper(t5)
+ assert.Equal(t, MakeTuple5(2, 4, 6, 8, 10), result)
+}
+
+// Test Replicate for larger tuples
+func TestReplicate4(t *testing.T) {
+ result := Replicate4(7)
+ assert.Equal(t, MakeTuple4(7, 7, 7, 7), result)
+}
+
+func TestReplicate5(t *testing.T) {
+ result := Replicate5(9)
+ assert.Equal(t, MakeTuple5(9, 9, 9, 9, 9), result)
+}
+
+// Test ToArray/FromArray for larger tuples
+func TestToArray4FromArray4(t *testing.T) {
+ t4 := MakeTuple4(1, 2, 3, 4)
+ toArray := ToArray4(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ arr := toArray(t4)
+ assert.Equal(t, []int{1, 2, 3, 4}, arr)
+
+ fromArray := FromArray4(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ result := fromArray(arr)
+ assert.Equal(t, t4, result)
+}
+
+func TestToArray5FromArray5(t *testing.T) {
+ t5 := MakeTuple5(1, 2, 3, 4, 5)
+ toArray := ToArray5(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ arr := toArray(t5)
+ assert.Equal(t, []int{1, 2, 3, 4, 5}, arr)
+
+ fromArray := FromArray5(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ result := fromArray(arr)
+ assert.Equal(t, t5, result)
+}
+
+// Test Push for larger tuples
+func TestPush4(t *testing.T) {
+ t4 := MakeTuple4(1, 2, 3, 4)
+ push := Push4[int, int, int, int, int](5)
+ result := push(t4)
+ assert.Equal(t, MakeTuple5(1, 2, 3, 4, 5), result)
+}
+
+func TestPush5(t *testing.T) {
+ t5 := MakeTuple5(1, 2, 3, 4, 5)
+ push := Push5[int, int, int, int, int, int](6)
+ result := push(t5)
+ assert.Equal(t, MakeTuple6(1, 2, 3, 4, 5, 6), result)
+}
+
+// Test Monoid for larger tuples
+func TestMonoid4(t *testing.T) {
+ m := Monoid4(
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ )
+ t1 := MakeTuple4(1, 2, 3, 4)
+ t2 := MakeTuple4(5, 6, 7, 8)
+ result := m.Concat(t1, t2)
+ assert.Equal(t, MakeTuple4(6, 8, 10, 12), result)
+}
+
+func TestMonoid5(t *testing.T) {
+ m := Monoid5(
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ )
+ t1 := MakeTuple5(1, 2, 3, 4, 5)
+ t2 := MakeTuple5(1, 1, 1, 1, 1)
+ result := m.Concat(t1, t2)
+ assert.Equal(t, MakeTuple5(2, 3, 4, 5, 6), result)
+}
+
+// Test Ord for larger tuples
+func TestOrd4(t *testing.T) {
+ o := Ord4(
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ )
+ t1 := MakeTuple4(1, 2, 3, 4)
+ t2 := MakeTuple4(1, 2, 3, 5)
+ t3 := MakeTuple4(1, 2, 3, 4)
+
+ assert.Equal(t, -1, o.Compare(t1, t2))
+ assert.Equal(t, 0, o.Compare(t1, t3))
+ assert.True(t, o.Equals(t1, t3))
+}
+
+func TestOrd5(t *testing.T) {
+ o := Ord5(
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ )
+ t1 := MakeTuple5(1, 2, 3, 4, 5)
+ t2 := MakeTuple5(1, 2, 3, 4, 6)
+ t3 := MakeTuple5(1, 2, 3, 4, 5)
+
+ assert.Equal(t, -1, o.Compare(t1, t2))
+ assert.Equal(t, 0, o.Compare(t1, t3))
+ assert.True(t, o.Equals(t1, t3))
+}
+
+// Test larger tuple sizes (6-10)
+func TestMakeTuple7(t *testing.T) {
+ t7 := MakeTuple7(1, 2, 3, 4, 5, 6, 7)
+ assert.Equal(t, 1, t7.F1)
+ assert.Equal(t, 7, t7.F7)
+}
+
+func TestMakeTuple8(t *testing.T) {
+ t8 := MakeTuple8(1, 2, 3, 4, 5, 6, 7, 8)
+ assert.Equal(t, 1, t8.F1)
+ assert.Equal(t, 8, t8.F8)
+}
+
+func TestMakeTuple9(t *testing.T) {
+ t9 := MakeTuple9(1, 2, 3, 4, 5, 6, 7, 8, 9)
+ assert.Equal(t, 1, t9.F1)
+ assert.Equal(t, 9, t9.F9)
+}
+
+func TestMakeTuple10(t *testing.T) {
+ t10 := MakeTuple10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+ assert.Equal(t, 1, t10.F1)
+ assert.Equal(t, 10, t10.F10)
+}
+
+// Test Tupled/Untupled for sizes 6-10
+func TestTupled6Untupled6(t *testing.T) {
+ sum6 := func(a, b, c, d, e, f int) int { return a + b + c + d + e + f }
+
+ tupled := Tupled6(sum6)
+ result := tupled(MakeTuple6(1, 2, 3, 4, 5, 6))
+ assert.Equal(t, 21, result)
+
+ untupled := Untupled6(tupled)
+ result2 := untupled(1, 1, 1, 1, 1, 1)
+ assert.Equal(t, 6, result2)
+}
+
+func TestTupled7Untupled7(t *testing.T) {
+ sum7 := func(a, b, c, d, e, f, g int) int { return a + b + c + d + e + f + g }
+
+ tupled := Tupled7(sum7)
+ result := tupled(MakeTuple7(1, 2, 3, 4, 5, 6, 7))
+ assert.Equal(t, 28, result)
+
+ untupled := Untupled7(tupled)
+ result2 := untupled(1, 1, 1, 1, 1, 1, 1)
+ assert.Equal(t, 7, result2)
+}
+
+func TestTupled8Untupled8(t *testing.T) {
+ sum8 := func(a, b, c, d, e, f, g, h int) int { return a + b + c + d + e + f + g + h }
+
+ tupled := Tupled8(sum8)
+ result := tupled(MakeTuple8(1, 2, 3, 4, 5, 6, 7, 8))
+ assert.Equal(t, 36, result)
+
+ untupled := Untupled8(tupled)
+ result2 := untupled(1, 1, 1, 1, 1, 1, 1, 1)
+ assert.Equal(t, 8, result2)
+}
+
+func TestTupled9Untupled9(t *testing.T) {
+ sum9 := func(a, b, c, d, e, f, g, h, i int) int { return a + b + c + d + e + f + g + h + i }
+
+ tupled := Tupled9(sum9)
+ result := tupled(MakeTuple9(1, 2, 3, 4, 5, 6, 7, 8, 9))
+ assert.Equal(t, 45, result)
+
+ untupled := Untupled9(tupled)
+ result2 := untupled(1, 1, 1, 1, 1, 1, 1, 1, 1)
+ assert.Equal(t, 9, result2)
+}
+
+func TestTupled10Untupled10(t *testing.T) {
+ sum10 := func(a, b, c, d, e, f, g, h, i, j int) int { return a + b + c + d + e + f + g + h + i + j }
+
+ tupled := Tupled10(sum10)
+ result := tupled(MakeTuple10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
+ assert.Equal(t, 55, result)
+
+ untupled := Untupled10(tupled)
+ result2 := untupled(1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
+ assert.Equal(t, 10, result2)
+}
+
+// Test Map for sizes 6-10
+func TestMap6(t *testing.T) {
+ t6 := MakeTuple6(1, 2, 3, 4, 5, 6)
+ mapper := Map6(
+ func(n int) int { return n + 1 },
+ func(n int) int { return n + 2 },
+ func(n int) int { return n + 3 },
+ func(n int) int { return n + 4 },
+ func(n int) int { return n + 5 },
+ func(n int) int { return n + 6 },
+ )
+ result := mapper(t6)
+ assert.Equal(t, MakeTuple6(2, 4, 6, 8, 10, 12), result)
+}
+
+func TestMap7(t *testing.T) {
+ t7 := MakeTuple7(1, 2, 3, 4, 5, 6, 7)
+ mapper := Map7(
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ )
+ result := mapper(t7)
+ assert.Equal(t, MakeTuple7(2, 4, 6, 8, 10, 12, 14), result)
+}
+
+func TestMap8(t *testing.T) {
+ t8 := MakeTuple8(1, 2, 3, 4, 5, 6, 7, 8)
+ mapper := Map8(
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ )
+ result := mapper(t8)
+ assert.Equal(t, MakeTuple8(2, 4, 6, 8, 10, 12, 14, 16), result)
+}
+
+func TestMap9(t *testing.T) {
+ t9 := MakeTuple9(1, 2, 3, 4, 5, 6, 7, 8, 9)
+ mapper := Map9(
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ )
+ result := mapper(t9)
+ assert.Equal(t, MakeTuple9(2, 4, 6, 8, 10, 12, 14, 16, 18), result)
+}
+
+func TestMap10(t *testing.T) {
+ t10 := MakeTuple10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+ mapper := Map10(
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ )
+ result := mapper(t10)
+ assert.Equal(t, MakeTuple10(2, 4, 6, 8, 10, 12, 14, 16, 18, 20), result)
+}
+
+// Test Replicate for sizes 6-10
+func TestReplicate6(t *testing.T) {
+ result := Replicate6(11)
+ assert.Equal(t, MakeTuple6(11, 11, 11, 11, 11, 11), result)
+}
+
+func TestReplicate7(t *testing.T) {
+ result := Replicate7(13)
+ assert.Equal(t, MakeTuple7(13, 13, 13, 13, 13, 13, 13), result)
+}
+
+func TestReplicate8(t *testing.T) {
+ result := Replicate8(15)
+ assert.Equal(t, MakeTuple8(15, 15, 15, 15, 15, 15, 15, 15), result)
+}
+
+func TestReplicate9(t *testing.T) {
+ result := Replicate9(17)
+ assert.Equal(t, MakeTuple9(17, 17, 17, 17, 17, 17, 17, 17, 17), result)
+}
+
+func TestReplicate10(t *testing.T) {
+ result := Replicate10(19)
+ assert.Equal(t, MakeTuple10(19, 19, 19, 19, 19, 19, 19, 19, 19, 19), result)
+}
+
+// Test ToArray/FromArray for sizes 6-10
+func TestToArray6FromArray6(t *testing.T) {
+ t6 := MakeTuple6(1, 2, 3, 4, 5, 6)
+ toArray := ToArray6(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ arr := toArray(t6)
+ assert.Equal(t, []int{1, 2, 3, 4, 5, 6}, arr)
+
+ fromArray := FromArray6(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ result := fromArray(arr)
+ assert.Equal(t, t6, result)
+}
+
+func TestToArray7FromArray7(t *testing.T) {
+ t7 := MakeTuple7(1, 2, 3, 4, 5, 6, 7)
+ toArray := ToArray7(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ arr := toArray(t7)
+ assert.Equal(t, []int{1, 2, 3, 4, 5, 6, 7}, arr)
+
+ fromArray := FromArray7(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ result := fromArray(arr)
+ assert.Equal(t, t7, result)
+}
+
+func TestToArray8FromArray8(t *testing.T) {
+ t8 := MakeTuple8(1, 2, 3, 4, 5, 6, 7, 8)
+ toArray := ToArray8(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ arr := toArray(t8)
+ assert.Equal(t, []int{1, 2, 3, 4, 5, 6, 7, 8}, arr)
+
+ fromArray := FromArray8(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ result := fromArray(arr)
+ assert.Equal(t, t8, result)
+}
+
+func TestToArray9FromArray9(t *testing.T) {
+ t9 := MakeTuple9(1, 2, 3, 4, 5, 6, 7, 8, 9)
+ toArray := ToArray9(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ arr := toArray(t9)
+ assert.Equal(t, []int{1, 2, 3, 4, 5, 6, 7, 8, 9}, arr)
+
+ fromArray := FromArray9(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ result := fromArray(arr)
+ assert.Equal(t, t9, result)
+}
+
+func TestToArray10FromArray10(t *testing.T) {
+ t10 := MakeTuple10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+ toArray := ToArray10(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ arr := toArray(t10)
+ assert.Equal(t, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, arr)
+
+ fromArray := FromArray10(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ result := fromArray(arr)
+ assert.Equal(t, t10, result)
+}
+
+// Test Push for sizes 6-10
+func TestPush6(t *testing.T) {
+ t6 := MakeTuple6(1, 2, 3, 4, 5, 6)
+ push := Push6[int, int, int, int, int, int, int](7)
+ result := push(t6)
+ assert.Equal(t, MakeTuple7(1, 2, 3, 4, 5, 6, 7), result)
+}
+
+func TestPush7(t *testing.T) {
+ t7 := MakeTuple7(1, 2, 3, 4, 5, 6, 7)
+ push := Push7[int, int, int, int, int, int, int, int](8)
+ result := push(t7)
+ assert.Equal(t, MakeTuple8(1, 2, 3, 4, 5, 6, 7, 8), result)
+}
+
+func TestPush8(t *testing.T) {
+ t8 := MakeTuple8(1, 2, 3, 4, 5, 6, 7, 8)
+ push := Push8[int, int, int, int, int, int, int, int, int](9)
+ result := push(t8)
+ assert.Equal(t, MakeTuple9(1, 2, 3, 4, 5, 6, 7, 8, 9), result)
+}
+
+func TestPush9(t *testing.T) {
+ t9 := MakeTuple9(1, 2, 3, 4, 5, 6, 7, 8, 9)
+ push := Push9[int, int, int, int, int, int, int, int, int, int](10)
+ result := push(t9)
+ assert.Equal(t, MakeTuple10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), result)
+}
+
+// Test String methods for sizes 5-10
+func TestTuple5String(t *testing.T) {
+ t5 := MakeTuple5(1, 2, 3, 4, 5)
+ assert.Equal(t, "Tuple5[int, int, int, int, int](1, 2, 3, 4, 5)", t5.String())
+}
+
+func TestTuple6String(t *testing.T) {
+ t6 := MakeTuple6(1, 2, 3, 4, 5, 6)
+ assert.Equal(t, "Tuple6[int, int, int, int, int, int](1, 2, 3, 4, 5, 6)", t6.String())
+}
+
+func TestTuple7String(t *testing.T) {
+ t7 := MakeTuple7(1, 2, 3, 4, 5, 6, 7)
+ assert.Equal(t, "Tuple7[int, int, int, int, int, int, int](1, 2, 3, 4, 5, 6, 7)", t7.String())
+}
+
+func TestTuple8String(t *testing.T) {
+ t8 := MakeTuple8(1, 2, 3, 4, 5, 6, 7, 8)
+ assert.Equal(t, "Tuple8[int, int, int, int, int, int, int, int](1, 2, 3, 4, 5, 6, 7, 8)", t8.String())
+}
+
+func TestTuple9String(t *testing.T) {
+ t9 := MakeTuple9(1, 2, 3, 4, 5, 6, 7, 8, 9)
+ assert.Equal(t, "Tuple9[int, int, int, int, int, int, int, int, int](1, 2, 3, 4, 5, 6, 7, 8, 9)", t9.String())
+}
+
+func TestTuple10String(t *testing.T) {
+ t10 := MakeTuple10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+ assert.Equal(t, "Tuple10[int, int, int, int, int, int, int, int, int, int](1, 2, 3, 4, 5, 6, 7, 8, 9, 10)", t10.String())
+}
+
+// Test JSON for sizes 6-10
+func TestTuple6JSON(t *testing.T) {
+ t6 := MakeTuple6(1, 2, 3, 4, 5, 6)
+ data, err := json.Marshal(t6)
+ require.NoError(t, err)
+
+ var unmarshaled Tuple6[int, int, int, int, int, int]
+ err = json.Unmarshal(data, &unmarshaled)
+ require.NoError(t, err)
+ assert.Equal(t, t6, unmarshaled)
+}
+
+func TestTuple7JSON(t *testing.T) {
+ t7 := MakeTuple7(1, 2, 3, 4, 5, 6, 7)
+ data, err := json.Marshal(t7)
+ require.NoError(t, err)
+
+ var unmarshaled Tuple7[int, int, int, int, int, int, int]
+ err = json.Unmarshal(data, &unmarshaled)
+ require.NoError(t, err)
+ assert.Equal(t, t7, unmarshaled)
+}
+
+func TestTuple8JSON(t *testing.T) {
+ t8 := MakeTuple8(1, 2, 3, 4, 5, 6, 7, 8)
+ data, err := json.Marshal(t8)
+ require.NoError(t, err)
+
+ var unmarshaled Tuple8[int, int, int, int, int, int, int, int]
+ err = json.Unmarshal(data, &unmarshaled)
+ require.NoError(t, err)
+ assert.Equal(t, t8, unmarshaled)
+}
+
+func TestTuple9JSON(t *testing.T) {
+ t9 := MakeTuple9(1, 2, 3, 4, 5, 6, 7, 8, 9)
+ data, err := json.Marshal(t9)
+ require.NoError(t, err)
+
+ var unmarshaled Tuple9[int, int, int, int, int, int, int, int, int]
+ err = json.Unmarshal(data, &unmarshaled)
+ require.NoError(t, err)
+ assert.Equal(t, t9, unmarshaled)
+}
+
+func TestTuple10JSON(t *testing.T) {
+ t10 := MakeTuple10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+ data, err := json.Marshal(t10)
+ require.NoError(t, err)
+
+ var unmarshaled Tuple10[int, int, int, int, int, int, int, int, int, int]
+ err = json.Unmarshal(data, &unmarshaled)
+ require.NoError(t, err)
+ assert.Equal(t, t10, unmarshaled)
+}
+
+// Test Monoid for sizes 6-10
+func TestMonoid6(t *testing.T) {
+ m := Monoid6(
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ )
+ t1 := MakeTuple6(1, 2, 3, 4, 5, 6)
+ t2 := MakeTuple6(1, 1, 1, 1, 1, 1)
+ result := m.Concat(t1, t2)
+ assert.Equal(t, MakeTuple6(2, 3, 4, 5, 6, 7), result)
+}
+
+func TestMonoid7(t *testing.T) {
+ m := Monoid7(
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ )
+ t1 := MakeTuple7(1, 2, 3, 4, 5, 6, 7)
+ t2 := MakeTuple7(1, 1, 1, 1, 1, 1, 1)
+ result := m.Concat(t1, t2)
+ assert.Equal(t, MakeTuple7(2, 3, 4, 5, 6, 7, 8), result)
+}
+
+func TestMonoid8(t *testing.T) {
+ m := Monoid8(
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ )
+ t1 := MakeTuple8(1, 2, 3, 4, 5, 6, 7, 8)
+ t2 := MakeTuple8(1, 1, 1, 1, 1, 1, 1, 1)
+ result := m.Concat(t1, t2)
+ assert.Equal(t, MakeTuple8(2, 3, 4, 5, 6, 7, 8, 9), result)
+}
+
+func TestMonoid9(t *testing.T) {
+ m := Monoid9(
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ )
+ t1 := MakeTuple9(1, 2, 3, 4, 5, 6, 7, 8, 9)
+ t2 := MakeTuple9(1, 1, 1, 1, 1, 1, 1, 1, 1)
+ result := m.Concat(t1, t2)
+ assert.Equal(t, MakeTuple9(2, 3, 4, 5, 6, 7, 8, 9, 10), result)
+}
+
+func TestMonoid10(t *testing.T) {
+ m := Monoid10(
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ )
+ t1 := MakeTuple10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+ t2 := MakeTuple10(1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
+ result := m.Concat(t1, t2)
+ assert.Equal(t, MakeTuple10(2, 3, 4, 5, 6, 7, 8, 9, 10, 11), result)
+}
+
+// Test Ord for sizes 6-10
+func TestOrd6(t *testing.T) {
+ o := Ord6(
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ )
+ t1 := MakeTuple6(1, 2, 3, 4, 5, 6)
+ t2 := MakeTuple6(1, 2, 3, 4, 5, 7)
+ t3 := MakeTuple6(1, 2, 3, 4, 5, 6)
+
+ assert.Equal(t, -1, o.Compare(t1, t2))
+ assert.Equal(t, 0, o.Compare(t1, t3))
+ assert.True(t, o.Equals(t1, t3))
+}
+
+func TestOrd7(t *testing.T) {
+ o := Ord7(
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ )
+ t1 := MakeTuple7(1, 2, 3, 4, 5, 6, 7)
+ t2 := MakeTuple7(1, 2, 3, 4, 5, 6, 8)
+ t3 := MakeTuple7(1, 2, 3, 4, 5, 6, 7)
+
+ assert.Equal(t, -1, o.Compare(t1, t2))
+ assert.Equal(t, 0, o.Compare(t1, t3))
+ assert.True(t, o.Equals(t1, t3))
+}
+
+func TestOrd8(t *testing.T) {
+ o := Ord8(
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ )
+ t1 := MakeTuple8(1, 2, 3, 4, 5, 6, 7, 8)
+ t2 := MakeTuple8(1, 2, 3, 4, 5, 6, 7, 9)
+ t3 := MakeTuple8(1, 2, 3, 4, 5, 6, 7, 8)
+
+ assert.Equal(t, -1, o.Compare(t1, t2))
+ assert.Equal(t, 0, o.Compare(t1, t3))
+ assert.True(t, o.Equals(t1, t3))
+}
+
+func TestOrd9(t *testing.T) {
+ o := Ord9(
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ )
+ t1 := MakeTuple9(1, 2, 3, 4, 5, 6, 7, 8, 9)
+ t2 := MakeTuple9(1, 2, 3, 4, 5, 6, 7, 8, 10)
+ t3 := MakeTuple9(1, 2, 3, 4, 5, 6, 7, 8, 9)
+
+ assert.Equal(t, -1, o.Compare(t1, t2))
+ assert.Equal(t, 0, o.Compare(t1, t3))
+ assert.True(t, o.Equals(t1, t3))
+}
+
+func TestOrd10(t *testing.T) {
+ o := Ord10(
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ )
+ t1 := MakeTuple10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+ t2 := MakeTuple10(1, 2, 3, 4, 5, 6, 7, 8, 9, 11)
+ t3 := MakeTuple10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+
+ assert.Equal(t, -1, o.Compare(t1, t2))
+ assert.Equal(t, 0, o.Compare(t1, t3))
+ assert.True(t, o.Equals(t1, t3))
+}
+
+// Test tuple sizes 11-15
+func TestMakeTuple11(t *testing.T) {
+ t11 := MakeTuple11(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
+ assert.Equal(t, 1, t11.F1)
+ assert.Equal(t, 11, t11.F11)
+}
+
+func TestMakeTuple12(t *testing.T) {
+ t12 := MakeTuple12(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
+ assert.Equal(t, 1, t12.F1)
+ assert.Equal(t, 12, t12.F12)
+}
+
+func TestMakeTuple13(t *testing.T) {
+ t13 := MakeTuple13(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
+ assert.Equal(t, 1, t13.F1)
+ assert.Equal(t, 13, t13.F13)
+}
+
+func TestMakeTuple14(t *testing.T) {
+ t14 := MakeTuple14(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
+ assert.Equal(t, 1, t14.F1)
+ assert.Equal(t, 14, t14.F14)
+}
+
+func TestMakeTuple15(t *testing.T) {
+ t15 := MakeTuple15(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
+ assert.Equal(t, 1, t15.F1)
+ assert.Equal(t, 15, t15.F15)
+}
+
+// Test Tupled/Untupled for sizes 11-15
+func TestTupled11Untupled11(t *testing.T) {
+ sum11 := func(a, b, c, d, e, f, g, h, i, j, k int) int {
+ return a + b + c + d + e + f + g + h + i + j + k
+ }
+
+ tupled := Tupled11(sum11)
+ result := tupled(MakeTuple11(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11))
+ assert.Equal(t, 66, result)
+
+ untupled := Untupled11(tupled)
+ result2 := untupled(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
+ assert.Equal(t, 11, result2)
+}
+
+func TestTupled12Untupled12(t *testing.T) {
+ sum12 := func(a, b, c, d, e, f, g, h, i, j, k, l int) int {
+ return a + b + c + d + e + f + g + h + i + j + k + l
+ }
+
+ tupled := Tupled12(sum12)
+ result := tupled(MakeTuple12(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12))
+ assert.Equal(t, 78, result)
+
+ untupled := Untupled12(tupled)
+ result2 := untupled(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
+ assert.Equal(t, 12, result2)
+}
+
+func TestTupled13Untupled13(t *testing.T) {
+ sum13 := func(a, b, c, d, e, f, g, h, i, j, k, l, m int) int {
+ return a + b + c + d + e + f + g + h + i + j + k + l + m
+ }
+
+ tupled := Tupled13(sum13)
+ result := tupled(MakeTuple13(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13))
+ assert.Equal(t, 91, result)
+
+ untupled := Untupled13(tupled)
+ result2 := untupled(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
+ assert.Equal(t, 13, result2)
+}
+
+func TestTupled14Untupled14(t *testing.T) {
+ sum14 := func(a, b, c, d, e, f, g, h, i, j, k, l, m, n int) int {
+ return a + b + c + d + e + f + g + h + i + j + k + l + m + n
+ }
+
+ tupled := Tupled14(sum14)
+ result := tupled(MakeTuple14(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14))
+ assert.Equal(t, 105, result)
+
+ untupled := Untupled14(tupled)
+ result2 := untupled(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
+ assert.Equal(t, 14, result2)
+}
+
+func TestTupled15Untupled15(t *testing.T) {
+ sum15 := func(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o int) int {
+ return a + b + c + d + e + f + g + h + i + j + k + l + m + n + o
+ }
+
+ tupled := Tupled15(sum15)
+ result := tupled(MakeTuple15(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15))
+ assert.Equal(t, 120, result)
+
+ untupled := Untupled15(tupled)
+ result2 := untupled(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
+ assert.Equal(t, 15, result2)
+}
+
+// Test Map for sizes 11-15
+func TestMap11(t *testing.T) {
+ t11 := MakeTuple11(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
+ mapper := Map11(
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ )
+ result := mapper(t11)
+ assert.Equal(t, MakeTuple11(2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22), result)
+}
+
+func TestMap12(t *testing.T) {
+ t12 := MakeTuple12(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
+ mapper := Map12(
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ )
+ result := mapper(t12)
+ assert.Equal(t, MakeTuple12(2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24), result)
+}
+
+func TestMap13(t *testing.T) {
+ t13 := MakeTuple13(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
+ mapper := Map13(
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ )
+ result := mapper(t13)
+ assert.Equal(t, MakeTuple13(2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26), result)
+}
+
+func TestMap14(t *testing.T) {
+ t14 := MakeTuple14(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
+ mapper := Map14(
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ )
+ result := mapper(t14)
+ assert.Equal(t, MakeTuple14(2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28), result)
+}
+
+func TestMap15(t *testing.T) {
+ t15 := MakeTuple15(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
+ mapper := Map15(
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ func(n int) int { return n * 2 },
+ )
+ result := mapper(t15)
+ assert.Equal(t, MakeTuple15(2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30), result)
+}
+
+// Test Replicate for sizes 11-15
+func TestReplicate11(t *testing.T) {
+ result := Replicate11(21)
+ assert.Equal(t, MakeTuple11(21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21), result)
+}
+
+func TestReplicate12(t *testing.T) {
+ result := Replicate12(23)
+ assert.Equal(t, MakeTuple12(23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23), result)
+}
+
+func TestReplicate13(t *testing.T) {
+ result := Replicate13(25)
+ assert.Equal(t, MakeTuple13(25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25), result)
+}
+
+func TestReplicate14(t *testing.T) {
+ result := Replicate14(27)
+ assert.Equal(t, MakeTuple14(27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27), result)
+}
+
+func TestReplicate15(t *testing.T) {
+ result := Replicate15(29)
+ assert.Equal(t, MakeTuple15(29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29), result)
+}
+
+// Test ToArray/FromArray for sizes 11-15
+func TestToArray11FromArray11(t *testing.T) {
+ t11 := MakeTuple11(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
+ toArray := ToArray11(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ arr := toArray(t11)
+ assert.Equal(t, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, arr)
+
+ fromArray := FromArray11(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ result := fromArray(arr)
+ assert.Equal(t, t11, result)
+}
+
+func TestToArray12FromArray12(t *testing.T) {
+ t12 := MakeTuple12(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
+ toArray := ToArray12(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ arr := toArray(t12)
+ assert.Equal(t, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}, arr)
+
+ fromArray := FromArray12(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ result := fromArray(arr)
+ assert.Equal(t, t12, result)
+}
+
+func TestToArray13FromArray13(t *testing.T) {
+ t13 := MakeTuple13(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
+ toArray := ToArray13(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ arr := toArray(t13)
+ assert.Equal(t, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}, arr)
+
+ fromArray := FromArray13(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ result := fromArray(arr)
+ assert.Equal(t, t13, result)
+}
+
+func TestToArray14FromArray14(t *testing.T) {
+ t14 := MakeTuple14(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
+ toArray := ToArray14(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ arr := toArray(t14)
+ assert.Equal(t, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}, arr)
+
+ fromArray := FromArray14(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ result := fromArray(arr)
+ assert.Equal(t, t14, result)
+}
+
+func TestToArray15FromArray15(t *testing.T) {
+ t15 := MakeTuple15(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
+ toArray := ToArray15(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ arr := toArray(t15)
+ assert.Equal(t, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, arr)
+
+ fromArray := FromArray15(
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ func(n int) int { return n },
+ )
+ result := fromArray(arr)
+ assert.Equal(t, t15, result)
+}
+
+// Test Push for sizes 10-14
+func TestPush10(t *testing.T) {
+ t10 := MakeTuple10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+ push := Push10[int, int, int, int, int, int, int, int, int, int, int](11)
+ result := push(t10)
+ assert.Equal(t, MakeTuple11(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11), result)
+}
+
+func TestPush11(t *testing.T) {
+ t11 := MakeTuple11(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
+ push := Push11[int, int, int, int, int, int, int, int, int, int, int, int](12)
+ result := push(t11)
+ assert.Equal(t, MakeTuple12(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), result)
+}
+
+func TestPush12(t *testing.T) {
+ t12 := MakeTuple12(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
+ push := Push12[int, int, int, int, int, int, int, int, int, int, int, int, int](13)
+ result := push(t12)
+ assert.Equal(t, MakeTuple13(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13), result)
+}
+
+func TestPush13(t *testing.T) {
+ t13 := MakeTuple13(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
+ push := Push13[int, int, int, int, int, int, int, int, int, int, int, int, int, int](14)
+ result := push(t13)
+ assert.Equal(t, MakeTuple14(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14), result)
+}
+
+func TestPush14(t *testing.T) {
+ t14 := MakeTuple14(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
+ push := Push14[int, int, int, int, int, int, int, int, int, int, int, int, int, int, int](15)
+ result := push(t14)
+ assert.Equal(t, MakeTuple15(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15), result)
+}
+
+// Test String methods for sizes 11-15
+func TestTuple11String(t *testing.T) {
+ t11 := MakeTuple11(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
+ assert.Equal(t, "Tuple11[int, int, int, int, int, int, int, int, int, int, int](1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)", t11.String())
+}
+
+func TestTuple12String(t *testing.T) {
+ t12 := MakeTuple12(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
+ assert.Equal(t, "Tuple12[int, int, int, int, int, int, int, int, int, int, int, int](1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)", t12.String())
+}
+
+func TestTuple13String(t *testing.T) {
+ t13 := MakeTuple13(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
+ assert.Equal(t, "Tuple13[int, int, int, int, int, int, int, int, int, int, int, int, int](1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)", t13.String())
+}
+
+func TestTuple14String(t *testing.T) {
+ t14 := MakeTuple14(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
+ assert.Equal(t, "Tuple14[int, int, int, int, int, int, int, int, int, int, int, int, int, int](1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)", t14.String())
+}
+
+func TestTuple15String(t *testing.T) {
+ t15 := MakeTuple15(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
+ assert.Equal(t, "Tuple15[int, int, int, int, int, int, int, int, int, int, int, int, int, int, int](1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)", t15.String())
+}
+
+// Test JSON for sizes 11-15
+func TestTuple11JSON(t *testing.T) {
+ t11 := MakeTuple11(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
+ data, err := json.Marshal(t11)
+ require.NoError(t, err)
+
+ var unmarshaled Tuple11[int, int, int, int, int, int, int, int, int, int, int]
+ err = json.Unmarshal(data, &unmarshaled)
+ require.NoError(t, err)
+ assert.Equal(t, t11, unmarshaled)
+}
+
+func TestTuple12JSON(t *testing.T) {
+ t12 := MakeTuple12(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
+ data, err := json.Marshal(t12)
+ require.NoError(t, err)
+
+ var unmarshaled Tuple12[int, int, int, int, int, int, int, int, int, int, int, int]
+ err = json.Unmarshal(data, &unmarshaled)
+ require.NoError(t, err)
+ assert.Equal(t, t12, unmarshaled)
+}
+
+func TestTuple13JSON(t *testing.T) {
+ t13 := MakeTuple13(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
+ data, err := json.Marshal(t13)
+ require.NoError(t, err)
+
+ var unmarshaled Tuple13[int, int, int, int, int, int, int, int, int, int, int, int, int]
+ err = json.Unmarshal(data, &unmarshaled)
+ require.NoError(t, err)
+ assert.Equal(t, t13, unmarshaled)
+}
+
+func TestTuple14JSON(t *testing.T) {
+ t14 := MakeTuple14(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
+ data, err := json.Marshal(t14)
+ require.NoError(t, err)
+
+ var unmarshaled Tuple14[int, int, int, int, int, int, int, int, int, int, int, int, int, int]
+ err = json.Unmarshal(data, &unmarshaled)
+ require.NoError(t, err)
+ assert.Equal(t, t14, unmarshaled)
+}
+
+func TestTuple15JSON(t *testing.T) {
+ t15 := MakeTuple15(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
+ data, err := json.Marshal(t15)
+ require.NoError(t, err)
+
+ var unmarshaled Tuple15[int, int, int, int, int, int, int, int, int, int, int, int, int, int, int]
+ err = json.Unmarshal(data, &unmarshaled)
+ require.NoError(t, err)
+ assert.Equal(t, t15, unmarshaled)
+}
+
+// Test Monoid for sizes 11-15
+func TestMonoid11(t *testing.T) {
+ m := Monoid11(
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ )
+ t1 := MakeTuple11(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
+ t2 := MakeTuple11(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
+ result := m.Concat(t1, t2)
+ assert.Equal(t, MakeTuple11(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), result)
+}
+
+func TestMonoid12(t *testing.T) {
+ m := Monoid12(
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ )
+ t1 := MakeTuple12(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
+ t2 := MakeTuple12(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
+ result := m.Concat(t1, t2)
+ assert.Equal(t, MakeTuple12(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13), result)
+}
+
+func TestMonoid13(t *testing.T) {
+ m := Monoid13(
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ )
+ t1 := MakeTuple13(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
+ t2 := MakeTuple13(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
+ result := m.Concat(t1, t2)
+ assert.Equal(t, MakeTuple13(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14), result)
+}
+
+func TestMonoid14(t *testing.T) {
+ m := Monoid14(
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ )
+ t1 := MakeTuple14(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
+ t2 := MakeTuple14(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
+ result := m.Concat(t1, t2)
+ assert.Equal(t, MakeTuple14(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15), result)
+}
+
+func TestMonoid15(t *testing.T) {
+ m := Monoid15(
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ number.MonoidSum[int](),
+ )
+ t1 := MakeTuple15(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
+ t2 := MakeTuple15(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
+ result := m.Concat(t1, t2)
+ assert.Equal(t, MakeTuple15(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), result)
+}
+
+// Test Ord for sizes 11-15
+func TestOrd11(t *testing.T) {
+ o := Ord11(
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ )
+ t1 := MakeTuple11(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
+ t2 := MakeTuple11(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12)
+ t3 := MakeTuple11(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
+
+ assert.Equal(t, -1, o.Compare(t1, t2))
+ assert.Equal(t, 0, o.Compare(t1, t3))
+ assert.True(t, o.Equals(t1, t3))
+}
+
+func TestOrd12(t *testing.T) {
+ o := Ord12(
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ )
+ t1 := MakeTuple12(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
+ t2 := MakeTuple12(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13)
+ t3 := MakeTuple12(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
+
+ assert.Equal(t, -1, o.Compare(t1, t2))
+ assert.Equal(t, 0, o.Compare(t1, t3))
+ assert.True(t, o.Equals(t1, t3))
+}
+
+func TestOrd13(t *testing.T) {
+ o := Ord13(
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ )
+ t1 := MakeTuple13(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
+ t2 := MakeTuple13(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14)
+ t3 := MakeTuple13(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
+
+ assert.Equal(t, -1, o.Compare(t1, t2))
+ assert.Equal(t, 0, o.Compare(t1, t3))
+ assert.True(t, o.Equals(t1, t3))
+}
+
+func TestOrd14(t *testing.T) {
+ o := Ord14(
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ )
+ t1 := MakeTuple14(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
+ t2 := MakeTuple14(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15)
+ t3 := MakeTuple14(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
+
+ assert.Equal(t, -1, o.Compare(t1, t2))
+ assert.Equal(t, 0, o.Compare(t1, t3))
+ assert.True(t, o.Equals(t1, t3))
+}
+
+func TestOrd15(t *testing.T) {
+ o := Ord15(
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ O.FromStrictCompare[int](),
+ )
+ t1 := MakeTuple15(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
+ t2 := MakeTuple15(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16)
+ t3 := MakeTuple15(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
+
+ assert.Equal(t, -1, o.Compare(t1, t2))
+ assert.Equal(t, 0, o.Compare(t1, t3))
+ assert.True(t, o.Equals(t1, t3))
+}