fix: better performance for either

Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>
fix: run benchmarks
2025-12-07 23:03:15 +02:00 · 2025-11-08 10:01:14 +01:00 · 2025-11-08 09:31:48 +01:00 · 2025-11-07 17:53:47 +01:00 · 2025-11-07 17:42:54 +01:00 · 2025-11-07 17:31:27 +01:00
854 changed files with 121290 additions and 244 deletions
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -4,9 +4,7 @@ on:
  push:
    branches:
      - main
-
  pull_request:
-
  workflow_dispatch:
    inputs:
      dryRun:
@@ -15,35 +13,109 @@ on:
        required: false

 env:
-  # Currently no way to detect automatically
  DEFAULT_BRANCH: main
-  GO_VERSION: 1.21.6 # renovate: datasource=golang-version depName=golang
-  NODE_VERSION: 20
+  LATEST_GO_VERSION: 1.25.2 # renovate: datasource=golang-version depName=golang
+  NODE_VERSION: 24
  DRY_RUN: true

 jobs:
-  build:
+  build-v1:
+    name: Build v1 (Go ${{ matrix.go-version }})
    runs-on: ubuntu-latest
    strategy:
      matrix:
-        go-version: [ '1.20.x', '1.21.x', '1.22.x']
+        go-version: ['1.20.x', '1.21.x', '1.22.x', '1.23.x', '1.24.x', '1.25.x']
+      fail-fast: false  # Continue with other versions if one fails
    steps:
      # full checkout for semantic-release
-      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
        with:
          fetch-depth: 0
-      - name: Set up go ${{ matrix.go-version }}
+      - name: Set up Go ${{ matrix.go-version }}
        uses: actions/setup-go@v5
        with:
          go-version: ${{ matrix.go-version }}
-      -
-        name: Tests
+          cache: true  # Enable Go module caching
+      - name: Run tests
        run: |
          go mod tidy
-          go test -v ./...
+          go test -v -race -coverprofile=coverage.txt -covermode=atomic ./...
+      
+      - name: Upload coverage to Coveralls
+        uses: coverallsapp/github-action@v2
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          file: ./coverage.txt
+          flag-name: v1-go-${{ matrix.go-version }}
+          parallel: true
+      
+      # - name: Upload coverage to Codecov
+      #   uses: codecov/codecov-action@v5
+      #   with:
+      #     file: ./coverage.txt
+      #     flags: v1,go-${{ matrix.go-version }}
+      #     name: v1-go-${{ matrix.go-version }}
+      #     fail_ci_if_error: false
+      #   env:
+      #     CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  build-v2:
+    name: Build v2 (Go ${{ matrix.go-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go-version: ['1.24.x', '1.25.x']
+    steps:
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+        with:
+          fetch-depth: 0
+      - name: Set up Go ${{ matrix.go-version }}
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ matrix.go-version }}
+          cache: true  # Enable Go module caching
+      - name: Run tests
+        run: |
+          cd v2
+          go mod tidy
+          go test -v -race -coverprofile=coverage.txt -covermode=atomic ./...
+      
+      - name: Upload coverage to Coveralls
+        uses: coverallsapp/github-action@v2
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          file: ./v2/coverage.txt
+          flag-name: v2-go-${{ matrix.go-version }}
+          parallel: true
+      
+      # - name: Upload coverage to Codecov
+      #   uses: codecov/codecov-action@v5
+      #   with:
+      #     file: ./v2/coverage.txt
+      #     flags: v2,go-${{ matrix.go-version }}
+      #     name: v2-go-${{ matrix.go-version }}
+      #     fail_ci_if_error: false
+      #   env:
+      #     CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  coveralls-finish:
+    name: Finish Coveralls
+    needs:
+      - build-v1
+      - build-v2
+    runs-on: ubuntu-latest
+    steps:
+      - name: Coveralls Finished
+        uses: coverallsapp/github-action@v2
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          parallel-finished: true

  release:
-    needs: [build]
+    name: Release
+    needs:
+      - build-v1
+      - build-v2
    if: github.repository == 'IBM/fp-go' && github.event_name != 'pull_request'
    runs-on: ubuntu-latest
    timeout-minutes: 15
@@ -51,38 +123,37 @@ jobs:
      contents: write
      issues: write
      pull-requests: write
-
    steps:
      # full checkout for semantic-release
      - name: Full checkout
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
        with:
          fetch-depth: 0

      - name: Set up Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@60edb5dd545a775178f52524783378180af0d1f8 # v4.0.2
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
        with:
          node-version: ${{ env.NODE_VERSION }}

-      - name: Set up go ${{env.GO_VERSION}}
+      - name: Set up Go
        uses: actions/setup-go@v5
        with:
-          go-version: ${{env.GO_VERSION}}
+          go-version: ${{ env.LATEST_GO_VERSION }}
+          cache: true  # Enable Go module caching

-      # The dry-run evaluation is only made for non PR events. Manual trigger w/dryRun true, main branch and any tagged branches will set DRY run to false
-      - name: Check dry run
+      - name: Determine release mode
+        id: release-mode
        run: |
-          if [[ "${{github.event_name}}" == "workflow_dispatch" && "${{ github.event.inputs.dryRun }}" != "true"  ]]; then
-              echo "DRY_RUN=false" >> $GITHUB_ENV
-          elif [[ "${{github.ref}}" == "refs/heads/${{env.DEFAULT_BRANCH}}" ]]; then
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" && "${{ github.event.inputs.dryRun }}" != "true" ]]; then
            echo "DRY_RUN=false" >> $GITHUB_ENV
-          elif [[ "${{github.ref}}" =~ ^refs/heads/v[0-9]+(\.[0-9]+)?$ ]]; then
+          elif [[ "${{ github.ref }}" == "refs/heads/${{ env.DEFAULT_BRANCH }}" ]]; then
+            echo "DRY_RUN=false" >> $GITHUB_ENV
+          elif [[ "${{ github.ref }}" =~ ^refs/heads/v[0-9]+(\.[0-9]+)?$ ]]; then
            echo "DRY_RUN=false" >> $GITHUB_ENV
          fi

-      - name: Semantic Release
+      - name: Run semantic release
        run: |
-          npx -p conventional-changelog-conventionalcommits -p semantic-release semantic-release --dry-run ${{env.DRY_RUN}}
+          npx -p conventional-changelog-conventionalcommits -p semantic-release semantic-release --dry-run ${{ env.DRY_RUN }}
        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-  
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,6 @@
 fp-go.exe
+fp-go
 main.exe
 build/
-.idea
+.idea
+*.exe
--- a/.whitesource
+++ b/.whitesource
@@ -0,0 +1,3 @@
+{
+  "settingsInheritedFrom": "ibm-mend-config/mend-config@main"
+}
--- a/README.md
+++ b/README.md
@@ -1,207 +1,312 @@
-# Functional programming library for golang
+# fp-go: Functional Programming Library for Go

-**🚧 Work in progress! 🚧** Despite major version 1 because of <https://github.com/semantic-release/semantic-release/issues/1507>. Trying to not make breaking changes, but devil is in the details.
+[![Go Reference](https://pkg.go.dev/badge/github.com/IBM/fp-go.svg)](https://pkg.go.dev/github.com/IBM/fp-go)
+[![Coverage Status](https://coveralls.io/repos/github/IBM/fp-go/badge.svg?branch=main)](https://coveralls.io/github/IBM/fp-go?branch=main)
+
+**🚧 Work in progress! 🚧** Despite major version 1 (due to [semantic-release limitations](https://github.com/semantic-release/semantic-release/issues/1507)), we're working to minimize breaking changes.

 ![logo](resources/images/logo.png)

-This library is strongly influenced by the awesome [fp-ts](https://github.com/gcanti/fp-ts).
+A comprehensive functional programming library for Go, strongly influenced by the excellent [fp-ts](https://github.com/gcanti/fp-ts) library for TypeScript.

-## Getting started
+## 📚 Table of Contents
+
+- [Getting Started](#-getting-started)
+- [Design Goals](#-design-goals)
+- [Core Concepts](#-core-concepts)
+- [Comparison to Idiomatic Go](#comparison-to-idiomatic-go)
+- [Implementation Notes](#implementation-notes)
+- [Common Operations](#common-operations)
+- [Resources](#-resources)
+
+## 🚀 Getting Started
+
+### Installation

 ```bash
 go get github.com/IBM/fp-go
 ```

-Refer to the [samples](./samples/).
+### Quick Example

-Find API documentation [here](https://pkg.go.dev/github.com/IBM/fp-go)
+```go
+import (
+    "errors"
+    "github.com/IBM/fp-go/either"
+    "github.com/IBM/fp-go/function"
+)

-## Design Goal
+// Pure function that can fail
+func divide(a, b int) either.Either[error, int] {
+    if b == 0 {
+        return either.Left[int](errors.New("division by zero"))
+    }
+    return either.Right[error](a / b)
+}

-This library aims to provide a set of data types and functions that make it easy and fun to write maintainable and testable code in golang. It encourages the following patterns:
+// Compose operations safely
+result := function.Pipe2(
+    divide(10, 2),
+    either.Map(func(x int) int { return x * 2 }),
+    either.GetOrElse(func() int { return 0 }),
+)
+// result = 10
+```

- write many small, testable and pure functions, i.e. functions that produce output only depending on their input and that do not execute side effects
- offer helpers to isolate side effects into lazily executed functions (IO)
- expose a consistent set of composition to create new functions from existing ones
-  - for each data type there exists a small set of composition functions
-  - these functions are called the same across all data types, so you only have to learn a small number of function names
-  - the semantic of functions of the same name is consistent across all data types
+### Resources

-### How does this play with the [🧘🏽 Zen Of Go](https://the-zen-of-go.netlify.app/)?
+- 📖 [API Documentation](https://pkg.go.dev/github.com/IBM/fp-go)
+- 💡 [Code Samples](./samples/)
+- 🆕 [V2 Documentation](./v2/README.md) (requires Go 1.24+)

-#### 🧘🏽 Each package fulfils a single purpose
+## 🎯 Design Goals

-✔️ Each of the top level packages (e.g. Option, Either, ReaderIOEither, ...) fulfils the purpose of defining the respective data type and implementing the set of common operations for this data type.
+This library aims to provide a set of data types and functions that make it easy and fun to write maintainable and testable code in Go. It encourages the following patterns:

-#### 🧘🏽 Handle errors explicitly
+### Core Principles

-✔️ The library makes a clear distinction between that operations that cannot fail by design and operations that can fail. Failure is represented via the `Either` type and errors are handled explicitly by using `Either`'s monadic set of operations.
+- **Pure Functions**: Write many small, testable, and pure functions that produce output only depending on their input and execute no side effects
+- **Side Effect Isolation**: Isolate side effects into lazily executed functions using the `IO` monad
+- **Consistent Composition**: Expose a consistent set of composition functions across all data types
+  - Each data type has a small set of composition functions
+  - Functions are named consistently across all data types
+  - Semantics of same-named functions are consistent across data types

-#### 🧘🏽 Return early rather than nesting deeply
+### 🧘🏽 Alignment with the Zen of Go

-✔️ We recommend to implement simple, small functions that implement one feature and that would typically not invoke other functions. Interaction with other functions is done by function composition and the composition makes sure to run one function after the other. In the error case the `Either` monad makes sure to skip the error path.
+This library respects and aligns with [The Zen of Go](https://the-zen-of-go.netlify.app/):

-#### 🧘🏽 Leave concurrency to the caller
+| Principle | Alignment | Explanation |
+|-----------|-----------|-------------|
+| 🧘🏽 Each package fulfills a single purpose | ✔️ | Each top-level package (Option, Either, ReaderIOEither, etc.) defines one data type and its operations |
+| 🧘🏽 Handle errors explicitly | ✔️ | Clear distinction between operations that can/cannot fail; failures represented via `Either` type |
+| 🧘🏽 Return early rather than nesting deeply | ✔️ | Small, focused functions composed together; `Either` monad handles error paths automatically |
+| 🧘🏽 Leave concurrency to the caller | ✔️ | Pure functions are synchronous; I/O operations are asynchronous by default |
+| 🧘🏽 Before you launch a goroutine, know when it will stop | 🤷🏽 | Library doesn't start goroutines; Task monad supports cancellation via context |
+| 🧘🏽 Avoid package level state | ✔️ | No package-level state anywhere |
+| 🧘🏽 Simplicity matters | ✔️ | Small, consistent interface across data types; focus on business logic |
+| 🧘🏽 Write tests to lock in behaviour | 🟡 | Programming pattern encourages testing; library has growing test coverage |
+| 🧘🏽 If you think it's slow, first prove it with a benchmark | ✔️ | Performance claims should be backed by benchmarks |
+| 🧘🏽 Moderation is a virtue | ✔️ | No custom goroutines or expensive synchronization; atomic counters for coordination |
+| 🧘🏽 Maintainability counts | ✔️ | Small, concise operations; pure functions with clear type signatures |

-✔️ All pure are synchronous by default. The I/O operations are asynchronous per default.
+## 💡 Core Concepts

-#### 🧘🏽 Before you launch a goroutine, know when it will stop
+### Data Types

-🤷🏽 This is left to the user of the library since the library itself will not start goroutines on its own. The Task monad offers support for cancellation via the golang context, though.
+The library provides several key functional data types:

-#### 🧘🏽 Avoid package level state
+- **`Option[A]`**: Represents an optional value (Some or None)
+- **`Either[E, A]`**: Represents a value that can be one of two types (Left for errors, Right for success)
+- **`IO[A]`**: Represents a lazy computation that produces a value
+- **`IOEither[E, A]`**: Represents a lazy computation that can fail
+- **`Reader[R, A]`**: Represents a computation that depends on an environment
+- **`ReaderIOEither[R, E, A]`**: Combines Reader, IO, and Either for effectful computations with dependencies
+- **`Task[A]`**: Represents an asynchronous computation
+- **`State[S, A]`**: Represents a stateful computation

-✔️ No package level state anywhere, this would be a significant anti-pattern
+### Monadic Operations

-#### 🧘🏽 Simplicity matters
+All data types support common monadic operations:

-✔️ The library is simple in the sense that it offers a small, consistent interface to a variety of data types. Users can concentrate on implementing business logic rather than dealing with low level data structures.
-
-#### 🧘🏽 Write tests to lock in the behaviour of your package’s API
-
-🟡 The programming pattern suggested by this library encourages writing test cases. The library itself also has a growing number of tests, but not enough, yet. TBD
-
-#### 🧘🏽 If you think it’s slow, first prove it with a benchmark
-
-✔️ Absolutely. If you think the function composition offered by this library is too slow, please provide a benchmark.
-
-#### 🧘🏽 Moderation is a virtue
-
-✔️ The library does not implement its own goroutines and also does not require any expensive synchronization primitives. Coordination of IO operations is implemented via atomic counters without additional primitives.
-
-#### 🧘🏽 Maintainability counts
-
-✔️ Code that consumes this library is easy to maintain because of the small and concise set of operations exposed. Also the suggested programming paradigm to decompose an application into small functions increases maintainability, because these functions are easy to understand and if they are pure, it's often sufficient to look at the type signature to understand the purpose.
-
-The library itself also comprises many small functions, but it's admittedly harder to maintain than code that uses it. However this asymmetry is intended because it offloads complexity from users into a central component.
+- **`Map`**: Transform the value inside a context
+- **`Chain`** (FlatMap): Transform and flatten nested contexts
+- **`Ap`**: Apply a function in a context to a value in a context
+- **`Of`**: Wrap a value in a context
+- **`Fold`**: Extract a value from a context

 ## Comparison to Idiomatic Go

-In this section we discuss how the functional APIs differ from idiomatic go function signatures and how to convert back and forth.
+This section explains how functional APIs differ from idiomatic Go and how to convert between them.

-### Pure functions
+### Pure Functions

-Pure functions are functions that take input parameters and that compute an output without changing any global state and without mutating the input parameters. They will always return the same output for the same input.
+Pure functions take input parameters and compute output without changing global state or mutating inputs. They always return the same output for the same input.

 #### Without Errors

-If your pure function does not return an error, the idiomatic signature is just fine and no changes are required.
+If your pure function doesn't return an error, the idiomatic signature works as-is:
+
+```go
+func add(a, b int) int {
+    return a + b
+}
+```

 #### With Errors

-If your pure function can return an error, then it will have a `(T, error)` return value in idiomatic go. In functional style the return value is [Either[error, T]](https://pkg.go.dev/github.com/IBM/fp-go/either) because function composition is easier with such a return type. Use the `EitherizeXXX` methods in ["github.com/IBM/fp-go/either"](https://pkg.go.dev/github.com/IBM/fp-go/either) to convert from idiomatic to functional style and `UneitherizeXXX` to convert from functional to idiomatic style.
+**Idiomatic Go:**
+```go
+func divide(a, b int) (int, error) {
+    if b == 0 {
+        return 0, errors.New("division by zero")
+    }
+    return a / b, nil
+}
+```

-### Effectful functions
+**Functional Style:**
+```go
+func divide(a, b int) either.Either[error, int] {
+    if b == 0 {
+        return either.Left[int](errors.New("division by zero"))
+    }
+    return either.Right[error](a / b)
+}
+```

-An effectful function (or function with a side effect) is one that changes data outside the scope of the function or that does not always produce the same output for the same input (because it depends on some external, mutable state). There is no special way in idiomatic go to identify such a function other than documentation. In functional style we represent them as functions that do not take an input but that produce an output. The base type for these functions is [IO[T]](https://pkg.go.dev/github.com/IBM/fp-go/io) because in many cases such functions represent `I/O` operations.
+**Conversion:**
+- Use `either.EitherizeXXX` to convert from idiomatic to functional style
+- Use `either.UneitherizeXXX` to convert from functional to idiomatic style
+
+### Effectful Functions
+
+An effectful function changes data outside its scope or doesn't always produce the same output for the same input.

 #### Without Errors

-If your effectful function does not return an error, the functional signature is [IO[T]](https://pkg.go.dev/github.com/IBM/fp-go/io)
+**Functional signature:** `IO[T]`
+
+```go
+func getCurrentTime() io.IO[time.Time] {
+    return func() time.Time {
+        return time.Now()
+    }
+}
+```

 #### With Errors

-If your effectful function can return an error, the functional signature is [IOEither[error, T]](https://pkg.go.dev/github.com/IBM/fp-go/ioeither). Use `EitherizeXXX` from ["github.com/IBM/fp-go/ioeither"](https://pkg.go.dev/github.com/IBM/fp-go/ioeither) to convert an idiomatic go function to functional style.
+**Functional signature:** `IOEither[error, T]`
+
+```go
+func readFile(path string) ioeither.IOEither[error, []byte] {
+    return func() either.Either[error, []byte] {
+        data, err := os.ReadFile(path)
+        if err != nil {
+            return either.Left[[]byte](err)
+        }
+        return either.Right[error](data)
+    }
+}
+```
+
+**Conversion:**
+- Use `ioeither.EitherizeXXX` to convert idiomatic Go functions to functional style

 ### Go Context

-Functions that take a [context](https://pkg.go.dev/context) are per definition effectful because they depend on the context parameter that is designed to be mutable (it can e.g. be used to cancel a running operation). Furthermore in idiomatic go the parameter is typically passed as the first parameter to a function.
+Functions that take a `context.Context` are effectful because they depend on mutable context.

-In functional style we isolate the [context](https://pkg.go.dev/context) and represent the nature of the effectful function as an [IOEither[error, T]](https://pkg.go.dev/github.com/IBM/fp-go/ioeither). The resulting type is [ReaderIOEither[T]](https://pkg.go.dev/github.com/IBM/fp-go/context/readerioeither), a function taking a [context](https://pkg.go.dev/context) that returns a function without parameters returning an [Either[error, T]](https://pkg.go.dev/github.com/IBM/fp-go/either). Use the `EitherizeXXX` methods from ["github.com/IBM/fp-go/context/readerioeither"](https://pkg.go.dev/github.com/IBM/fp-go/context/readerioeither) to convert an idiomatic go function with a [context](https://pkg.go.dev/context) to functional style.
+**Idiomatic Go:**
+```go
+func fetchData(ctx context.Context, url string) ([]byte, error) {
+    // implementation
+}
+```
+
+**Functional Style:**
+```go
+func fetchData(url string) readerioeither.ReaderIOEither[context.Context, error, []byte] {
+    return func(ctx context.Context) ioeither.IOEither[error, []byte] {
+        return func() either.Either[error, []byte] {
+            // implementation
+        }
+    }
+}
+```
+
+**Conversion:**
+- Use `readerioeither.EitherizeXXX` to convert idiomatic Go functions with context to functional style

 ## Implementation Notes

 ### Generics

-All monadic operations are implemented via generics, i.e. they offer a type safe way to compose operations. This allows for convenient IDE support and also gives confidence about the correctness of the composition at compile time.
+All monadic operations use Go generics for type safety:

-Downside is that this will result in different versions of each operation per type, these versions are generated by the golang compiler at build time (unlike type erasure in languages such as Java of TypeScript). This might lead to large binaries for codebases with many different types. If this is a concern, you can always implement type erasure on top, i.e. use the monadic operations with the `any` type as if generics were not supported. You loose type safety, but this might result in smaller binaries.
+- ✅ **Pros**: Type-safe composition, IDE support, compile-time correctness
+- ⚠️ **Cons**: May result in larger binaries (different versions per type)
+- 💡 **Tip**: For binary size concerns, use type erasure with `any` type

 ### Ordering of Generic Type Parameters

-In go we need to specify all type parameters of a function on the global function definition, even if the function returns a higher order function and some of the type parameters are only applicable to the higher order function. So the following is not possible:
+Go requires all type parameters on the global function definition. Parameters that cannot be auto-detected come first:

 ```go
-func Map[A, B any](f func(A) B) [R, E any]func(fa ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B]
+// Map: B cannot be auto-detected, so it comes first
+func Map[R, E, A, B any](f func(A) B) func(ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B]
+
+// Ap: B cannot be auto-detected from the argument
+func Ap[B, R, E, A any](fa ReaderIOEither[R, E, A]) func(ReaderIOEither[R, E, func(A) B]) ReaderIOEither[R, E, B]
 ```

-Note that the parameters `R` and `E` are not needed by the first level of `Map` but only by the resulting higher order function. Instead we need to specify the following:
+This ordering maximizes type inference where possible.

-```go
-func Map[R, E, A, B any](f func(A) B) func(fa ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B]
-```
+### Use of the ~ Operator

-which overspecifies `Map` on the global scope. As a result the go compiler will not be able to auto-detect these parameters, it can only auto detect `A` and `B` since they appear in the argument of `Map`. We need to explicitly pass values for these type parameters when `Map` is being used.
-
-Because of this limitation the order of parameters on a function matters. We want to make sure that we define those parameters that cannot be auto-detected, first, and the parameters that can be auto-detected, last. This can lead to inconsistencies in parameter ordering, but we believe that the gain in convenience is worth it. The parameter order of `Ap` is e.g. different from that of `Map`:
-
-```go
-func Ap[B, R, E, A any](fa ReaderIOEither[R, E, A]) func(fab ReaderIOEither[R, E, func(A) B]) ReaderIOEither[R, E, B]
-```
-
-because `R`, `E` and `A` can be determined from the argument to `Ap` but `B` cannot.
-
-### Use of the [~ Operator](https://go.googlesource.com/proposal/+/master/design/47781-parameterized-go-ast.md)
-
-The FP library attempts to be easy to consume and one aspect of this is the definition of higher level type definitions instead of having to use their low level equivalent. It is e.g. more convenient and readable to use
-
-```go
-ReaderIOEither[R, E, A]
-```
-
-than
-
-```go
-func(R) func() Either.Either[E, A]
-```
-
-although both are logically equivalent. At the time of this writing the go type system does not support generic type aliases, only generic type definition, i.e. it is not possible to write:
-
-```go
-type ReaderIOEither[R, E, A any] = RD.Reader[R, IOE.IOEither[E, A]]
-```
-
-only
+Go doesn't support generic type aliases (until Go 1.24), only type definitions. The `~` operator allows generic implementations to work with compatible types:

 ```go
 type ReaderIOEither[R, E, A any] RD.Reader[R, IOE.IOEither[E, A]]
 ```

-This makes a big difference, because in the second case the type `ReaderIOEither[R, E, A any]` is considered a completely new type, not compatible to its right hand side, so it's not just a shortcut but a fully new type.
+**Generic Subpackages:**
+- Each higher-level type has a `generic` subpackage with fully generic implementations
+- These are for library extensions, not end-users
+- Main packages specialize generic implementations for convenience

-From the implementation perspective however there is no reason to restrict the implementation to the new type, it can be generic for all compatible types. The way to express this in go is the [~](https://go.googlesource.com/proposal/+/master/design/47781-parameterized-go-ast.md) operator. This comes with some quite complicated type declarations in some cases, which undermines the goal of the library to be easy to use.
+### Higher Kinded Types (HKT)

-For that reason there exist sub-packages called `Generic` for all higher level types. These packages contain the fully generic implementation of the operations, preferring abstraction over usability. These packages are not meant to be used by end-users but are meant to be used by library extensions. The implementation for the convenient higher level types specializes the generic implementation for the particular higher level type, i.e. this layer does not contain any business logic but only *type magic*.
+Go doesn't support HKT natively. This library addresses this by:

-### Higher Kinded Types
+- Introducing HKTs as individual types (e.g., `HKTA` for `HKT[A]`)
+- Implementing generic algorithms in the `internal` package
+- Keeping complexity hidden from end-users

-Go does not support higher kinded types (HKT). Such types occur if a generic type itself is parametrized by another generic type. Example:
+## Common Operations

-The `Map` operation for `ReaderIOEither` is defined as:
+### Map/Chain/Ap/Flap
+
+| Operator | Parameter        | Monad           | Result   | Use Case |
+| -------- | ---------------- | --------------- | -------- | -------- |
+| Map      | `func(A) B`      | `HKT[A]`        | `HKT[B]` | Transform value in context |
+| Chain    | `func(A) HKT[B]` | `HKT[A]`        | `HKT[B]` | Transform and flatten |
+| Ap       | `HKT[A]`         | `HKT[func(A)B]` | `HKT[B]` | Apply function in context |
+| Flap     | `A`              | `HKT[func(A)B]` | `HKT[B]` | Apply value to function in context |
+
+### Example: Chaining Operations

 ```go
-func Map[R, E, A, B any](f func(A) B) func(fa ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B]
+import (
+    "github.com/IBM/fp-go/either"
+    "github.com/IBM/fp-go/function"
+)
+
+result := function.Pipe3(
+    either.Right[error](10),
+    either.Map(func(x int) int { return x * 2 }),
+    either.Chain(func(x int) either.Either[error, int] {
+        if x > 15 {
+            return either.Right[error](x)
+        }
+        return either.Left[int](errors.New("too small"))
+    }),
+    either.GetOrElse(func() int { return 0 }),
+)
 ```

-and in fact the equivalent operations for all other monads follow the same pattern, we could try to introduce a new type for `ReaderIOEither` (without a parameter) as a HKT, e.g. like so (made-up syntax, does not work in go):
+## 📚 Resources

-```go
-func Map[HKT, R, E, A, B any](f func(A) B) func(HKT[R, E, A]) HKT[R, E, B]
-```
+- [API Documentation](https://pkg.go.dev/github.com/IBM/fp-go)
+- [Code Samples](./samples/)
+- [V2 Documentation](./v2/README.md) - New features in Go 1.24+
+- [fp-ts](https://github.com/gcanti/fp-ts) - Original TypeScript inspiration

-this would be the completely generic method signature for all possible monads. In particular in many cases it is possible to compose functions independent of the concrete knowledge of the actual `HKT`. From the perspective of a library this is the ideal situation because then a particular algorithm only has to be implemented and tested once.
+## 🤝 Contributing

-This FP library addresses this by introducing the HKTs as individual types, e.g. `HKT[A]` would be represented as a new generic type `HKTA`. This loses the correlation to the type `A` but allows to implement generic algorithms, at the price of readability.
+Contributions are welcome! Please feel free to submit issues or pull requests.

-For that reason these implementations are kept in the `internal` package. These are meant to be used by the library itself or by extensions, not by end users.
+## 📄 License

-## Map/Ap/Flap
-
-The following table lists the relationship between some selected operators
-
-| Opertator | Parameter        | Monad           | Result   |
-| --------  | ---------------- | --------------- | -------- |
-| Map       | `func(A) B`      | `HKT[A]`        | `HKT[B]` |
-| Chain     | `func(A) HKT[B]` | `HKT[A]` | `HKT[B]` |
-| Ap        | `HKT[A]`         | `HKT[func(A)B]` | `HKT[B]` |
-| Flap      | `A`              | `HKT[func(A)B]` | `HKT[B]` |
+This project is licensed under the Apache License 2.0 - see the LICENSE file for details.
--- a/array/array.go
+++ b/array/array.go
@@ -141,6 +141,10 @@ func reduceRef[A, B any](fa []A, f func(B, *A) B, initial B) B {
 	return current
 }

+func MonadReduce[A, B any](fa []A, f func(B, A) B, initial B) B {
+	return G.MonadReduce(fa, f, initial)
+}
+
 func Reduce[A, B any](f func(B, A) B, initial B) func([]A) B {
 	return G.Reduce[[]A](f, initial)
 }
--- a/cli/contextreaderioeither.go
+++ b/cli/contextreaderioeither.go
@@ -365,6 +365,70 @@ func generateContextReaderIOEitherEitherize(f, fg *os.File, i int) {
 	fmt.Fprintln(fg, "}")
 }

+func generateContextReaderIOEitherUneitherize(f, fg *os.File, i int) {
+	// non generic version
+	fmt.Fprintf(f, "\n// Uneitherize%d converts a function with %d parameters returning a [ReaderIOEither[R]] into a function with %d parameters returning a tuple.\n// The first parameter is considered to be the [context.Context].\n", i, i+1, i)
+	fmt.Fprintf(f, "func Uneitherize%d[F ~func(", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j)
+	}
+	fmt.Fprintf(f, ") ReaderIOEither[R]")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ", R any](f F) func(context.Context")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ") (R, error) {\n")
+	fmt.Fprintf(f, "  return G.Uneitherize%d[ReaderIOEither[R]", i)
+
+	fmt.Fprintf(f, ", func(context.Context")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ")(R, error)](f)\n")
+	fmt.Fprintln(f, "}")
+
+	// generic version
+	fmt.Fprintf(fg, "\n// Uneitherize%d converts a function with %d parameters returning a [GRA] into a function with %d parameters returning a tuple.\n// The first parameter is considered to be the [context.Context].\n", i, i, i)
+	fmt.Fprintf(fg, "func Uneitherize%d[GRA ~func(context.Context) GIOA, F ~func(context.Context", i)
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", T%d", j)
+	}
+	fmt.Fprintf(fg, ") (R, error), GIOA ~func() E.Either[error, R]")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", T%d", j)
+	}
+	fmt.Fprintf(fg, ", R any](f func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "T%d", j)
+	}
+	fmt.Fprintf(fg, ") GRA) F {\n")
+
+	fmt.Fprintf(fg, "  return func(c context.Context")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", t%d T%d", j, j)
+	}
+	fmt.Fprintf(fg, ") (R, error) {\n")
+	fmt.Fprintf(fg, "    return E.UnwrapError(f(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "t%d", j)
+	}
+	fmt.Fprintf(fg, ")(c)())\n")
+	fmt.Fprintf(fg, "  }\n")
+	fmt.Fprintf(fg, "}\n")
+}
+
 func generateContextReaderIOEitherHelpers(filename string, count int) error {
 	dir, err := os.Getwd()
 	if err != nil {
@@ -420,10 +484,12 @@ import (
 `)

 	generateContextReaderIOEitherEitherize(f, fg, 0)
+	generateContextReaderIOEitherUneitherize(f, fg, 0)

 	for i := 1; i <= count; i++ {
 		// eitherize
 		generateContextReaderIOEitherEitherize(f, fg, i)
+		generateContextReaderIOEitherUneitherize(f, fg, i)
 		// sequenceT
 		generateContextReaderIOEitherSequenceT("")(f, fg, i)
 		generateContextReaderIOEitherSequenceT("Seq")(f, fg, i)
--- a/cli/readerioeither.go
+++ b/cli/readerioeither.go
@@ -136,6 +136,70 @@ func generateReaderIOEitherEitherize(f, fg *os.File, i int) {
 	fmt.Fprintf(fg, "}\n")
 }

+func generateReaderIOEitherUneitherize(f, fg *os.File, i int) {
+	// non generic version
+	fmt.Fprintf(f, "\n// Uneitherize%d converts a function with %d parameters returning a [ReaderIOEither[C, error, R]] into a function with %d parameters returning a tuple.\n// The first parameter is considered to be the context [C].\n", i, i+1, i)
+	fmt.Fprintf(f, "func Uneitherize%d[F ~func(", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j)
+	}
+	fmt.Fprintf(f, ") ReaderIOEither[C, error, R]")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ", C, R any](f F) func(C")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ") (R, error) {\n")
+	fmt.Fprintf(f, "  return G.Uneitherize%d[ReaderIOEither[C, error, R]", i)
+
+	fmt.Fprintf(f, ", func(C")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ")(R, error)](f)\n")
+	fmt.Fprintln(f, "}")
+
+	// generic version
+	fmt.Fprintf(fg, "\n// Uneitherize%d converts a function with %d parameters returning a [GRA] into a function with %d parameters returning a tuple.\n// The first parameter is considered to be the context [C].\n", i, i, i)
+	fmt.Fprintf(fg, "func Uneitherize%d[GRA ~func(C) GIOA, F ~func(C", i)
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", T%d", j)
+	}
+	fmt.Fprintf(fg, ") (R, error), GIOA ~func() E.Either[error, R]")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", T%d", j)
+	}
+	fmt.Fprintf(fg, ", C, R any](f func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "T%d", j)
+	}
+	fmt.Fprintf(fg, ") GRA) F {\n")
+
+	fmt.Fprintf(fg, "  return func(c C")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", t%d T%d", j, j)
+	}
+	fmt.Fprintf(fg, ") (R, error) {\n")
+	fmt.Fprintf(fg, "    return E.UnwrapError(f(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "t%d", j)
+	}
+	fmt.Fprintf(fg, ")(c)())\n")
+	fmt.Fprintf(fg, "  }\n")
+	fmt.Fprintf(fg, "}\n")
+}
+
 func generateReaderIOEitherHelpers(filename string, count int) error {
 	dir, err := os.Getwd()
 	if err != nil {
@@ -197,12 +261,16 @@ import (
 	generateReaderIOEitherFrom(f, fg, 0)
 	// eitherize
 	generateReaderIOEitherEitherize(f, fg, 0)
+	// uneitherize
+	generateReaderIOEitherUneitherize(f, fg, 0)

 	for i := 1; i <= count; i++ {
 		// from
 		generateReaderIOEitherFrom(f, fg, i)
 		// eitherize
 		generateReaderIOEitherEitherize(f, fg, i)
+		// uneitherize
+		generateReaderIOEitherUneitherize(f, fg, i)
 	}

 	return nil
--- a/cli/templates/functions.go
+++ b/cli/templates/functions.go
@@ -0,0 +1,15 @@
+package templates
+
+import (
+	"text/template"
+
+	E "github.com/IBM/fp-go/either"
+)
+
+var (
+	templateFunctions = template.FuncMap{}
+)
+
+func Parse(name, tmpl string) E.Either[error, *template.Template] {
+	return E.TryCatchError(template.New(name).Funcs(templateFunctions).Parse(tmpl))
+}
--- a/context/readerioeither/gen.go
+++ b/context/readerioeither/gen.go
@@ -2,7 +2,7 @@ package readerioeither

 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:30:39.012572 +0200 CEST m=+0.008846101
+// 2024-05-24 22:24:01.4250895 +0200 CEST m=+0.014515801

 import (
 	"context"
@@ -17,12 +17,24 @@ func Eitherize0[F ~func(context.Context) (R, error), R any](f F) func() ReaderIO
 	return G.Eitherize0[ReaderIOEither[R]](f)
 }

+// Uneitherize0 converts a function with 1 parameters returning a [ReaderIOEither[R]] into a function with 0 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize0[F ~func() ReaderIOEither[R], R any](f F) func(context.Context) (R, error) {
+	return G.Uneitherize0[ReaderIOEither[R], func(context.Context) (R, error)](f)
+}
+
 // Eitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize1]
 func Eitherize1[F ~func(context.Context, T0) (R, error), T0, R any](f F) func(T0) ReaderIOEither[R] {
 	return G.Eitherize1[ReaderIOEither[R]](f)
 }

+// Uneitherize1 converts a function with 2 parameters returning a [ReaderIOEither[R]] into a function with 1 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize1[F ~func(T0) ReaderIOEither[R], T0, R any](f F) func(context.Context, T0) (R, error) {
+	return G.Uneitherize1[ReaderIOEither[R], func(context.Context, T0) (R, error)](f)
+}
+
 // SequenceT1 converts 1 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple1].
 func SequenceT1[T1 any](t1 ReaderIOEither[T1]) ReaderIOEither[T.Tuple1[T1]] {
 	return G.SequenceT1[ReaderIOEither[T.Tuple1[T1]]](t1)
@@ -74,6 +86,12 @@ func Eitherize2[F ~func(context.Context, T0, T1) (R, error), T0, T1, R any](f F)
 	return G.Eitherize2[ReaderIOEither[R]](f)
 }

+// Uneitherize2 converts a function with 3 parameters returning a [ReaderIOEither[R]] into a function with 2 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize2[F ~func(T0, T1) ReaderIOEither[R], T0, T1, R any](f F) func(context.Context, T0, T1) (R, error) {
+	return G.Uneitherize2[ReaderIOEither[R], func(context.Context, T0, T1) (R, error)](f)
+}
+
 // SequenceT2 converts 2 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple2].
 func SequenceT2[T1, T2 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2]) ReaderIOEither[T.Tuple2[T1, T2]] {
 	return G.SequenceT2[ReaderIOEither[T.Tuple2[T1, T2]]](t1, t2)
@@ -125,6 +143,12 @@ func Eitherize3[F ~func(context.Context, T0, T1, T2) (R, error), T0, T1, T2, R a
 	return G.Eitherize3[ReaderIOEither[R]](f)
 }

+// Uneitherize3 converts a function with 4 parameters returning a [ReaderIOEither[R]] into a function with 3 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize3[F ~func(T0, T1, T2) ReaderIOEither[R], T0, T1, T2, R any](f F) func(context.Context, T0, T1, T2) (R, error) {
+	return G.Uneitherize3[ReaderIOEither[R], func(context.Context, T0, T1, T2) (R, error)](f)
+}
+
 // SequenceT3 converts 3 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple3].
 func SequenceT3[T1, T2, T3 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3]) ReaderIOEither[T.Tuple3[T1, T2, T3]] {
 	return G.SequenceT3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](t1, t2, t3)
@@ -176,6 +200,12 @@ func Eitherize4[F ~func(context.Context, T0, T1, T2, T3) (R, error), T0, T1, T2,
 	return G.Eitherize4[ReaderIOEither[R]](f)
 }

+// Uneitherize4 converts a function with 5 parameters returning a [ReaderIOEither[R]] into a function with 4 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize4[F ~func(T0, T1, T2, T3) ReaderIOEither[R], T0, T1, T2, T3, R any](f F) func(context.Context, T0, T1, T2, T3) (R, error) {
+	return G.Uneitherize4[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3) (R, error)](f)
+}
+
 // SequenceT4 converts 4 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple4].
 func SequenceT4[T1, T2, T3, T4 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4]) ReaderIOEither[T.Tuple4[T1, T2, T3, T4]] {
 	return G.SequenceT4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](t1, t2, t3, t4)
@@ -227,6 +257,12 @@ func Eitherize5[F ~func(context.Context, T0, T1, T2, T3, T4) (R, error), T0, T1,
 	return G.Eitherize5[ReaderIOEither[R]](f)
 }

+// Uneitherize5 converts a function with 6 parameters returning a [ReaderIOEither[R]] into a function with 5 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize5[F ~func(T0, T1, T2, T3, T4) ReaderIOEither[R], T0, T1, T2, T3, T4, R any](f F) func(context.Context, T0, T1, T2, T3, T4) (R, error) {
+	return G.Uneitherize5[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4) (R, error)](f)
+}
+
 // SequenceT5 converts 5 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple5].
 func SequenceT5[T1, T2, T3, T4, T5 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5]) ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]] {
 	return G.SequenceT5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](t1, t2, t3, t4, t5)
@@ -278,6 +314,12 @@ func Eitherize6[F ~func(context.Context, T0, T1, T2, T3, T4, T5) (R, error), T0,
 	return G.Eitherize6[ReaderIOEither[R]](f)
 }

+// Uneitherize6 converts a function with 7 parameters returning a [ReaderIOEither[R]] into a function with 6 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize6[F ~func(T0, T1, T2, T3, T4, T5) ReaderIOEither[R], T0, T1, T2, T3, T4, T5, R any](f F) func(context.Context, T0, T1, T2, T3, T4, T5) (R, error) {
+	return G.Uneitherize6[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4, T5) (R, error)](f)
+}
+
 // SequenceT6 converts 6 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple6].
 func SequenceT6[T1, T2, T3, T4, T5, T6 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6]) ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
 	return G.SequenceT6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](t1, t2, t3, t4, t5, t6)
@@ -329,6 +371,12 @@ func Eitherize7[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error),
 	return G.Eitherize7[ReaderIOEither[R]](f)
 }

+// Uneitherize7 converts a function with 8 parameters returning a [ReaderIOEither[R]] into a function with 7 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize7[F ~func(T0, T1, T2, T3, T4, T5, T6) ReaderIOEither[R], T0, T1, T2, T3, T4, T5, T6, R any](f F) func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error) {
+	return G.Uneitherize7[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error)](f)
+}
+
 // SequenceT7 converts 7 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple7].
 func SequenceT7[T1, T2, T3, T4, T5, T6, T7 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6], t7 ReaderIOEither[T7]) ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
 	return G.SequenceT7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](t1, t2, t3, t4, t5, t6, t7)
@@ -380,6 +428,12 @@ func Eitherize8[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, err
 	return G.Eitherize8[ReaderIOEither[R]](f)
 }

+// Uneitherize8 converts a function with 9 parameters returning a [ReaderIOEither[R]] into a function with 8 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) ReaderIOEither[R], T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, error) {
+	return G.Uneitherize8[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, error)](f)
+}
+
 // SequenceT8 converts 8 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple8].
 func SequenceT8[T1, T2, T3, T4, T5, T6, T7, T8 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6], t7 ReaderIOEither[T7], t8 ReaderIOEither[T8]) ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
 	return G.SequenceT8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](t1, t2, t3, t4, t5, t6, t7, t8)
@@ -431,6 +485,12 @@ func Eitherize9[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R,
 	return G.Eitherize9[ReaderIOEither[R]](f)
 }

+// Uneitherize9 converts a function with 10 parameters returning a [ReaderIOEither[R]] into a function with 9 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) ReaderIOEither[R], T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error) {
+	return G.Uneitherize9[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error)](f)
+}
+
 // SequenceT9 converts 9 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple9].
 func SequenceT9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6], t7 ReaderIOEither[T7], t8 ReaderIOEither[T8], t9 ReaderIOEither[T9]) ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
 	return G.SequenceT9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](t1, t2, t3, t4, t5, t6, t7, t8, t9)
@@ -482,6 +542,12 @@ func Eitherize10[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
 	return G.Eitherize10[ReaderIOEither[R]](f)
 }

+// Uneitherize10 converts a function with 11 parameters returning a [ReaderIOEither[R]] into a function with 10 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f F) func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error) {
+	return G.Uneitherize10[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error)](f)
+}
+
 // SequenceT10 converts 10 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple10].
 func SequenceT10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6], t7 ReaderIOEither[T7], t8 ReaderIOEither[T8], t9 ReaderIOEither[T9], t10 ReaderIOEither[T10]) ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
 	return G.SequenceT10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
--- a/context/readerioeither/generic/gen.go
+++ b/context/readerioeither/generic/gen.go
@@ -2,7 +2,7 @@ package generic

 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:30:39.012572 +0200 CEST m=+0.008846101
+// 2024-05-24 22:24:01.4250895 +0200 CEST m=+0.014515801

 import (
 	"context"
@@ -19,12 +19,28 @@ func Eitherize0[GRA ~func(context.Context) GIOA, F ~func(context.Context) (R, er
 	return RE.Eitherize0[GRA](f)
 }

+// Uneitherize0 converts a function with 0 parameters returning a [GRA] into a function with 0 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize0[GRA ~func(context.Context) GIOA, F ~func(context.Context) (R, error), GIOA ~func() E.Either[error, R], R any](f func() GRA) F {
+	return func(c context.Context) (R, error) {
+		return E.UnwrapError(f()(c)())
+	}
+}
+
 // Eitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [GRA]
 // The inverse function is [Uneitherize1]
 func Eitherize1[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0) (R, error), GIOA ~func() E.Either[error, R], T0, R any](f F) func(T0) GRA {
 	return RE.Eitherize1[GRA](f)
 }

+// Uneitherize1 converts a function with 1 parameters returning a [GRA] into a function with 1 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize1[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0) (R, error), GIOA ~func() E.Either[error, R], T0, R any](f func(T0) GRA) F {
+	return func(c context.Context, t0 T0) (R, error) {
+		return E.UnwrapError(f(t0)(c)())
+	}
+}
+
 // SequenceT1 converts 1 readers into a reader of a [T.Tuple1].
 func SequenceT1[
 	GR_TUPLE1 ~func(context.Context) GIO_TUPLE1,
@@ -169,6 +185,14 @@ func Eitherize2[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize2[GRA](f)
 }

+// Uneitherize2 converts a function with 2 parameters returning a [GRA] into a function with 2 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize2[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1) (R, error), GIOA ~func() E.Either[error, R], T0, T1, R any](f func(T0, T1) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1) (R, error) {
+		return E.UnwrapError(f(t0, t1)(c)())
+	}
+}
+
 // SequenceT2 converts 2 readers into a reader of a [T.Tuple2].
 func SequenceT2[
 	GR_TUPLE2 ~func(context.Context) GIO_TUPLE2,
@@ -364,6 +388,14 @@ func Eitherize3[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize3[GRA](f)
 }

+// Uneitherize3 converts a function with 3 parameters returning a [GRA] into a function with 3 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize3[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, R any](f func(T0, T1, T2) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2)(c)())
+	}
+}
+
 // SequenceT3 converts 3 readers into a reader of a [T.Tuple3].
 func SequenceT3[
 	GR_TUPLE3 ~func(context.Context) GIO_TUPLE3,
@@ -610,6 +642,14 @@ func Eitherize4[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize4[GRA](f)
 }

+// Uneitherize4 converts a function with 4 parameters returning a [GRA] into a function with 4 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize4[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, R any](f func(T0, T1, T2, T3) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3)(c)())
+	}
+}
+
 // SequenceT4 converts 4 readers into a reader of a [T.Tuple4].
 func SequenceT4[
 	GR_TUPLE4 ~func(context.Context) GIO_TUPLE4,
@@ -907,6 +947,14 @@ func Eitherize5[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize5[GRA](f)
 }

+// Uneitherize5 converts a function with 5 parameters returning a [GRA] into a function with 5 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize5[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, R any](f func(T0, T1, T2, T3, T4) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4)(c)())
+	}
+}
+
 // SequenceT5 converts 5 readers into a reader of a [T.Tuple5].
 func SequenceT5[
 	GR_TUPLE5 ~func(context.Context) GIO_TUPLE5,
@@ -1255,6 +1303,14 @@ func Eitherize6[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize6[GRA](f)
 }

+// Uneitherize6 converts a function with 6 parameters returning a [GRA] into a function with 6 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize6[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, R any](f func(T0, T1, T2, T3, T4, T5) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5)(c)())
+	}
+}
+
 // SequenceT6 converts 6 readers into a reader of a [T.Tuple6].
 func SequenceT6[
 	GR_TUPLE6 ~func(context.Context) GIO_TUPLE6,
@@ -1654,6 +1710,14 @@ func Eitherize7[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize7[GRA](f)
 }

+// Uneitherize7 converts a function with 7 parameters returning a [GRA] into a function with 7 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize7[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, R any](f func(T0, T1, T2, T3, T4, T5, T6) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6)(c)())
+	}
+}
+
 // SequenceT7 converts 7 readers into a reader of a [T.Tuple7].
 func SequenceT7[
 	GR_TUPLE7 ~func(context.Context) GIO_TUPLE7,
@@ -2104,6 +2168,14 @@ func Eitherize8[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize8[GRA](f)
 }

+// Uneitherize8 converts a function with 8 parameters returning a [GRA] into a function with 8 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize8[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7)(c)())
+	}
+}
+
 // SequenceT8 converts 8 readers into a reader of a [T.Tuple8].
 func SequenceT8[
 	GR_TUPLE8 ~func(context.Context) GIO_TUPLE8,
@@ -2605,6 +2677,14 @@ func Eitherize9[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize9[GRA](f)
 }

+// Uneitherize9 converts a function with 9 parameters returning a [GRA] into a function with 9 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize9[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8)(c)())
+	}
+}
+
 // SequenceT9 converts 9 readers into a reader of a [T.Tuple9].
 func SequenceT9[
 	GR_TUPLE9 ~func(context.Context) GIO_TUPLE9,
@@ -3157,6 +3237,14 @@ func Eitherize10[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T
 	return RE.Eitherize10[GRA](f)
 }

+// Uneitherize10 converts a function with 10 parameters returning a [GRA] into a function with 10 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize10[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)(c)())
+	}
+}
+
 // SequenceT10 converts 10 readers into a reader of a [T.Tuple10].
 func SequenceT10[
 	GR_TUPLE10 ~func(context.Context) GIO_TUPLE10,
--- a/context/readerioeither/reader.go
+++ b/context/readerioeither/reader.go
@@ -25,6 +25,7 @@ import (
 	IOE "github.com/IBM/fp-go/ioeither"
 	L "github.com/IBM/fp-go/lazy"
 	O "github.com/IBM/fp-go/option"
+	RIO "github.com/IBM/fp-go/readerio"
 )

 func FromEither[A any](e ET.Either[error, A]) ReaderIOEither[A] {
@@ -192,8 +193,7 @@ func Memoize[A any](rdr ReaderIOEither[A]) ReaderIOEither[A] {
 }

 // Flatten converts a nested [ReaderIOEither] into a [ReaderIOEither]
-func Flatten[
-	A any](rdr ReaderIOEither[ReaderIOEither[A]]) ReaderIOEither[A] {
+func Flatten[A any](rdr ReaderIOEither[ReaderIOEither[A]]) ReaderIOEither[A] {
 	return G.Flatten[ReaderIOEither[ReaderIOEither[A]]](rdr)
 }

@@ -204,3 +204,15 @@ func MonadFlap[B, A any](fab ReaderIOEither[func(A) B], a A) ReaderIOEither[B] {
 func Flap[B, A any](a A) func(ReaderIOEither[func(A) B]) ReaderIOEither[B] {
 	return G.Flap[ReaderIOEither[func(A) B], ReaderIOEither[B]](a)
 }
+
+func Fold[A, B any](onLeft func(error) ReaderIOEither[B], onRight func(A) ReaderIOEither[B]) func(ReaderIOEither[A]) ReaderIOEither[B] {
+	return G.Fold[ReaderIOEither[B], ReaderIOEither[A]](onLeft, onRight)
+}
+
+func GetOrElse[A any](onLeft func(error) RIO.ReaderIO[context.Context, A]) func(ReaderIOEither[A]) RIO.ReaderIO[context.Context, A] {
+	return G.GetOrElse[RIO.ReaderIO[context.Context, A], ReaderIOEither[A]](onLeft)
+}
+
+func OrLeft[A any](onLeft func(error) RIO.ReaderIO[context.Context, error]) func(ReaderIOEither[A]) ReaderIOEither[A] {
+	return G.OrLeft[ReaderIOEither[A]](onLeft)
+}
--- a/coverage.bat
+++ b/coverage.bat
@@ -1,2 +1,3 @@
@echo off
-go tool cover -html=build/cover.out -o build/cover.html
+go tool cover -html=build/cover.out -o build/cover.html
+cov-report -ex ".*/cli/.*.go|.*/gen.go|.*/binds.go" build\cover.out
--- a/di/doc.go
+++ b/di/doc.go
@@ -40,4 +40,4 @@
 // [MakeInjector]: [github.com/IBM/fp-go/di/erasure.MakeInjector]
 package di

-//go:generate go run .. di --count 10 --filename gen.go
+//go:generate go run .. di --count 15 --filename gen.go
--- a/di/gen.go
+++ b/di/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-12-18 21:40:11.0891062 +0100 CET m=+0.007755601
+// 2024-02-29 16:18:47.9991921 +0100 CET m=+0.012914901

 package di

@@ -41,7 +41,7 @@ func MakeProviderFactory1[T1 any, R any](
 	)
 }

-// MakeTokenWithDefault1 creates an [InjectionToken] with a default implementation with 1 dependenciess
+// MakeTokenWithDefault1 creates an [InjectionToken] with a default implementation with 1 dependencies
 func MakeTokenWithDefault1[T1 any, R any](
 	name string,
 	d1 Dependency[T1],
@@ -102,7 +102,7 @@ func MakeProviderFactory2[T1, T2 any, R any](
 	)
 }

-// MakeTokenWithDefault2 creates an [InjectionToken] with a default implementation with 2 dependenciess
+// MakeTokenWithDefault2 creates an [InjectionToken] with a default implementation with 2 dependencies
 func MakeTokenWithDefault2[T1, T2 any, R any](
 	name string,
 	d1 Dependency[T1],
@@ -173,7 +173,7 @@ func MakeProviderFactory3[T1, T2, T3 any, R any](
 	)
 }

-// MakeTokenWithDefault3 creates an [InjectionToken] with a default implementation with 3 dependenciess
+// MakeTokenWithDefault3 creates an [InjectionToken] with a default implementation with 3 dependencies
 func MakeTokenWithDefault3[T1, T2, T3 any, R any](
 	name string,
 	d1 Dependency[T1],
@@ -254,7 +254,7 @@ func MakeProviderFactory4[T1, T2, T3, T4 any, R any](
 	)
 }

-// MakeTokenWithDefault4 creates an [InjectionToken] with a default implementation with 4 dependenciess
+// MakeTokenWithDefault4 creates an [InjectionToken] with a default implementation with 4 dependencies
 func MakeTokenWithDefault4[T1, T2, T3, T4 any, R any](
 	name string,
 	d1 Dependency[T1],
@@ -345,7 +345,7 @@ func MakeProviderFactory5[T1, T2, T3, T4, T5 any, R any](
 	)
 }

-// MakeTokenWithDefault5 creates an [InjectionToken] with a default implementation with 5 dependenciess
+// MakeTokenWithDefault5 creates an [InjectionToken] with a default implementation with 5 dependencies
 func MakeTokenWithDefault5[T1, T2, T3, T4, T5 any, R any](
 	name string,
 	d1 Dependency[T1],
@@ -446,7 +446,7 @@ func MakeProviderFactory6[T1, T2, T3, T4, T5, T6 any, R any](
 	)
 }

-// MakeTokenWithDefault6 creates an [InjectionToken] with a default implementation with 6 dependenciess
+// MakeTokenWithDefault6 creates an [InjectionToken] with a default implementation with 6 dependencies
 func MakeTokenWithDefault6[T1, T2, T3, T4, T5, T6 any, R any](
 	name string,
 	d1 Dependency[T1],
@@ -557,7 +557,7 @@ func MakeProviderFactory7[T1, T2, T3, T4, T5, T6, T7 any, R any](
 	)
 }

-// MakeTokenWithDefault7 creates an [InjectionToken] with a default implementation with 7 dependenciess
+// MakeTokenWithDefault7 creates an [InjectionToken] with a default implementation with 7 dependencies
 func MakeTokenWithDefault7[T1, T2, T3, T4, T5, T6, T7 any, R any](
 	name string,
 	d1 Dependency[T1],
@@ -678,7 +678,7 @@ func MakeProviderFactory8[T1, T2, T3, T4, T5, T6, T7, T8 any, R any](
 	)
 }

-// MakeTokenWithDefault8 creates an [InjectionToken] with a default implementation with 8 dependenciess
+// MakeTokenWithDefault8 creates an [InjectionToken] with a default implementation with 8 dependencies
 func MakeTokenWithDefault8[T1, T2, T3, T4, T5, T6, T7, T8 any, R any](
 	name string,
 	d1 Dependency[T1],
@@ -809,7 +809,7 @@ func MakeProviderFactory9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any, R any](
 	)
 }

-// MakeTokenWithDefault9 creates an [InjectionToken] with a default implementation with 9 dependenciess
+// MakeTokenWithDefault9 creates an [InjectionToken] with a default implementation with 9 dependencies
 func MakeTokenWithDefault9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any, R any](
 	name string,
 	d1 Dependency[T1],
@@ -950,7 +950,7 @@ func MakeProviderFactory10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any, R any](
 	)
 }

-// MakeTokenWithDefault10 creates an [InjectionToken] with a default implementation with 10 dependenciess
+// MakeTokenWithDefault10 creates an [InjectionToken] with a default implementation with 10 dependencies
 func MakeTokenWithDefault10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any, R any](
 	name string,
 	d1 Dependency[T1],
@@ -1011,3 +1011,878 @@ func MakeProvider10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any, R any](
 			f,
 		))
 }
+
+// eraseProviderFactory11 creates a function that takes a variadic number of untyped arguments and from a function of 11 strongly typed arguments and 11 dependencies
+func eraseProviderFactory11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {
+	ft := eraseTuple(T.Tupled11(f))
+	t1 := lookupAt[T1](0, d1)
+	t2 := lookupAt[T2](1, d2)
+	t3 := lookupAt[T3](2, d3)
+	t4 := lookupAt[T4](3, d4)
+	t5 := lookupAt[T5](4, d5)
+	t6 := lookupAt[T6](5, d6)
+	t7 := lookupAt[T7](6, d7)
+	t8 := lookupAt[T8](7, d8)
+	t9 := lookupAt[T9](8, d9)
+	t10 := lookupAt[T10](9, d10)
+	t11 := lookupAt[T11](10, d11)
+	return func(params ...any) IOE.IOEither[error, any] {
+		return ft(E.SequenceT11(
+			t1(params),
+			t2(params),
+			t3(params),
+			t4(params),
+			t5(params),
+			t6(params),
+			t7(params),
+			t8(params),
+			t9(params),
+			t10(params),
+			t11(params),
+		))
+	}
+}
+
+// MakeProviderFactory11 creates a [DIE.ProviderFactory] from a function with 11 arguments and 11 dependencies
+func MakeProviderFactory11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) IOE.IOEither[error, R],
+) DIE.ProviderFactory {
+	return DIE.MakeProviderFactory(
+		A.From[DIE.Dependency](
+			d1,
+			d2,
+			d3,
+			d4,
+			d5,
+			d6,
+			d7,
+			d8,
+			d9,
+			d10,
+			d11,
+		),
+		eraseProviderFactory11(
+			d1,
+			d2,
+			d3,
+			d4,
+			d5,
+			d6,
+			d7,
+			d8,
+			d9,
+			d10,
+			d11,
+			f,
+		),
+	)
+}
+
+// MakeTokenWithDefault11 creates an [InjectionToken] with a default implementation with 11 dependencies
+func MakeTokenWithDefault11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any, R any](
+	name string,
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) IOE.IOEither[error, R],
+) InjectionToken[R] {
+	return MakeTokenWithDefault[R](name, MakeProviderFactory11(
+		d1,
+		d2,
+		d3,
+		d4,
+		d5,
+		d6,
+		d7,
+		d8,
+		d9,
+		d10,
+		d11,
+		f,
+	))
+}
+
+// MakeProvider11 creates a [DIE.Provider] for an [InjectionToken] from a function with 11 dependencies
+func MakeProvider11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any, R any](
+	token InjectionToken[R],
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) IOE.IOEither[error, R],
+) DIE.Provider {
+	return DIE.MakeProvider(
+		token,
+		MakeProviderFactory11(
+			d1,
+			d2,
+			d3,
+			d4,
+			d5,
+			d6,
+			d7,
+			d8,
+			d9,
+			d10,
+			d11,
+			f,
+		))
+}
+
+// eraseProviderFactory12 creates a function that takes a variadic number of untyped arguments and from a function of 12 strongly typed arguments and 12 dependencies
+func eraseProviderFactory12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	d12 Dependency[T12],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {
+	ft := eraseTuple(T.Tupled12(f))
+	t1 := lookupAt[T1](0, d1)
+	t2 := lookupAt[T2](1, d2)
+	t3 := lookupAt[T3](2, d3)
+	t4 := lookupAt[T4](3, d4)
+	t5 := lookupAt[T5](4, d5)
+	t6 := lookupAt[T6](5, d6)
+	t7 := lookupAt[T7](6, d7)
+	t8 := lookupAt[T8](7, d8)
+	t9 := lookupAt[T9](8, d9)
+	t10 := lookupAt[T10](9, d10)
+	t11 := lookupAt[T11](10, d11)
+	t12 := lookupAt[T12](11, d12)
+	return func(params ...any) IOE.IOEither[error, any] {
+		return ft(E.SequenceT12(
+			t1(params),
+			t2(params),
+			t3(params),
+			t4(params),
+			t5(params),
+			t6(params),
+			t7(params),
+			t8(params),
+			t9(params),
+			t10(params),
+			t11(params),
+			t12(params),
+		))
+	}
+}
+
+// MakeProviderFactory12 creates a [DIE.ProviderFactory] from a function with 12 arguments and 12 dependencies
+func MakeProviderFactory12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	d12 Dependency[T12],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) IOE.IOEither[error, R],
+) DIE.ProviderFactory {
+	return DIE.MakeProviderFactory(
+		A.From[DIE.Dependency](
+			d1,
+			d2,
+			d3,
+			d4,
+			d5,
+			d6,
+			d7,
+			d8,
+			d9,
+			d10,
+			d11,
+			d12,
+		),
+		eraseProviderFactory12(
+			d1,
+			d2,
+			d3,
+			d4,
+			d5,
+			d6,
+			d7,
+			d8,
+			d9,
+			d10,
+			d11,
+			d12,
+			f,
+		),
+	)
+}
+
+// MakeTokenWithDefault12 creates an [InjectionToken] with a default implementation with 12 dependencies
+func MakeTokenWithDefault12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any, R any](
+	name string,
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	d12 Dependency[T12],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) IOE.IOEither[error, R],
+) InjectionToken[R] {
+	return MakeTokenWithDefault[R](name, MakeProviderFactory12(
+		d1,
+		d2,
+		d3,
+		d4,
+		d5,
+		d6,
+		d7,
+		d8,
+		d9,
+		d10,
+		d11,
+		d12,
+		f,
+	))
+}
+
+// MakeProvider12 creates a [DIE.Provider] for an [InjectionToken] from a function with 12 dependencies
+func MakeProvider12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any, R any](
+	token InjectionToken[R],
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	d12 Dependency[T12],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) IOE.IOEither[error, R],
+) DIE.Provider {
+	return DIE.MakeProvider(
+		token,
+		MakeProviderFactory12(
+			d1,
+			d2,
+			d3,
+			d4,
+			d5,
+			d6,
+			d7,
+			d8,
+			d9,
+			d10,
+			d11,
+			d12,
+			f,
+		))
+}
+
+// eraseProviderFactory13 creates a function that takes a variadic number of untyped arguments and from a function of 13 strongly typed arguments and 13 dependencies
+func eraseProviderFactory13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	d12 Dependency[T12],
+	d13 Dependency[T13],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {
+	ft := eraseTuple(T.Tupled13(f))
+	t1 := lookupAt[T1](0, d1)
+	t2 := lookupAt[T2](1, d2)
+	t3 := lookupAt[T3](2, d3)
+	t4 := lookupAt[T4](3, d4)
+	t5 := lookupAt[T5](4, d5)
+	t6 := lookupAt[T6](5, d6)
+	t7 := lookupAt[T7](6, d7)
+	t8 := lookupAt[T8](7, d8)
+	t9 := lookupAt[T9](8, d9)
+	t10 := lookupAt[T10](9, d10)
+	t11 := lookupAt[T11](10, d11)
+	t12 := lookupAt[T12](11, d12)
+	t13 := lookupAt[T13](12, d13)
+	return func(params ...any) IOE.IOEither[error, any] {
+		return ft(E.SequenceT13(
+			t1(params),
+			t2(params),
+			t3(params),
+			t4(params),
+			t5(params),
+			t6(params),
+			t7(params),
+			t8(params),
+			t9(params),
+			t10(params),
+			t11(params),
+			t12(params),
+			t13(params),
+		))
+	}
+}
+
+// MakeProviderFactory13 creates a [DIE.ProviderFactory] from a function with 13 arguments and 13 dependencies
+func MakeProviderFactory13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	d12 Dependency[T12],
+	d13 Dependency[T13],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) IOE.IOEither[error, R],
+) DIE.ProviderFactory {
+	return DIE.MakeProviderFactory(
+		A.From[DIE.Dependency](
+			d1,
+			d2,
+			d3,
+			d4,
+			d5,
+			d6,
+			d7,
+			d8,
+			d9,
+			d10,
+			d11,
+			d12,
+			d13,
+		),
+		eraseProviderFactory13(
+			d1,
+			d2,
+			d3,
+			d4,
+			d5,
+			d6,
+			d7,
+			d8,
+			d9,
+			d10,
+			d11,
+			d12,
+			d13,
+			f,
+		),
+	)
+}
+
+// MakeTokenWithDefault13 creates an [InjectionToken] with a default implementation with 13 dependencies
+func MakeTokenWithDefault13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any, R any](
+	name string,
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	d12 Dependency[T12],
+	d13 Dependency[T13],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) IOE.IOEither[error, R],
+) InjectionToken[R] {
+	return MakeTokenWithDefault[R](name, MakeProviderFactory13(
+		d1,
+		d2,
+		d3,
+		d4,
+		d5,
+		d6,
+		d7,
+		d8,
+		d9,
+		d10,
+		d11,
+		d12,
+		d13,
+		f,
+	))
+}
+
+// MakeProvider13 creates a [DIE.Provider] for an [InjectionToken] from a function with 13 dependencies
+func MakeProvider13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any, R any](
+	token InjectionToken[R],
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	d12 Dependency[T12],
+	d13 Dependency[T13],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) IOE.IOEither[error, R],
+) DIE.Provider {
+	return DIE.MakeProvider(
+		token,
+		MakeProviderFactory13(
+			d1,
+			d2,
+			d3,
+			d4,
+			d5,
+			d6,
+			d7,
+			d8,
+			d9,
+			d10,
+			d11,
+			d12,
+			d13,
+			f,
+		))
+}
+
+// eraseProviderFactory14 creates a function that takes a variadic number of untyped arguments and from a function of 14 strongly typed arguments and 14 dependencies
+func eraseProviderFactory14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	d12 Dependency[T12],
+	d13 Dependency[T13],
+	d14 Dependency[T14],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {
+	ft := eraseTuple(T.Tupled14(f))
+	t1 := lookupAt[T1](0, d1)
+	t2 := lookupAt[T2](1, d2)
+	t3 := lookupAt[T3](2, d3)
+	t4 := lookupAt[T4](3, d4)
+	t5 := lookupAt[T5](4, d5)
+	t6 := lookupAt[T6](5, d6)
+	t7 := lookupAt[T7](6, d7)
+	t8 := lookupAt[T8](7, d8)
+	t9 := lookupAt[T9](8, d9)
+	t10 := lookupAt[T10](9, d10)
+	t11 := lookupAt[T11](10, d11)
+	t12 := lookupAt[T12](11, d12)
+	t13 := lookupAt[T13](12, d13)
+	t14 := lookupAt[T14](13, d14)
+	return func(params ...any) IOE.IOEither[error, any] {
+		return ft(E.SequenceT14(
+			t1(params),
+			t2(params),
+			t3(params),
+			t4(params),
+			t5(params),
+			t6(params),
+			t7(params),
+			t8(params),
+			t9(params),
+			t10(params),
+			t11(params),
+			t12(params),
+			t13(params),
+			t14(params),
+		))
+	}
+}
+
+// MakeProviderFactory14 creates a [DIE.ProviderFactory] from a function with 14 arguments and 14 dependencies
+func MakeProviderFactory14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	d12 Dependency[T12],
+	d13 Dependency[T13],
+	d14 Dependency[T14],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) IOE.IOEither[error, R],
+) DIE.ProviderFactory {
+	return DIE.MakeProviderFactory(
+		A.From[DIE.Dependency](
+			d1,
+			d2,
+			d3,
+			d4,
+			d5,
+			d6,
+			d7,
+			d8,
+			d9,
+			d10,
+			d11,
+			d12,
+			d13,
+			d14,
+		),
+		eraseProviderFactory14(
+			d1,
+			d2,
+			d3,
+			d4,
+			d5,
+			d6,
+			d7,
+			d8,
+			d9,
+			d10,
+			d11,
+			d12,
+			d13,
+			d14,
+			f,
+		),
+	)
+}
+
+// MakeTokenWithDefault14 creates an [InjectionToken] with a default implementation with 14 dependencies
+func MakeTokenWithDefault14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any, R any](
+	name string,
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	d12 Dependency[T12],
+	d13 Dependency[T13],
+	d14 Dependency[T14],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) IOE.IOEither[error, R],
+) InjectionToken[R] {
+	return MakeTokenWithDefault[R](name, MakeProviderFactory14(
+		d1,
+		d2,
+		d3,
+		d4,
+		d5,
+		d6,
+		d7,
+		d8,
+		d9,
+		d10,
+		d11,
+		d12,
+		d13,
+		d14,
+		f,
+	))
+}
+
+// MakeProvider14 creates a [DIE.Provider] for an [InjectionToken] from a function with 14 dependencies
+func MakeProvider14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any, R any](
+	token InjectionToken[R],
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	d12 Dependency[T12],
+	d13 Dependency[T13],
+	d14 Dependency[T14],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) IOE.IOEither[error, R],
+) DIE.Provider {
+	return DIE.MakeProvider(
+		token,
+		MakeProviderFactory14(
+			d1,
+			d2,
+			d3,
+			d4,
+			d5,
+			d6,
+			d7,
+			d8,
+			d9,
+			d10,
+			d11,
+			d12,
+			d13,
+			d14,
+			f,
+		))
+}
+
+// eraseProviderFactory15 creates a function that takes a variadic number of untyped arguments and from a function of 15 strongly typed arguments and 15 dependencies
+func eraseProviderFactory15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	d12 Dependency[T12],
+	d13 Dependency[T13],
+	d14 Dependency[T14],
+	d15 Dependency[T15],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {
+	ft := eraseTuple(T.Tupled15(f))
+	t1 := lookupAt[T1](0, d1)
+	t2 := lookupAt[T2](1, d2)
+	t3 := lookupAt[T3](2, d3)
+	t4 := lookupAt[T4](3, d4)
+	t5 := lookupAt[T5](4, d5)
+	t6 := lookupAt[T6](5, d6)
+	t7 := lookupAt[T7](6, d7)
+	t8 := lookupAt[T8](7, d8)
+	t9 := lookupAt[T9](8, d9)
+	t10 := lookupAt[T10](9, d10)
+	t11 := lookupAt[T11](10, d11)
+	t12 := lookupAt[T12](11, d12)
+	t13 := lookupAt[T13](12, d13)
+	t14 := lookupAt[T14](13, d14)
+	t15 := lookupAt[T15](14, d15)
+	return func(params ...any) IOE.IOEither[error, any] {
+		return ft(E.SequenceT15(
+			t1(params),
+			t2(params),
+			t3(params),
+			t4(params),
+			t5(params),
+			t6(params),
+			t7(params),
+			t8(params),
+			t9(params),
+			t10(params),
+			t11(params),
+			t12(params),
+			t13(params),
+			t14(params),
+			t15(params),
+		))
+	}
+}
+
+// MakeProviderFactory15 creates a [DIE.ProviderFactory] from a function with 15 arguments and 15 dependencies
+func MakeProviderFactory15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	d12 Dependency[T12],
+	d13 Dependency[T13],
+	d14 Dependency[T14],
+	d15 Dependency[T15],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) IOE.IOEither[error, R],
+) DIE.ProviderFactory {
+	return DIE.MakeProviderFactory(
+		A.From[DIE.Dependency](
+			d1,
+			d2,
+			d3,
+			d4,
+			d5,
+			d6,
+			d7,
+			d8,
+			d9,
+			d10,
+			d11,
+			d12,
+			d13,
+			d14,
+			d15,
+		),
+		eraseProviderFactory15(
+			d1,
+			d2,
+			d3,
+			d4,
+			d5,
+			d6,
+			d7,
+			d8,
+			d9,
+			d10,
+			d11,
+			d12,
+			d13,
+			d14,
+			d15,
+			f,
+		),
+	)
+}
+
+// MakeTokenWithDefault15 creates an [InjectionToken] with a default implementation with 15 dependencies
+func MakeTokenWithDefault15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any, R any](
+	name string,
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	d12 Dependency[T12],
+	d13 Dependency[T13],
+	d14 Dependency[T14],
+	d15 Dependency[T15],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) IOE.IOEither[error, R],
+) InjectionToken[R] {
+	return MakeTokenWithDefault[R](name, MakeProviderFactory15(
+		d1,
+		d2,
+		d3,
+		d4,
+		d5,
+		d6,
+		d7,
+		d8,
+		d9,
+		d10,
+		d11,
+		d12,
+		d13,
+		d14,
+		d15,
+		f,
+	))
+}
+
+// MakeProvider15 creates a [DIE.Provider] for an [InjectionToken] from a function with 15 dependencies
+func MakeProvider15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any, R any](
+	token InjectionToken[R],
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	d3 Dependency[T3],
+	d4 Dependency[T4],
+	d5 Dependency[T5],
+	d6 Dependency[T6],
+	d7 Dependency[T7],
+	d8 Dependency[T8],
+	d9 Dependency[T9],
+	d10 Dependency[T10],
+	d11 Dependency[T11],
+	d12 Dependency[T12],
+	d13 Dependency[T13],
+	d14 Dependency[T14],
+	d15 Dependency[T15],
+	f func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) IOE.IOEither[error, R],
+) DIE.Provider {
+	return DIE.MakeProvider(
+		token,
+		MakeProviderFactory15(
+			d1,
+			d2,
+			d3,
+			d4,
+			d5,
+			d6,
+			d7,
+			d8,
+			d9,
+			d10,
+			d11,
+			d12,
+			d13,
+			d14,
+			d15,
+			f,
+		))
+}
--- a/either/array_test.go
+++ b/either/array_test.go
@@ -1,8 +1,10 @@
 package either

 import (
+	"fmt"
 	"testing"

+	TST "github.com/IBM/fp-go/internal/testing"
 	"github.com/stretchr/testify/assert"
 )

@@ -16,3 +18,33 @@ func TestCompactArray(t *testing.T) {
 	res := CompactArray(ar)
 	assert.Equal(t, 2, len(res))
 }
+
+func TestSequenceArray(t *testing.T) {
+
+	s := TST.SequenceArrayTest(
+		FromStrictEquals[error, bool](),
+		Pointed[error, string](),
+		Pointed[error, bool](),
+		Functor[error, []string, bool](),
+		SequenceArray[error, string],
+	)
+
+	for i := 0; i < 10; i++ {
+		t.Run(fmt.Sprintf("TestSequenceArray %d", i), s(i))
+	}
+}
+
+func TestSequenceArrayError(t *testing.T) {
+
+	s := TST.SequenceArrayErrorTest(
+		FromStrictEquals[error, bool](),
+		Left[string, error],
+		Left[bool, error],
+		Pointed[error, string](),
+		Pointed[error, bool](),
+		Functor[error, []string, bool](),
+		SequenceArray[error, string],
+	)
+	// run across four bits
+	s(4)(t)
+}
--- a/either/core.go
+++ b/either/core.go
@@ -21,8 +21,8 @@ import (

 type (
 	either struct {
-		isLeft bool
 		value  any
+		isLeft bool
 	}

 	// Either defines a data structure that logically holds either an E or an A. The flag discriminates the cases
@@ -31,7 +31,7 @@ type (

 // String prints some debug info for the object
 //
-// go:noinline
+//go:noinline
 func eitherString(s *either) string {
 	if s.isLeft {
 		return fmt.Sprintf("Left[%T](%v)", s.value, s.value)
@@ -41,7 +41,7 @@ func eitherString(s *either) string {

 // Format prints some debug info for the object
 //
-// go:noinline
+//go:noinline
 func eitherFormat(e *either, f fmt.State, c rune) {
 	switch c {
 	case 's':
@@ -73,12 +73,12 @@ func IsRight[E, A any](val Either[E, A]) bool {

 // Left creates a new instance of an [Either] representing the left value.
 func Left[A, E any](value E) Either[E, A] {
-	return Either[E, A]{true, value}
+	return Either[E, A]{value, true}
 }

 // Right creates a new instance of an [Either] representing the right value.
 func Right[E, A any](value A) Either[E, A] {
-	return Either[E, A]{false, value}
+	return Either[E, A]{value, false}
 }

 // MonadFold extracts the values from an [Either] by invoking the [onLeft] callback or the [onRight] callback depending on the case
@@ -94,8 +94,7 @@ func Unwrap[E, A any](ma Either[E, A]) (A, E) {
 	if ma.isLeft {
 		var a A
 		return a, ma.value.(E)
-	} else {
-		var e E
-		return ma.value.(A), e
 	}
+	var e E
+	return ma.value.(A), e
 }
--- a/either/doc.go
+++ b/either/doc.go
@@ -16,4 +16,4 @@
 // Package option defines the [Either] datastructure and its monadic operations
 package either

-//go:generate go run .. either --count 10 --filename gen.go
+//go:generate go run .. either --count 15 --filename gen.go
--- a/either/either.go
+++ b/either/either.go
@@ -33,7 +33,7 @@ func Of[E, A any](value A) Either[E, A] {
 	return F.Pipe1(value, Right[E, A])
 }

-func FromIO[E, IO ~func() A, A any](f IO) Either[E, A] {
+func FromIO[E any, IO ~func() A, A any](f IO) Either[E, A] {
 	return F.Pipe1(f(), Right[E, A])
 }

--- a/either/either_test.go
+++ b/either/either_test.go
@@ -22,6 +22,7 @@ import (

 	F "github.com/IBM/fp-go/function"
 	"github.com/IBM/fp-go/internal/utils"
+	IO "github.com/IBM/fp-go/io"
 	O "github.com/IBM/fp-go/option"
 	S "github.com/IBM/fp-go/string"
 	"github.com/stretchr/testify/assert"
@@ -71,7 +72,6 @@ func TestReduce(t *testing.T) {
 	assert.Equal(t, "foo", F.Pipe1(Left[string, string]("bar"), Reduce[string](s.Concat, "foo")))

 }
-
 func TestAp(t *testing.T) {
 	f := S.Size

@@ -120,3 +120,10 @@ func TestStringer(t *testing.T) {
 	var s fmt.Stringer = e
 	assert.Equal(t, exp, s.String())
 }
+
+func TestFromIO(t *testing.T) {
+	f := IO.Of("abc")
+	e := FromIO[error](f)
+
+	assert.Equal(t, Right[error]("abc"), e)
+}
--- a/either/functor.go
+++ b/either/functor.go
@@ -0,0 +1,31 @@
+// Copyright (c) 2024 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 either
+
+import (
+	"github.com/IBM/fp-go/internal/functor"
+)
+
+type eitherFunctor[E, A, B any] struct{}
+
+func (o *eitherFunctor[E, A, B]) Map(f func(A) B) func(Either[E, A]) Either[E, B] {
+	return Map[E, A, B](f)
+}
+
+// Functor implements the functoric operations for [Either]
+func Functor[E, A, B any]() functor.Functor[A, B, Either[E, A], Either[E, B]] {
+	return &eitherFunctor[E, A, B]{}
+}
--- a/either/gen.go
+++ b/either/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:30:40.410373 +0200 CEST m=+0.010337601
+// 2024-02-29 16:18:50.8721435 +0100 CET m=+0.070394501

 package either

@@ -679,3 +679,518 @@ func TraverseTuple10[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3
 		)
 	}
 }
+
+// Eitherize11 converts a function with 11 parameters returning a tuple into a function with 11 parameters returning an Either
+// The inverse function is [Uneitherize11]
+func Eitherize11[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) Either[error, R] {
+	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) Either[error, R] {
+		return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10))
+	}
+}
+
+// Uneitherize11 converts a function with 11 parameters returning an Either into a function with 11 parameters returning a tuple
+// The inverse function is [Eitherize11]
+func Uneitherize11[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) (R, error) {
+	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) (R, error) {
+		return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10))
+	}
+}
+
+// SequenceT11 converts 11 parameters of [Either[E, T]] into a [Either[E, Tuple11]].
+func SequenceT11[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4], t5 Either[E, T5], t6 Either[E, T6], t7 Either[E, T7], t8 Either[E, T8], t9 Either[E, T9], t10 Either[E, T10], t11 Either[E, T11]) Either[E, T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] {
+	return A.SequenceT11(
+		Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]],
+		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T2],
+		Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T3],
+		Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T4],
+		Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T5],
+		Ap[func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T6],
+		Ap[func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T7],
+		Ap[func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T8],
+		Ap[func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T9],
+		Ap[func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T10],
+		Ap[T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T11],
+		t1,
+		t2,
+		t3,
+		t4,
+		t5,
+		t6,
+		t7,
+		t8,
+		t9,
+		t10,
+		t11,
+	)
+}
+
+// SequenceTuple11 converts a [Tuple11] of [Either[E, T]] into an [Either[E, Tuple11]].
+func SequenceTuple11[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](t T.Tuple11[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4], Either[E, T5], Either[E, T6], Either[E, T7], Either[E, T8], Either[E, T9], Either[E, T10], Either[E, T11]]) Either[E, T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] {
+	return A.SequenceTuple11(
+		Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]],
+		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T2],
+		Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T3],
+		Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T4],
+		Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T5],
+		Ap[func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T6],
+		Ap[func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T7],
+		Ap[func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T8],
+		Ap[func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T9],
+		Ap[func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T10],
+		Ap[T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T11],
+		t,
+	)
+}
+
+// TraverseTuple11 converts a [Tuple11] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple11]].
+func TraverseTuple11[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], F11 ~func(A11) Either[E, T11], E, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10, A11, T11 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[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Either[E, T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] {
+	return func(t T.Tuple11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Either[E, T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] {
+		return A.TraverseTuple11(
+			Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]],
+			Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T2],
+			Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T3],
+			Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T4],
+			Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T5],
+			Ap[func(T7) func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T6],
+			Ap[func(T8) func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T7],
+			Ap[func(T9) func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T8],
+			Ap[func(T10) func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T9],
+			Ap[func(T11) T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T10],
+			Ap[T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11], E, T11],
+			f1,
+			f2,
+			f3,
+			f4,
+			f5,
+			f6,
+			f7,
+			f8,
+			f9,
+			f10,
+			f11,
+			t,
+		)
+	}
+}
+
+// Eitherize12 converts a function with 12 parameters returning a tuple into a function with 12 parameters returning an Either
+// The inverse function is [Uneitherize12]
+func Eitherize12[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) Either[error, R] {
+	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11) Either[error, R] {
+		return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11))
+	}
+}
+
+// Uneitherize12 converts a function with 12 parameters returning an Either into a function with 12 parameters returning a tuple
+// The inverse function is [Eitherize12]
+func Uneitherize12[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) (R, error) {
+	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11) (R, error) {
+		return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11))
+	}
+}
+
+// SequenceT12 converts 12 parameters of [Either[E, T]] into a [Either[E, Tuple12]].
+func SequenceT12[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4], t5 Either[E, T5], t6 Either[E, T6], t7 Either[E, T7], t8 Either[E, T8], t9 Either[E, T9], t10 Either[E, T10], t11 Either[E, T11], t12 Either[E, T12]) Either[E, T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] {
+	return A.SequenceT12(
+		Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]],
+		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T2],
+		Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T3],
+		Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T4],
+		Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T5],
+		Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T6],
+		Ap[func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T7],
+		Ap[func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T8],
+		Ap[func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T9],
+		Ap[func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T10],
+		Ap[func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T11],
+		Ap[T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T12],
+		t1,
+		t2,
+		t3,
+		t4,
+		t5,
+		t6,
+		t7,
+		t8,
+		t9,
+		t10,
+		t11,
+		t12,
+	)
+}
+
+// SequenceTuple12 converts a [Tuple12] of [Either[E, T]] into an [Either[E, Tuple12]].
+func SequenceTuple12[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](t T.Tuple12[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4], Either[E, T5], Either[E, T6], Either[E, T7], Either[E, T8], Either[E, T9], Either[E, T10], Either[E, T11], Either[E, T12]]) Either[E, T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] {
+	return A.SequenceTuple12(
+		Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]],
+		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T2],
+		Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T3],
+		Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T4],
+		Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T5],
+		Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T6],
+		Ap[func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T7],
+		Ap[func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T8],
+		Ap[func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T9],
+		Ap[func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T10],
+		Ap[func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T11],
+		Ap[T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T12],
+		t,
+	)
+}
+
+// TraverseTuple12 converts a [Tuple12] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple12]].
+func TraverseTuple12[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], F11 ~func(A11) Either[E, T11], F12 ~func(A12) Either[E, T12], E, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10, A11, T11, A12, T12 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[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Either[E, T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] {
+	return func(t T.Tuple12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Either[E, T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] {
+		return A.TraverseTuple12(
+			Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]],
+			Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T2],
+			Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T3],
+			Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T4],
+			Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T5],
+			Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T6],
+			Ap[func(T8) func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T7],
+			Ap[func(T9) func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T8],
+			Ap[func(T10) func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T9],
+			Ap[func(T11) func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T10],
+			Ap[func(T12) T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T11],
+			Ap[T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12], E, T12],
+			f1,
+			f2,
+			f3,
+			f4,
+			f5,
+			f6,
+			f7,
+			f8,
+			f9,
+			f10,
+			f11,
+			f12,
+			t,
+		)
+	}
+}
+
+// Eitherize13 converts a function with 13 parameters returning a tuple into a function with 13 parameters returning an Either
+// The inverse function is [Uneitherize13]
+func Eitherize13[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) Either[error, R] {
+	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10, t11 T11, t12 T12) Either[error, R] {
+		return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12))
+	}
+}
+
+// Uneitherize13 converts a function with 13 parameters returning an Either into a function with 13 parameters returning a tuple
+// The inverse function is [Eitherize13]
+func Uneitherize13[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) (R, error) {
+	return func(t0 T0, 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, error) {
+		return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12))
+	}
+}
+
+// SequenceT13 converts 13 parameters of [Either[E, T]] into a [Either[E, Tuple13]].
+func SequenceT13[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4], t5 Either[E, T5], t6 Either[E, T6], t7 Either[E, T7], t8 Either[E, T8], t9 Either[E, T9], t10 Either[E, T10], t11 Either[E, T11], t12 Either[E, T12], t13 Either[E, T13]) Either[E, T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] {
+	return A.SequenceT13(
+		Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]],
+		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T2],
+		Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T3],
+		Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T4],
+		Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T5],
+		Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T6],
+		Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T7],
+		Ap[func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T8],
+		Ap[func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T9],
+		Ap[func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T10],
+		Ap[func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T11],
+		Ap[func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T12],
+		Ap[T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T13],
+		t1,
+		t2,
+		t3,
+		t4,
+		t5,
+		t6,
+		t7,
+		t8,
+		t9,
+		t10,
+		t11,
+		t12,
+		t13,
+	)
+}
+
+// SequenceTuple13 converts a [Tuple13] of [Either[E, T]] into an [Either[E, Tuple13]].
+func SequenceTuple13[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](t T.Tuple13[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4], Either[E, T5], Either[E, T6], Either[E, T7], Either[E, T8], Either[E, T9], Either[E, T10], Either[E, T11], Either[E, T12], Either[E, T13]]) Either[E, T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] {
+	return A.SequenceTuple13(
+		Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]],
+		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T2],
+		Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T3],
+		Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T4],
+		Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T5],
+		Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T6],
+		Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T7],
+		Ap[func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T8],
+		Ap[func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T9],
+		Ap[func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T10],
+		Ap[func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T11],
+		Ap[func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T12],
+		Ap[T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T13],
+		t,
+	)
+}
+
+// TraverseTuple13 converts a [Tuple13] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple13]].
+func TraverseTuple13[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], F11 ~func(A11) Either[E, T11], F12 ~func(A12) Either[E, T12], F13 ~func(A13) Either[E, T13], E, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10, A11, T11, A12, T12, A13, T13 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[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Either[E, T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] {
+	return func(t T.Tuple13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Either[E, T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] {
+		return A.TraverseTuple13(
+			Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]],
+			Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T2],
+			Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T3],
+			Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T4],
+			Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T5],
+			Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T6],
+			Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T7],
+			Ap[func(T9) func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T8],
+			Ap[func(T10) func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T9],
+			Ap[func(T11) func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T10],
+			Ap[func(T12) func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T11],
+			Ap[func(T13) T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T12],
+			Ap[T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13], E, T13],
+			f1,
+			f2,
+			f3,
+			f4,
+			f5,
+			f6,
+			f7,
+			f8,
+			f9,
+			f10,
+			f11,
+			f12,
+			f13,
+			t,
+		)
+	}
+}
+
+// Eitherize14 converts a function with 14 parameters returning a tuple into a function with 14 parameters returning an Either
+// The inverse function is [Uneitherize14]
+func Eitherize14[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) Either[error, R] {
+	return func(t0 T0, 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) Either[error, R] {
+		return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13))
+	}
+}
+
+// Uneitherize14 converts a function with 14 parameters returning an Either into a function with 14 parameters returning a tuple
+// The inverse function is [Eitherize14]
+func Uneitherize14[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) (R, error) {
+	return func(t0 T0, 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, error) {
+		return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13))
+	}
+}
+
+// SequenceT14 converts 14 parameters of [Either[E, T]] into a [Either[E, Tuple14]].
+func SequenceT14[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4], t5 Either[E, T5], t6 Either[E, T6], t7 Either[E, T7], t8 Either[E, T8], t9 Either[E, T9], t10 Either[E, T10], t11 Either[E, T11], t12 Either[E, T12], t13 Either[E, T13], t14 Either[E, T14]) Either[E, T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] {
+	return A.SequenceT14(
+		Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]],
+		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T2],
+		Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T3],
+		Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T4],
+		Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T5],
+		Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T6],
+		Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T7],
+		Ap[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T8],
+		Ap[func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T9],
+		Ap[func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T10],
+		Ap[func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T11],
+		Ap[func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T12],
+		Ap[func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T13],
+		Ap[T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T14],
+		t1,
+		t2,
+		t3,
+		t4,
+		t5,
+		t6,
+		t7,
+		t8,
+		t9,
+		t10,
+		t11,
+		t12,
+		t13,
+		t14,
+	)
+}
+
+// SequenceTuple14 converts a [Tuple14] of [Either[E, T]] into an [Either[E, Tuple14]].
+func SequenceTuple14[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](t T.Tuple14[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4], Either[E, T5], Either[E, T6], Either[E, T7], Either[E, T8], Either[E, T9], Either[E, T10], Either[E, T11], Either[E, T12], Either[E, T13], Either[E, T14]]) Either[E, T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] {
+	return A.SequenceTuple14(
+		Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]],
+		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T2],
+		Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T3],
+		Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T4],
+		Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T5],
+		Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T6],
+		Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T7],
+		Ap[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T8],
+		Ap[func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T9],
+		Ap[func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T10],
+		Ap[func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T11],
+		Ap[func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T12],
+		Ap[func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T13],
+		Ap[T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T14],
+		t,
+	)
+}
+
+// TraverseTuple14 converts a [Tuple14] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple14]].
+func TraverseTuple14[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], F11 ~func(A11) Either[E, T11], F12 ~func(A12) Either[E, T12], F13 ~func(A13) Either[E, T13], F14 ~func(A14) Either[E, T14], E, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10, A11, T11, A12, T12, A13, T13, A14, T14 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[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Either[E, T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] {
+	return func(t T.Tuple14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Either[E, T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] {
+		return A.TraverseTuple14(
+			Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]],
+			Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T2],
+			Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T3],
+			Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T4],
+			Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T5],
+			Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T6],
+			Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T7],
+			Ap[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T8],
+			Ap[func(T10) func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T9],
+			Ap[func(T11) func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T10],
+			Ap[func(T12) func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T11],
+			Ap[func(T13) func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T12],
+			Ap[func(T14) T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T13],
+			Ap[T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14], E, T14],
+			f1,
+			f2,
+			f3,
+			f4,
+			f5,
+			f6,
+			f7,
+			f8,
+			f9,
+			f10,
+			f11,
+			f12,
+			f13,
+			f14,
+			t,
+		)
+	}
+}
+
+// Eitherize15 converts a function with 15 parameters returning a tuple into a function with 15 parameters returning an Either
+// The inverse function is [Uneitherize15]
+func Eitherize15[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) Either[error, R] {
+	return func(t0 T0, 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) Either[error, R] {
+		return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14))
+	}
+}
+
+// Uneitherize15 converts a function with 15 parameters returning an Either into a function with 15 parameters returning a tuple
+// The inverse function is [Eitherize15]
+func Uneitherize15[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) (R, error) {
+	return func(t0 T0, 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, error) {
+		return UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14))
+	}
+}
+
+// SequenceT15 converts 15 parameters of [Either[E, T]] into a [Either[E, Tuple15]].
+func SequenceT15[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](t1 Either[E, T1], t2 Either[E, T2], t3 Either[E, T3], t4 Either[E, T4], t5 Either[E, T5], t6 Either[E, T6], t7 Either[E, T7], t8 Either[E, T8], t9 Either[E, T9], t10 Either[E, T10], t11 Either[E, T11], t12 Either[E, T12], t13 Either[E, T13], t14 Either[E, T14], t15 Either[E, T15]) Either[E, T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] {
+	return A.SequenceT15(
+		Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]],
+		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T2],
+		Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T3],
+		Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T4],
+		Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T5],
+		Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T6],
+		Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T7],
+		Ap[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T8],
+		Ap[func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T9],
+		Ap[func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T10],
+		Ap[func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T11],
+		Ap[func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T12],
+		Ap[func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T13],
+		Ap[func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T14],
+		Ap[T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T15],
+		t1,
+		t2,
+		t3,
+		t4,
+		t5,
+		t6,
+		t7,
+		t8,
+		t9,
+		t10,
+		t11,
+		t12,
+		t13,
+		t14,
+		t15,
+	)
+}
+
+// SequenceTuple15 converts a [Tuple15] of [Either[E, T]] into an [Either[E, Tuple15]].
+func SequenceTuple15[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](t T.Tuple15[Either[E, T1], Either[E, T2], Either[E, T3], Either[E, T4], Either[E, T5], Either[E, T6], Either[E, T7], Either[E, T8], Either[E, T9], Either[E, T10], Either[E, T11], Either[E, T12], Either[E, T13], Either[E, T14], Either[E, T15]]) Either[E, T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] {
+	return A.SequenceTuple15(
+		Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]],
+		Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T2],
+		Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T3],
+		Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T4],
+		Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T5],
+		Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T6],
+		Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T7],
+		Ap[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T8],
+		Ap[func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T9],
+		Ap[func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T10],
+		Ap[func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T11],
+		Ap[func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T12],
+		Ap[func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T13],
+		Ap[func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T14],
+		Ap[T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T15],
+		t,
+	)
+}
+
+// TraverseTuple15 converts a [Tuple15] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple15]].
+func TraverseTuple15[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], F11 ~func(A11) Either[E, T11], F12 ~func(A12) Either[E, T12], F13 ~func(A13) Either[E, T13], F14 ~func(A14) Either[E, T14], F15 ~func(A15) Either[E, T15], E, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10, A11, T11, A12, T12, A13, T13, A14, T14, A15, T15 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[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Either[E, T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] {
+	return func(t T.Tuple15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Either[E, T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] {
+		return A.TraverseTuple15(
+			Map[E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]],
+			Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T2],
+			Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T3],
+			Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T4],
+			Ap[func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T5],
+			Ap[func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T6],
+			Ap[func(T8) func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T7],
+			Ap[func(T9) func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T8],
+			Ap[func(T10) func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T9],
+			Ap[func(T11) func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T10],
+			Ap[func(T12) func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T11],
+			Ap[func(T13) func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T12],
+			Ap[func(T14) func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T13],
+			Ap[func(T15) T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T14],
+			Ap[T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15], E, T15],
+			f1,
+			f2,
+			f3,
+			f4,
+			f5,
+			f6,
+			f7,
+			f8,
+			f9,
+			f10,
+			f11,
+			f12,
+			f13,
+			f14,
+			f15,
+			t,
+		)
+	}
+}
--- a/either/pointed.go
+++ b/either/pointed.go
@@ -0,0 +1,31 @@
+// Copyright (c) 2024 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 either
+
+import (
+	"github.com/IBM/fp-go/internal/pointed"
+)
+
+type eitherPointed[E, A any] struct{}
+
+func (o *eitherPointed[E, A]) Of(a A) Either[E, A] {
+	return Of[E, A](a)
+}
+
+// Pointed implements the pointedic operations for [Either]
+func Pointed[E, A any]() pointed.Pointed[A, Either[E, A]] {
+	return &eitherPointed[E, A]{}
+}
--- a/function/binds.go
+++ b/function/binds.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2024-01-31 21:45:01.6437619 +0100 CET m=+0.032758901
+// 2024-02-29 16:19:01.120389 +0100 CET m=+0.011216001

 package function

--- a/function/gen.go
+++ b/function/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2024-01-31 21:44:55.7538323 +0100 CET m=+0.013067701
+// 2024-02-29 16:18:53.6664566 +0100 CET m=+0.011085101

 package function

--- a/go.mod
+++ b/go.mod
@@ -3,15 +3,15 @@ module github.com/IBM/fp-go
 go 1.20

 require (
-	github.com/stretchr/testify v1.8.4
-	github.com/urfave/cli/v2 v2.27.1
+	github.com/stretchr/testify v1.11.1
+	github.com/urfave/cli/v2 v2.27.7
 )

 require (
-	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.7 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e // indirect
+	github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
--- a/go.sum
+++ b/go.sum
@@ -1,17 +1,33 @@
-github.com/cpuguy83/go-md2man/v2 v2.0.3 h1:qMCsGGgs+MAzDFyp9LpAe1Lqy/fY/qCovCm0qnXZOBM=
-github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4=
+github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cpuguy83/go-md2man/v2 v2.0.5 h1:ZtcqGrnekaHpVLArFSe4HK5DoKx1T0rq2DwVB0alcyc=
+github.com/cpuguy83/go-md2man/v2 v2.0.5/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cpuguy83/go-md2man/v2 v2.0.7 h1:zbFlGlXEAKlwXpmvle3d8Oe3YnkKIK4xSRTd3sHPnBo=
+github.com/cpuguy83/go-md2man/v2 v2.0.7/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/urfave/cli/v2 v2.27.1 h1:8xSQ6szndafKVRmfyeUMxkNUJQMjL1F2zmsZ+qHpfho=
-github.com/urfave/cli/v2 v2.27.1/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=
-github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e h1:+SOyEddqYF09QP7vr7CgJ1eti3pY9Fn3LHO1M1r/0sI=
-github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.0 h1:ib4sjIrwZKxE5u/Japgo/7SJV3PvgjGiRNAvTVGqQl8=
+github.com/stretchr/testify v1.11.0/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/urfave/cli/v2 v2.27.4 h1:o1owoI+02Eb+K107p27wEX9Bb8eqIoZCfLXloLUSWJ8=
+github.com/urfave/cli/v2 v2.27.4/go.mod h1:m4QzxcD2qpra4z7WhzEGn74WZLViBnMpb1ToCAKdGRQ=
+github.com/urfave/cli/v2 v2.27.5 h1:WoHEJLdsXr6dDWoJgMq/CboDmyY/8HMMH1fTECbih+w=
+github.com/urfave/cli/v2 v2.27.5/go.mod h1:3Sevf16NykTbInEnD0yKkjDAeZDS0A6bzhBH5hrMvTQ=
+github.com/urfave/cli/v2 v2.27.6 h1:VdRdS98FNhKZ8/Az8B7MTyGQmpIr36O1EHybx/LaZ4g=
+github.com/urfave/cli/v2 v2.27.6/go.mod h1:3Sevf16NykTbInEnD0yKkjDAeZDS0A6bzhBH5hrMvTQ=
+github.com/urfave/cli/v2 v2.27.7 h1:bH59vdhbjLv3LAvIu6gd0usJHgoTTPhCFib8qqOwXYU=
+github.com/urfave/cli/v2 v2.27.7/go.mod h1:CyNAG/xg+iAOg0N4MPGZqVmv2rCoP267496AOXUZjA4=
+github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4=
+github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
--- a/identity/gen.go
+++ b/identity/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:30:50.5492271 +0200 CEST m=+0.023274501
+// 2024-02-29 16:19:02.7798504 +0100 CET m=+0.021933401

 package identity

--- a/internal/apply/doc.go
+++ b/internal/apply/doc.go
@@ -15,4 +15,4 @@

 package apply

-//go:generate go run ../.. apply --count 10 --filename gen.go
+//go:generate go run ../.. apply --count 15 --filename gen.go
--- a/internal/apply/gen.go
+++ b/internal/apply/gen.go
--- a/internal/array/array.go
+++ b/internal/array/array.go
@@ -17,6 +17,37 @@ package array

 func Slice[GA ~[]A, A any](low, high int) func(as GA) GA {
 	return func(as GA) GA {
+		length := len(as)
+
+		// Handle negative indices - count backward from the end
+		if low < 0 {
+			low = length + low
+			if low < 0 {
+				low = 0
+			}
+		}
+		if high < 0 {
+			high = length + high
+			if high < 0 {
+				high = 0
+			}
+		}
+
+		// Start index > array length: return empty array
+		if low > length {
+			return Empty[GA, A]()
+		}
+
+		// End index > array length: slice to the end
+		if high > length {
+			high = length
+		}
+
+		// Start >= end: return empty array
+		if low >= high {
+			return Empty[GA, A]()
+		}
+
 		return as[low:high]
 	}
 }
--- a/internal/bracket/bracket.go
+++ b/internal/bracket/bracket.go
@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-package file
+package bracket

 import (
 	F "github.com/IBM/fp-go/function"
--- a/internal/testing/sequence.go
+++ b/internal/testing/sequence.go
@@ -0,0 +1,183 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package testing
+
+import (
+	"fmt"
+	"testing"
+
+	EQ "github.com/IBM/fp-go/eq"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/functor"
+	"github.com/IBM/fp-go/internal/pointed"
+	"github.com/stretchr/testify/assert"
+)
+
+// SequenceArrayTest tests if the sequence operation works in case the operation cannot error
+func SequenceArrayTest[
+	HKTA,
+	HKTB,
+	HKTAA any, // HKT[[]A]
+](
+	eq EQ.Eq[HKTB],
+
+	pa pointed.Pointed[string, HKTA],
+	pb pointed.Pointed[bool, HKTB],
+	faa functor.Functor[[]string, bool, HKTAA, HKTB],
+	seq func([]HKTA) HKTAA,
+) func(count int) func(t *testing.T) {
+
+	return func(count int) func(t *testing.T) {
+
+		exp := make([]string, count)
+		good := make([]HKTA, count)
+		for i := 0; i < count; i++ {
+			val := fmt.Sprintf("TestData %d", i)
+			exp[i] = val
+			good[i] = pa.Of(val)
+		}
+
+		return func(t *testing.T) {
+			res := F.Pipe2(
+				good,
+				seq,
+				faa.Map(func(act []string) bool {
+					return assert.Equal(t, exp, act)
+				}),
+			)
+			assert.True(t, eq.Equals(res, pb.Of(true)))
+		}
+	}
+}
+
+// SequenceArrayErrorTest tests if the sequence operation works in case the operation can error
+func SequenceArrayErrorTest[
+	HKTA,
+	HKTB,
+	HKTAA any, // HKT[[]A]
+](
+	eq EQ.Eq[HKTB],
+
+	left func(error) HKTA,
+	leftB func(error) HKTB,
+	pa pointed.Pointed[string, HKTA],
+	pb pointed.Pointed[bool, HKTB],
+	faa functor.Functor[[]string, bool, HKTAA, HKTB],
+	seq func([]HKTA) HKTAA,
+) func(count int) func(t *testing.T) {
+
+	return func(count int) func(t *testing.T) {
+
+		expGood := make([]string, count)
+		good := make([]HKTA, count)
+		expBad := make([]error, count)
+		bad := make([]HKTA, count)
+
+		for i := 0; i < count; i++ {
+			goodVal := fmt.Sprintf("TestData %d", i)
+			badVal := fmt.Errorf("ErrorData %d", i)
+			expGood[i] = goodVal
+			good[i] = pa.Of(goodVal)
+			expBad[i] = badVal
+			bad[i] = left(badVal)
+		}
+
+		total := 1 << count
+
+		return func(t *testing.T) {
+			// test the good case
+			res := F.Pipe2(
+				good,
+				seq,
+				faa.Map(func(act []string) bool {
+					return assert.Equal(t, expGood, act)
+				}),
+			)
+			assert.True(t, eq.Equals(res, pb.Of(true)))
+			// iterate and test the bad cases
+			for i := 1; i < total; i++ {
+				// run the test
+				t.Run(fmt.Sprintf("Bitmask test %d", i), func(t1 *testing.T) {
+					// the actual
+					act := make([]HKTA, count)
+					// the expected error
+					var exp error
+					// prepare the values bases on the bit mask
+					mask := 1
+					for j := 0; j < count; j++ {
+						if (i & mask) == 0 {
+							act[j] = good[j]
+						} else {
+							act[j] = bad[j]
+							if exp == nil {
+								exp = expBad[j]
+							}
+						}
+						mask <<= 1
+					}
+					// test the good case
+					res := F.Pipe2(
+						act,
+						seq,
+						faa.Map(func(act []string) bool {
+							return assert.Equal(t, expGood, act)
+						}),
+					)
+					// validate the error
+					assert.True(t, eq.Equals(res, leftB(exp)))
+				})
+			}
+		}
+	}
+}
+
+// SequenceRecordTest tests if the sequence operation works in case the operation cannot error
+func SequenceRecordTest[
+	HKTA,
+	HKTB,
+	HKTAA any, // HKT[map[string]string]
+](
+	eq EQ.Eq[HKTB],
+
+	pa pointed.Pointed[string, HKTA],
+	pb pointed.Pointed[bool, HKTB],
+	faa functor.Functor[map[string]string, bool, HKTAA, HKTB],
+	seq func(map[string]HKTA) HKTAA,
+) func(count int) func(t *testing.T) {
+
+	return func(count int) func(t *testing.T) {
+
+		exp := make(map[string]string)
+		good := make(map[string]HKTA)
+		for i := 0; i < count; i++ {
+			key := fmt.Sprintf("KeyData %d", i)
+			val := fmt.Sprintf("ValueData %d", i)
+			exp[key] = val
+			good[key] = pa.Of(val)
+		}
+
+		return func(t *testing.T) {
+			res := F.Pipe2(
+				good,
+				seq,
+				faa.Map(func(act map[string]string) bool {
+					return assert.Equal(t, exp, act)
+				}),
+			)
+			assert.True(t, eq.Equals(res, pb.Of(true)))
+		}
+	}
+}
--- a/io/eq.go
+++ b/io/eq.go
@@ -24,3 +24,8 @@ import (
 func Eq[A any](e EQ.Eq[A]) EQ.Eq[IO[A]] {
 	return G.Eq[IO[A]](e)
 }
+
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[A comparable]() EQ.Eq[IO[A]] {
+	return G.FromStrictEquals[IO[A]]()
+}
--- a/io/functor.go
+++ b/io/functor.go
@@ -0,0 +1,26 @@
+// Copyright (c) 2024 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 io
+
+import (
+	"github.com/IBM/fp-go/internal/functor"
+	G "github.com/IBM/fp-go/io/generic"
+)
+
+// Functor returns the monadic operations for [IO]
+func Functor[A, B any]() functor.Functor[A, B, IO[A], IO[B]] {
+	return G.Functor[A, B, IO[A], IO[B]]()
+}
--- a/io/gen.go
+++ b/io/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:30:56.7105551 +0200 CEST m=+0.011255201
+// 2024-02-29 16:19:10.2607969 +0100 CET m=+0.024787801

 package io

--- a/io/generic/eq.go
+++ b/io/generic/eq.go
@@ -33,3 +33,8 @@ func Eq[GA ~func() A, A any](e EQ.Eq[A]) EQ.Eq[GA] {
 		return eq(l, r)()
 	})
 }
+
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[GA ~func() A, A comparable]() EQ.Eq[GA] {
+	return Eq[GA](EQ.FromStrictEquals[A]())
+}
--- a/io/generic/functor.go
+++ b/io/generic/functor.go
@@ -0,0 +1,31 @@
+// Copyright (c) 2024 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 (
+	"github.com/IBM/fp-go/internal/functor"
+)
+
+type ioFunctor[A, B any, GA ~func() A, GB ~func() B] struct{}
+
+func (o *ioFunctor[A, B, GA, GB]) Map(f func(A) B) func(GA) GB {
+	return Map[GA, GB, A, B](f)
+}
+
+// Functor implements the functoric operations for [IO]
+func Functor[A, B any, GA ~func() A, GB ~func() B]() functor.Functor[A, B, GA, GB] {
+	return &ioFunctor[A, B, GA, GB]{}
+}
--- a/io/generic/gen.go
+++ b/io/generic/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:30:56.7105551 +0200 CEST m=+0.011255201
+// 2024-02-29 16:19:10.2613281 +0100 CET m=+0.025319001
 package generic

 import (
--- a/io/generic/pointed.go
+++ b/io/generic/pointed.go
@@ -0,0 +1,31 @@
+// Copyright (c) 2024 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 (
+	"github.com/IBM/fp-go/internal/pointed"
+)
+
+type ioPointed[A any, GA ~func() A] struct{}
+
+func (o *ioPointed[A, GA]) Of(a A) GA {
+	return Of[GA, A](a)
+}
+
+// Pointed implements the pointedic operations for [IO]
+func Pointed[A any, GA ~func() A]() pointed.Pointed[A, GA] {
+	return &ioPointed[A, GA]{}
+}
--- a/io/pointed.go
+++ b/io/pointed.go
@@ -0,0 +1,26 @@
+// Copyright (c) 2024 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 io
+
+import (
+	"github.com/IBM/fp-go/internal/pointed"
+	G "github.com/IBM/fp-go/io/generic"
+)
+
+// Pointed returns the monadic operations for [IO]
+func Pointed[A any]() pointed.Pointed[A, IO[A]] {
+	return G.Pointed[A, IO[A]]()
+}
--- a/io/sequence_test.go
+++ b/io/sequence_test.go
@@ -16,8 +16,11 @@
 package io

 import (
+	"fmt"
+
 	A "github.com/IBM/fp-go/array"
 	F "github.com/IBM/fp-go/function"
+	TST "github.com/IBM/fp-go/internal/testing"
 	"github.com/stretchr/testify/assert"

 	"testing"
@@ -45,3 +48,18 @@ func TestMapSeq(t *testing.T) {

 	assert.True(t, res())
 }
+
+func TestSequenceArray(t *testing.T) {
+
+	s := TST.SequenceArrayTest(
+		FromStrictEquals[bool](),
+		Pointed[string](),
+		Pointed[bool](),
+		Functor[[]string, bool](),
+		SequenceArray[string],
+	)
+
+	for i := 0; i < 10; i++ {
+		t.Run(fmt.Sprintf("TestSequenceArray %d", i), s(i))
+	}
+}
--- a/ioeither/gen.go
+++ b/ioeither/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:30:58.6457744 +0200 CEST m=+0.080336501
+// 2024-02-29 16:19:13.144922 +0100 CET m=+0.065757301

 package ioeither

--- a/ioeither/generic/gen.go
+++ b/ioeither/generic/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:30:58.6556525 +0200 CEST m=+0.090214601
+// 2024-02-29 16:19:13.1643755 +0100 CET m=+0.085210801
 package generic

 import (
--- a/ioeither/generic/monad.go
+++ b/ioeither/generic/monad.go
@@ -17,6 +17,7 @@ package generic

 import (
 	ET "github.com/IBM/fp-go/either"
+	"github.com/IBM/fp-go/internal/functor"
 	"github.com/IBM/fp-go/internal/monad"
 	"github.com/IBM/fp-go/internal/pointed"
 )
@@ -25,6 +26,8 @@ type ioEitherPointed[E, A any, GA ~func() ET.Either[E, A]] struct{}

 type ioEitherMonad[E, A, B any, GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B]] struct{}

+type ioEitherFunctor[E, A, B any, GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B]] struct{}
+
 func (o *ioEitherPointed[E, A, GA]) Of(a A) GA {
 	return Of[GA, E, A](a)
 }
@@ -45,11 +48,20 @@ func (o *ioEitherMonad[E, A, B, GA, GB, GAB]) Ap(fa GA) func(GAB) GB {
 	return Ap[GB, GAB, GA, E, A, B](fa)
 }

+func (o *ioEitherFunctor[E, A, B, GA, GB]) Map(f func(A) B) func(GA) GB {
+	return Map[GA, GB, E, A, B](f)
+}
+
 // Pointed implements the pointed operations for [IOEither]
 func Pointed[E, A any, GA ~func() ET.Either[E, A]]() pointed.Pointed[A, GA] {
 	return &ioEitherPointed[E, A, GA]{}
 }

+// Functor implements the monadic operations for [IOEither]
+func Functor[E, A, B any, GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B]]() functor.Functor[A, B, GA, GB] {
+	return &ioEitherFunctor[E, A, B, GA, GB]{}
+}
+
 // Monad implements the monadic operations for [IOEither]
 func Monad[E, A, B any, GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B]]() monad.Monad[A, B, GA, GB, GAB] {
 	return &ioEitherMonad[E, A, B, GA, GB, GAB]{}
--- a/ioeither/monad.go
+++ b/ioeither/monad.go
@@ -16,6 +16,7 @@
 package ioeither

 import (
+	"github.com/IBM/fp-go/internal/functor"
 	"github.com/IBM/fp-go/internal/monad"
 	"github.com/IBM/fp-go/internal/pointed"
 	G "github.com/IBM/fp-go/ioeither/generic"
@@ -26,6 +27,11 @@ func Pointed[E, A any]() pointed.Pointed[A, IOEither[E, A]] {
 	return G.Pointed[E, A, IOEither[E, A]]()
 }

+// Functor returns the functor operations for [IOEither]
+func Functor[E, A, B any]() functor.Functor[A, B, IOEither[E, A], IOEither[E, B]] {
+	return G.Functor[E, A, B, IOEither[E, A], IOEither[E, B]]()
+}
+
 // Monad returns the monadic operations for [IOEither]
 func Monad[E, A, B any]() monad.Monad[A, B, IOEither[E, A], IOEither[E, B], IOEither[E, func(A) B]] {
 	return G.Monad[E, A, B, IOEither[E, A], IOEither[E, B], IOEither[E, func(A) B]]()
--- a/ioeither/sequence_test.go
+++ b/ioeither/sequence_test.go
@@ -16,11 +16,15 @@
 package ioeither

 import (
+	"fmt"
+
 	A "github.com/IBM/fp-go/array"
 	E "github.com/IBM/fp-go/either"
 	F "github.com/IBM/fp-go/function"
 	"github.com/stretchr/testify/assert"

+	TST "github.com/IBM/fp-go/internal/testing"
+
 	"testing"
 )

@@ -46,3 +50,33 @@ func TestMapSeq(t *testing.T) {

 	assert.Equal(t, E.Of[error](true), res())
 }
+
+func TestSequenceArray(t *testing.T) {
+
+	s := TST.SequenceArrayTest(
+		FromStrictEquals[error, bool](),
+		Pointed[error, string](),
+		Pointed[error, bool](),
+		Functor[error, []string, bool](),
+		SequenceArray[error, string],
+	)
+
+	for i := 0; i < 10; i++ {
+		t.Run(fmt.Sprintf("TestSequenceArray %d", i), s(i))
+	}
+}
+
+func TestSequenceArrayError(t *testing.T) {
+
+	s := TST.SequenceArrayErrorTest(
+		FromStrictEquals[error, bool](),
+		Left[string, error],
+		Left[bool, error],
+		Pointed[error, string](),
+		Pointed[error, bool](),
+		Functor[error, []string, bool](),
+		SequenceArray[error, string],
+	)
+	// run across four bits
+	s(4)(t)
+}
--- a/iooption/gen.go
+++ b/iooption/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:31:01.9227118 +0200 CEST m=+0.009977901
+// 2024-02-29 16:19:16.7939127 +0100 CET m=+0.053853301

 package iooption

--- a/iooption/generic/gen.go
+++ b/iooption/generic/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:31:01.9227118 +0200 CEST m=+0.009977901
+// 2024-02-29 16:19:16.8032769 +0100 CET m=+0.063217501
 package generic

 import (
--- a/iterator/stateless/cycle.go
+++ b/iterator/stateless/cycle.go
@@ -19,8 +19,7 @@ import (
 	G "github.com/IBM/fp-go/iterator/stateless/generic"
 )

-// DropWhile creates an [Iterator] that drops elements from the [Iterator] as long as the predicate is true; afterwards, returns every element.
-// Note, the [Iterator] does not produce any output until the predicate first becomes false
+// Cycle creates an [Iterator] containing an [Iterator] repeated an infinite number of times.
 func Cycle[U any](ma Iterator[U]) Iterator[U] {
 	return G.Cycle[Iterator[U]](ma)
 }
--- a/option/array_test.go
+++ b/option/array_test.go
@@ -16,25 +16,13 @@
 package option

 import (
+	"fmt"
 	"testing"

-	F "github.com/IBM/fp-go/function"
+	TST "github.com/IBM/fp-go/internal/testing"
 	"github.com/stretchr/testify/assert"
 )

-func TestSequenceArray(t *testing.T) {
-
-	one := Of(1)
-	two := Of(2)
-
-	res := F.Pipe1(
-		[]Option[int]{one, two},
-		SequenceArray[int],
-	)
-
-	assert.Equal(t, res, Of([]int{1, 2}))
-}
-
 func TestCompactArray(t *testing.T) {
 	ar := []Option[string]{
 		Of("ok"),
@@ -45,3 +33,18 @@ func TestCompactArray(t *testing.T) {
 	res := CompactArray(ar)
 	assert.Equal(t, 2, len(res))
 }
+
+func TestSequenceArray(t *testing.T) {
+
+	s := TST.SequenceArrayTest(
+		FromStrictEquals[bool](),
+		Pointed[string](),
+		Pointed[bool](),
+		Functor[[]string, bool](),
+		SequenceArray[string],
+	)
+
+	for i := 0; i < 10; i++ {
+		t.Run(fmt.Sprintf("TestSequenceArray %d", i), s(i))
+	}
+}
--- a/option/core.go
+++ b/option/core.go
@@ -35,7 +35,7 @@ type Option[A any] struct {

 // optString prints some debug info for the object
 //
-// go:noinline
+//go:noinline
 func optString(isSome bool, value any) string {
 	if isSome {
 		return fmt.Sprintf("Some[%T](%v)", value, value)
@@ -45,7 +45,7 @@ func optString(isSome bool, value any) string {

 // optFormat prints some debug info for the object
 //
-// go:noinline
+//go:noinline
 func optFormat(isSome bool, value any, f fmt.State, c rune) {
 	switch c {
 	case 's':
@@ -78,7 +78,7 @@ func (s Option[A]) MarshalJSON() ([]byte, error) {

 // optUnmarshalJSON unmarshals the [Option] from a JSON string
 //
-// go:noinline
+//go:noinline
 func optUnmarshalJSON(isSome *bool, value any, data []byte) error {
 	// decode the value
 	if bytes.Equal(data, jsonNull) {
--- a/option/functor.go
+++ b/option/functor.go
@@ -0,0 +1,31 @@
+// Copyright (c) 2024 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 (
+	"github.com/IBM/fp-go/internal/functor"
+)
+
+type optionFunctor[A, B any] struct{}
+
+func (o *optionFunctor[A, B]) Map(f func(A) B) func(Option[A]) Option[B] {
+	return Map[A, B](f)
+}
+
+// Functor implements the functoric operations for [Option]
+func Functor[A, B any]() functor.Functor[A, B, Option[A], Option[B]] {
+	return &optionFunctor[A, B]{}
+}
--- a/option/gen.go
+++ b/option/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:31:07.8687134 +0200 CEST m=+0.012222901
+// 2024-02-29 16:19:19.6336283 +0100 CET m=+0.018011101

 package option

--- a/option/pointed.go
+++ b/option/pointed.go
@@ -0,0 +1,31 @@
+// Copyright (c) 2024 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 (
+	"github.com/IBM/fp-go/internal/pointed"
+)
+
+type optionPointed[A any] struct{}
+
+func (o *optionPointed[A]) Of(a A) Option[A] {
+	return Of[A](a)
+}
+
+// Pointed implements the Pointed operations for [Option]
+func Pointed[A any]() pointed.Pointed[A, Option[A]] {
+	return &optionPointed[A]{}
+}
--- a/option/record_test.go
+++ b/option/record_test.go
@@ -16,21 +16,13 @@
 package option

 import (
+	"fmt"
 	"testing"

+	TST "github.com/IBM/fp-go/internal/testing"
 	"github.com/stretchr/testify/assert"
 )

-func TestSequenceRecord(t *testing.T) {
-	assert.Equal(t, Of(map[string]string{
-		"a": "A",
-		"b": "B",
-	}), SequenceRecord(map[string]Option[string]{
-		"a": Of("A"),
-		"b": Of("B"),
-	}))
-}
-
 func TestCompactRecord(t *testing.T) {
 	// make the map
 	m := make(map[string]Option[int])
@@ -45,3 +37,18 @@ func TestCompactRecord(t *testing.T) {

 	assert.Equal(t, exp, m1)
 }
+
+func TestSequenceRecord(t *testing.T) {
+
+	s := TST.SequenceRecordTest(
+		FromStrictEquals[bool](),
+		Pointed[string](),
+		Pointed[bool](),
+		Functor[map[string]string, bool](),
+		SequenceRecord[string, string],
+	)
+
+	for i := 0; i < 10; i++ {
+		t.Run(fmt.Sprintf("TestSequenceRecord %d", i), s(i))
+	}
+}
--- a/ord/ord.go
+++ b/ord/ord.go
@@ -64,7 +64,7 @@ func Reverse[T any](o Ord[T]) Ord[T] {
 	}, o.Equals)
 }

-// Contramap creates an odering under a transformation function
+// Contramap creates an ordering under a transformation function
 func Contramap[A, B any](f func(B) A) func(Ord[A]) Ord[B] {
 	return func(o Ord[A]) Ord[B] {
 		return MakeOrd(func(x, y B) int {
--- a/pair/pair.go
+++ b/pair/pair.go
@@ -34,14 +34,14 @@ type (

 // String prints some debug info for the object
 //
-// go:noinline
+//go:noinline
 func pairString(s *pair) string {
-	return fmt.Sprintf("Pair[%T, %t](%v, %v)", s.h, s.t, s.h, s.t)
+	return fmt.Sprintf("Pair[%T, %T](%v, %v)", s.h, s.t, s.h, s.t)
 }

 // Format prints some debug info for the object
 //
-// go:noinline
+//go:noinline
 func pairFormat(e *pair, f fmt.State, c rune) {
 	switch c {
 	case 's':
--- a/reader/gen.go
+++ b/reader/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:31:13.0131834 +0200 CEST m=+0.010996501
+// 2024-02-29 16:19:26.0521202 +0100 CET m=+0.018000401

 package reader

--- a/reader/generic/gen.go
+++ b/reader/generic/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:31:13.0131834 +0200 CEST m=+0.010996501
+// 2024-02-29 16:19:26.0521202 +0100 CET m=+0.018000401
 package generic

 // From0 converts a function with 1 parameters returning a [R] into a function with 0 parameters returning a [GRA]
--- a/readerioeither/array_test.go
+++ b/readerioeither/array_test.go
@@ -17,11 +17,13 @@ package readerioeither

 import (
 	"context"
+	"fmt"
 	"testing"

 	A "github.com/IBM/fp-go/array"
 	ET "github.com/IBM/fp-go/either"
 	F "github.com/IBM/fp-go/function"
+	TST "github.com/IBM/fp-go/internal/testing"
 	"github.com/stretchr/testify/assert"
 )

@@ -37,3 +39,33 @@ func TestTraverseArray(t *testing.T) {
 	assert.Equal(t, ET.Right[string]([]string{"aa", "bb"}), F.Pipe1([]string{"a", "b"}, f)(ctx)())
 	assert.Equal(t, ET.Left[[]string]("e"), F.Pipe1([]string{"a", ""}, f)(ctx)())
 }
+
+func TestSequenceArray(t *testing.T) {
+
+	s := TST.SequenceArrayTest(
+		FromStrictEquals[context.Context, error, bool]()(context.Background()),
+		Pointed[context.Context, error, string](),
+		Pointed[context.Context, error, bool](),
+		Functor[context.Context, error, []string, bool](),
+		SequenceArray[context.Context, error, string],
+	)
+
+	for i := 0; i < 10; i++ {
+		t.Run(fmt.Sprintf("TestSequenceArray %d", i), s(i))
+	}
+}
+
+func TestSequenceArrayError(t *testing.T) {
+
+	s := TST.SequenceArrayErrorTest(
+		FromStrictEquals[context.Context, error, bool]()(context.Background()),
+		Left[context.Context, string, error],
+		Left[context.Context, bool, error],
+		Pointed[context.Context, error, string](),
+		Pointed[context.Context, error, bool](),
+		Functor[context.Context, error, []string, bool](),
+		SequenceArray[context.Context, error, string],
+	)
+	// run across four bits
+	s(4)(t)
+}
--- a/readerioeither/gen.go
+++ b/readerioeither/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:31:16.2414489 +0200 CEST m=+0.013052301
+// 2024-05-24 17:26:07.2835624 +0200 CEST m=+0.011499301

 package readerioeither

@@ -20,6 +20,12 @@ func Eitherize0[F ~func(C) (R, error), C, R any](f F) func() ReaderIOEither[C, e
 	return G.Eitherize0[ReaderIOEither[C, error, R]](f)
 }

+// Uneitherize0 converts a function with 1 parameters returning a [ReaderIOEither[C, error, R]] into a function with 0 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize0[F ~func() ReaderIOEither[C, error, R], C, R any](f F) func(C) (R, error) {
+	return G.Uneitherize0[ReaderIOEither[C, error, R], func(C) (R, error)](f)
+}
+
 // From1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From1[F ~func(C, T0) func() (R, error), T0, C, R any](f F) func(T0) ReaderIOEither[C, error, R] {
@@ -32,6 +38,12 @@ func Eitherize1[F ~func(C, T0) (R, error), T0, C, R any](f F) func(T0) ReaderIOE
 	return G.Eitherize1[ReaderIOEither[C, error, R]](f)
 }

+// Uneitherize1 converts a function with 2 parameters returning a [ReaderIOEither[C, error, R]] into a function with 1 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize1[F ~func(T0) ReaderIOEither[C, error, R], T0, C, R any](f F) func(C, T0) (R, error) {
+	return G.Uneitherize1[ReaderIOEither[C, error, R], func(C, T0) (R, error)](f)
+}
+
 // From2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From2[F ~func(C, T0, T1) func() (R, error), T0, T1, C, R any](f F) func(T0, T1) ReaderIOEither[C, error, R] {
@@ -44,6 +56,12 @@ func Eitherize2[F ~func(C, T0, T1) (R, error), T0, T1, C, R any](f F) func(T0, T
 	return G.Eitherize2[ReaderIOEither[C, error, R]](f)
 }

+// Uneitherize2 converts a function with 3 parameters returning a [ReaderIOEither[C, error, R]] into a function with 2 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize2[F ~func(T0, T1) ReaderIOEither[C, error, R], T0, T1, C, R any](f F) func(C, T0, T1) (R, error) {
+	return G.Uneitherize2[ReaderIOEither[C, error, R], func(C, T0, T1) (R, error)](f)
+}
+
 // From3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From3[F ~func(C, T0, T1, T2) func() (R, error), T0, T1, T2, C, R any](f F) func(T0, T1, T2) ReaderIOEither[C, error, R] {
@@ -56,6 +74,12 @@ func Eitherize3[F ~func(C, T0, T1, T2) (R, error), T0, T1, T2, C, R any](f F) fu
 	return G.Eitherize3[ReaderIOEither[C, error, R]](f)
 }

+// Uneitherize3 converts a function with 4 parameters returning a [ReaderIOEither[C, error, R]] into a function with 3 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize3[F ~func(T0, T1, T2) ReaderIOEither[C, error, R], T0, T1, T2, C, R any](f F) func(C, T0, T1, T2) (R, error) {
+	return G.Uneitherize3[ReaderIOEither[C, error, R], func(C, T0, T1, T2) (R, error)](f)
+}
+
 // From4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From4[F ~func(C, T0, T1, T2, T3) func() (R, error), T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) ReaderIOEither[C, error, R] {
@@ -68,6 +92,12 @@ func Eitherize4[F ~func(C, T0, T1, T2, T3) (R, error), T0, T1, T2, T3, C, R any]
 	return G.Eitherize4[ReaderIOEither[C, error, R]](f)
 }

+// Uneitherize4 converts a function with 5 parameters returning a [ReaderIOEither[C, error, R]] into a function with 4 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize4[F ~func(T0, T1, T2, T3) ReaderIOEither[C, error, R], T0, T1, T2, T3, C, R any](f F) func(C, T0, T1, T2, T3) (R, error) {
+	return G.Uneitherize4[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3) (R, error)](f)
+}
+
 // From5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From5[F ~func(C, T0, T1, T2, T3, T4) func() (R, error), T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) ReaderIOEither[C, error, R] {
@@ -80,6 +110,12 @@ func Eitherize5[F ~func(C, T0, T1, T2, T3, T4) (R, error), T0, T1, T2, T3, T4, C
 	return G.Eitherize5[ReaderIOEither[C, error, R]](f)
 }

+// Uneitherize5 converts a function with 6 parameters returning a [ReaderIOEither[C, error, R]] into a function with 5 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize5[F ~func(T0, T1, T2, T3, T4) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, C, R any](f F) func(C, T0, T1, T2, T3, T4) (R, error) {
+	return G.Uneitherize5[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4) (R, error)](f)
+}
+
 // From6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From6[F ~func(C, T0, T1, T2, T3, T4, T5) func() (R, error), T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) ReaderIOEither[C, error, R] {
@@ -92,6 +128,12 @@ func Eitherize6[F ~func(C, T0, T1, T2, T3, T4, T5) (R, error), T0, T1, T2, T3, T
 	return G.Eitherize6[ReaderIOEither[C, error, R]](f)
 }

+// Uneitherize6 converts a function with 7 parameters returning a [ReaderIOEither[C, error, R]] into a function with 6 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize6[F ~func(T0, T1, T2, T3, T4, T5) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5) (R, error) {
+	return G.Uneitherize6[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5) (R, error)](f)
+}
+
 // From7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From7[F ~func(C, T0, T1, T2, T3, T4, T5, T6) func() (R, error), T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) ReaderIOEither[C, error, R] {
@@ -104,6 +146,12 @@ func Eitherize7[F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R, error), T0, T1, T2, T
 	return G.Eitherize7[ReaderIOEither[C, error, R]](f)
 }

+// Uneitherize7 converts a function with 8 parameters returning a [ReaderIOEither[C, error, R]] into a function with 7 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize7[F ~func(T0, T1, T2, T3, T4, T5, T6) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5, T6) (R, error) {
+	return G.Uneitherize7[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6) (R, error)](f)
+}
+
 // From8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From8[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) func() (R, error), T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) ReaderIOEither[C, error, R] {
@@ -116,6 +164,12 @@ func Eitherize8[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), T0, T1, T
 	return G.Eitherize8[ReaderIOEither[C, error, R]](f)
 }

+// Uneitherize8 converts a function with 9 parameters returning a [ReaderIOEither[C, error, R]] into a function with 8 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error) {
+	return G.Uneitherize8[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error)](f)
+}
+
 // From9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From9[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) func() (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) ReaderIOEither[C, error, R] {
@@ -128,6 +182,12 @@ func Eitherize9[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), T0, T
 	return G.Eitherize9[ReaderIOEither[C, error, R]](f)
 }

+// Uneitherize9 converts a function with 10 parameters returning a [ReaderIOEither[C, error, R]] into a function with 9 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error) {
+	return G.Uneitherize9[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error)](f)
+}
+
 // From10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From10[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) func() (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[C, error, R] {
@@ -139,3 +199,9 @@ func From10[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) func() (R, error)
 func Eitherize10[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[C, error, R] {
 	return G.Eitherize10[ReaderIOEither[C, error, R]](f)
 }
+
+// Uneitherize10 converts a function with 11 parameters returning a [ReaderIOEither[C, error, R]] into a function with 10 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error) {
+	return G.Uneitherize10[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error)](f)
+}
--- a/readerioeither/generic/gen.go
+++ b/readerioeither/generic/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-10-23 08:31:16.241979 +0200 CEST m=+0.013582401
+// 2024-05-24 17:26:07.2835624 +0200 CEST m=+0.011499301
 package generic

 import (
@@ -26,6 +26,14 @@ func Eitherize0[GRA ~func(C) GIOA, F ~func(C) (R, error), GIOA ~func() E.Either[
 	})
 }

+// Uneitherize0 converts a function with 0 parameters returning a [GRA] into a function with 0 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize0[GRA ~func(C) GIOA, F ~func(C) (R, error), GIOA ~func() E.Either[error, R], C, R any](f func() GRA) F {
+	return func(c C) (R, error) {
+		return E.UnwrapError(f()(c)())
+	}
+}
+
 // From1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From1[GRA ~func(C) GIOA, F ~func(C, T0) func() (R, error), GIOA ~func() E.Either[error, R], T0, C, R any](f F) func(T0) GRA {
@@ -44,6 +52,14 @@ func Eitherize1[GRA ~func(C) GIOA, F ~func(C, T0) (R, error), GIOA ~func() E.Eit
 	})
 }

+// Uneitherize1 converts a function with 1 parameters returning a [GRA] into a function with 1 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize1[GRA ~func(C) GIOA, F ~func(C, T0) (R, error), GIOA ~func() E.Either[error, R], T0, C, R any](f func(T0) GRA) F {
+	return func(c C, t0 T0) (R, error) {
+		return E.UnwrapError(f(t0)(c)())
+	}
+}
+
 // From2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From2[GRA ~func(C) GIOA, F ~func(C, T0, T1) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, C, R any](f F) func(T0, T1) GRA {
@@ -62,6 +78,14 @@ func Eitherize2[GRA ~func(C) GIOA, F ~func(C, T0, T1) (R, error), GIOA ~func() E
 	})
 }

+// Uneitherize2 converts a function with 2 parameters returning a [GRA] into a function with 2 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize2[GRA ~func(C) GIOA, F ~func(C, T0, T1) (R, error), GIOA ~func() E.Either[error, R], T0, T1, C, R any](f func(T0, T1) GRA) F {
+	return func(c C, t0 T0, t1 T1) (R, error) {
+		return E.UnwrapError(f(t0, t1)(c)())
+	}
+}
+
 // From3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From3[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, C, R any](f F) func(T0, T1, T2) GRA {
@@ -80,6 +104,14 @@ func Eitherize3[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2) (R, error), GIOA ~func
 	})
 }

+// Uneitherize3 converts a function with 3 parameters returning a [GRA] into a function with 3 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize3[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, C, R any](f func(T0, T1, T2) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2)(c)())
+	}
+}
+
 // From4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From4[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) GRA {
@@ -98,6 +130,14 @@ func Eitherize4[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3) (R, error), GIOA ~
 	})
 }

+// Uneitherize4 converts a function with 4 parameters returning a [GRA] into a function with 4 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize4[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, C, R any](f func(T0, T1, T2, T3) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3)(c)())
+	}
+}
+
 // From5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From5[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) GRA {
@@ -116,6 +156,14 @@ func Eitherize5[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4) (R, error), GI
 	})
 }

+// Uneitherize5 converts a function with 5 parameters returning a [GRA] into a function with 5 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize5[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, C, R any](f func(T0, T1, T2, T3, T4) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4)(c)())
+	}
+}
+
 // From6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From6[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) GRA {
@@ -134,6 +182,14 @@ func Eitherize6[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5) (R, error)
 	})
 }

+// Uneitherize6 converts a function with 6 parameters returning a [GRA] into a function with 6 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize6[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, C, R any](f func(T0, T1, T2, T3, T4, T5) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5)(c)())
+	}
+}
+
 // From7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From7[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) GRA {
@@ -152,6 +208,14 @@ func Eitherize7[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R, er
 	})
 }

+// Uneitherize7 converts a function with 7 parameters returning a [GRA] into a function with 7 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize7[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, C, R any](f func(T0, T1, T2, T3, T4, T5, T6) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6)(c)())
+	}
+}
+
 // From8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From8[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) GRA {
@@ -170,6 +234,14 @@ func Eitherize8[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R
 	})
 }

+// Uneitherize8 converts a function with 8 parameters returning a [GRA] into a function with 8 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize8[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7)(c)())
+	}
+}
+
 // From9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From9[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA {
@@ -188,6 +260,14 @@ func Eitherize9[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8
 	})
 }

+// Uneitherize9 converts a function with 9 parameters returning a [GRA] into a function with 9 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize9[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8)(c)())
+	}
+}
+
 // From10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From10[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA {
@@ -205,3 +285,11 @@ func Eitherize10[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T
 		}
 	})
 }
+
+// Uneitherize10 converts a function with 10 parameters returning a [GRA] into a function with 10 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize10[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)(c)())
+	}
+}
--- a/readerioeither/generic/monad.go
+++ b/readerioeither/generic/monad.go
@@ -0,0 +1,68 @@
+// Copyright (c) 2024 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 (
+	ET "github.com/IBM/fp-go/either"
+	"github.com/IBM/fp-go/internal/functor"
+	"github.com/IBM/fp-go/internal/monad"
+	"github.com/IBM/fp-go/internal/pointed"
+)
+
+type readerIOEitherPointed[R, E, A any, GRA ~func(R) GIOA, GIOA ~func() ET.Either[E, A]] struct{}
+
+type readerIOEitherMonad[R, E, A, B any, GRA ~func(R) GIOA, GRB ~func(R) GIOB, GRAB ~func(R) GIOAB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], GIOAB ~func() ET.Either[E, func(A) B]] struct{}
+
+type readerIOEitherFunctor[R, E, A, B any, GRA ~func(R) GIOA, GRB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B]] struct{}
+
+func (o *readerIOEitherPointed[R, E, A, GRA, GIOA]) Of(a A) GRA {
+	return Of[GRA, GIOA, R, E, A](a)
+}
+
+func (o *readerIOEitherMonad[R, E, A, B, GRA, GRB, GRAB, GIOA, GIOB, GIOAB]) Of(a A) GRA {
+	return Of[GRA, GIOA, R, E, A](a)
+}
+
+func (o *readerIOEitherMonad[R, E, A, B, GRA, GRB, GRAB, GIOA, GIOB, GIOAB]) Map(f func(A) B) func(GRA) GRB {
+	return Map[GRA, GRB, GIOA, GIOB, R, E, A, B](f)
+}
+
+func (o *readerIOEitherMonad[R, E, A, B, GRA, GRB, GRAB, GIOA, GIOB, GIOAB]) Chain(f func(A) GRB) func(GRA) GRB {
+	return Chain[GRA, GRB, GIOA, GIOB, R, E, A, B](f)
+}
+
+func (o *readerIOEitherMonad[R, E, A, B, GRA, GRB, GRAB, GIOA, GIOB, GIOAB]) Ap(fa GRA) func(GRAB) GRB {
+	return Ap[GRA, GRB, GRAB, GIOA, GIOB, GIOAB, R, E, A, B](fa)
+}
+
+func (o *readerIOEitherFunctor[R, E, A, B, GRA, GRB, GIOA, GIOB]) Map(f func(A) B) func(GRA) GRB {
+	return Map[GRA, GRB, GIOA, GIOB, R, E, A, B](f)
+}
+
+// Pointed implements the pointed operations for [ReaderIOEither]
+func Pointed[R, E, A any, GRA ~func(R) GIOA, GIOA ~func() ET.Either[E, A]]() pointed.Pointed[A, GRA] {
+	return &readerIOEitherPointed[R, E, A, GRA, GIOA]{}
+}
+
+// Functor implements the monadic operations for [ReaderIOEither]
+func Functor[R, E, A, B any, GRA ~func(R) GIOA, GRB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B]]() functor.Functor[A, B, GRA, GRB] {
+	return &readerIOEitherFunctor[R, E, A, B, GRA, GRB, GIOA, GIOB]{}
+}
+
+// Monad implements the monadic operations for [ReaderIOEither]
+func Monad[R, E, A, B any, GRA ~func(R) GIOA, GRB ~func(R) GIOB, GRAB ~func(R) GIOAB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], GIOAB ~func() ET.Either[E, func(A) B]]() monad.Monad[A, B, GRA, GRB, GRAB] {
+	return &readerIOEitherMonad[R, E, A, B, GRA, GRB, GRAB, GIOA, GIOB, GIOAB]{}
+}
--- a/readerioeither/monad.go
+++ b/readerioeither/monad.go
@@ -0,0 +1,38 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerioeither
+
+import (
+	"github.com/IBM/fp-go/internal/functor"
+	"github.com/IBM/fp-go/internal/monad"
+	"github.com/IBM/fp-go/internal/pointed"
+	G "github.com/IBM/fp-go/readerioeither/generic"
+)
+
+// Pointed returns the pointed operations for [ReaderIOEither]
+func Pointed[R, E, A any]() pointed.Pointed[A, ReaderIOEither[R, E, A]] {
+	return G.Pointed[R, E, A, ReaderIOEither[R, E, A]]()
+}
+
+// Functor returns the functor operations for [ReaderIOEither]
+func Functor[R, E, A, B any]() functor.Functor[A, B, ReaderIOEither[R, E, A], ReaderIOEither[R, E, B]] {
+	return G.Functor[R, E, A, B, ReaderIOEither[R, E, A], ReaderIOEither[R, E, B]]()
+}
+
+// Monad returns the monadic operations for [ReaderIOEither]
+func Monad[R, E, A, B any]() monad.Monad[A, B, ReaderIOEither[R, E, A], ReaderIOEither[R, E, B], ReaderIOEither[R, E, func(A) B]] {
+	return G.Monad[R, E, A, B, ReaderIOEither[R, E, A], ReaderIOEither[R, E, B], ReaderIOEither[R, E, func(A) B]]()
+}
--- a/record/eq.go
+++ b/record/eq.go
@@ -23,3 +23,8 @@ import (
 func Eq[K comparable, V any](e E.Eq[V]) E.Eq[map[K]V] {
 	return G.Eq[map[K]V, K, V](e)
 }
+
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[K, V comparable]() E.Eq[map[K]V] {
+	return G.FromStrictEquals[map[K]V]()
+}
--- a/record/eq_test.go
+++ b/record/eq_test.go
@@ -0,0 +1,48 @@
+// Copyright (c) 2024 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"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFromStrictEquals(t *testing.T) {
+	m1 := map[string]string{
+		"a": "A",
+		"b": "B",
+	}
+	m2 := map[string]string{
+		"a": "A",
+		"b": "C",
+	}
+	m3 := map[string]string{
+		"a": "A",
+		"b": "B",
+	}
+	m4 := map[string]string{
+		"a": "A",
+		"b": "B",
+		"c": "C",
+	}
+
+	e := FromStrictEquals[string, string]()
+	assert.True(t, e.Equals(m1, m1))
+	assert.True(t, e.Equals(m1, m3))
+	assert.False(t, e.Equals(m1, m2))
+	assert.False(t, e.Equals(m1, m4))
+}
--- a/record/generic/eq.go
+++ b/record/generic/eq.go
@@ -37,3 +37,8 @@ func Eq[M ~map[K]V, K comparable, V any](e E.Eq[V]) E.Eq[M] {
 		return equals(left, right, eq)
 	})
 }
+
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[M ~map[K]V, K, V comparable]() E.Eq[M] {
+	return Eq[M](E.FromStrictEquals[V]())
+}
--- a/record/monoid_test.go
+++ b/record/monoid_test.go
@@ -54,3 +54,69 @@ func TestUnionMonoid(t *testing.T) {

 	assert.Equal(t, res, m.Concat(x, y))
 }
+
+func TestUnionFirstMonoid(t *testing.T) {
+	m := UnionFirstMonoid[string, string]()
+
+	e := Empty[string, string]()
+
+	x := map[string]string{
+		"a": "a1",
+		"b": "b1",
+		"c": "c1",
+	}
+
+	y := map[string]string{
+		"b": "b2",
+		"c": "c2",
+		"d": "d2",
+	}
+
+	res := map[string]string{
+		"a": "a1",
+		"b": "b1",
+		"c": "c1",
+		"d": "d2",
+	}
+
+	assert.Equal(t, x, m.Concat(x, m.Empty()))
+	assert.Equal(t, x, m.Concat(m.Empty(), x))
+
+	assert.Equal(t, x, m.Concat(x, e))
+	assert.Equal(t, x, m.Concat(e, x))
+
+	assert.Equal(t, res, m.Concat(x, y))
+}
+
+func TestUnionLastMonoid(t *testing.T) {
+	m := UnionLastMonoid[string, string]()
+
+	e := Empty[string, string]()
+
+	x := map[string]string{
+		"a": "a1",
+		"b": "b1",
+		"c": "c1",
+	}
+
+	y := map[string]string{
+		"b": "b2",
+		"c": "c2",
+		"d": "d2",
+	}
+
+	res := map[string]string{
+		"a": "a1",
+		"b": "b2",
+		"c": "c2",
+		"d": "d2",
+	}
+
+	assert.Equal(t, x, m.Concat(x, m.Empty()))
+	assert.Equal(t, x, m.Concat(m.Empty(), x))
+
+	assert.Equal(t, x, m.Concat(x, e))
+	assert.Equal(t, x, m.Concat(e, x))
+
+	assert.Equal(t, res, m.Concat(x, y))
+}
--- a/record/record_test.go
+++ b/record/record_test.go
@@ -176,3 +176,25 @@ func TestFromArrayMap(t *testing.T) {
 		"C": "C",
 	}, res2)
 }
+
+func TestEmpty(t *testing.T) {
+	nonEmpty := map[string]string{
+		"a": "A",
+		"b": "B",
+	}
+	empty := Empty[string, string]()
+
+	assert.True(t, IsEmpty(empty))
+	assert.False(t, IsEmpty(nonEmpty))
+	assert.False(t, IsNonEmpty(empty))
+	assert.True(t, IsNonEmpty(nonEmpty))
+}
+
+func TestHas(t *testing.T) {
+	nonEmpty := map[string]string{
+		"a": "A",
+		"b": "B",
+	}
+	assert.True(t, Has("a", nonEmpty))
+	assert.False(t, Has("c", nonEmpty))
+}
--- a/renovate.json
+++ b/renovate.json
@@ -1,11 +1,20 @@
 {
    "$schema": "https://docs.renovatebot.com/renovate-schema.json",
    "extends": [
-        "config:base",
+        "config:recommended",
        ":dependencyDashboard"
    ],
    "rangeStrategy": "bump",
    "packageRules": [
+        {
+            "matchDatasources": [
+                "golang-version"
+            ],
+            "matchPackageNames": [
+                "go"
+            ],
+            "enabled": false
+        },
        {
            "matchManagers": [
                "gomod"
--- a/tuple/doc.go
+++ b/tuple/doc.go
@@ -15,4 +15,4 @@

 package tuple

-//go:generate go run .. tuple --count 10 --filename gen.go
+//go:generate go run .. tuple --count 15 --filename gen.go
--- a/tuple/gen.go
+++ b/tuple/gen.go
@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2024-02-08 08:36:32.8883679 +0100 CET m=+0.008054801
+// 2024-02-29 16:19:31.6574369 +0100 CET m=+0.012049601

 package tuple

@@ -104,6 +104,91 @@ type Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any] struct {
 	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}
@@ -1326,3 +1411,843 @@ func FromArray10[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4,
 		)
 	}
 }
+
+// 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]),
+		)
+	}
+}
--- a/v2/README.md
+++ b/v2/README.md
@@ -0,0 +1,319 @@
+# fp-go V2: Enhanced Functional Programming for Go 1.24+
+
+[![Go Reference](https://pkg.go.dev/badge/github.com/IBM/fp-go/v2.svg)](https://pkg.go.dev/github.com/IBM/fp-go/v2)
+[![Coverage Status](https://coveralls.io/repos/github/IBM/fp-go/badge.svg?branch=main&flag=v2)](https://coveralls.io/github/IBM/fp-go?branch=main)
+
+Version 2 of fp-go leverages [generic type aliases](https://github.com/golang/go/issues/46477) introduced in Go 1.24, providing a more ergonomic and streamlined API.
+
+## 📚 Table of Contents
+
+- [Requirements](#-requirements)
+- [Breaking Changes](#-breaking-changes)
+- [Key Improvements](#-key-improvements)
+- [Migration Guide](#-migration-guide)
+- [Installation](#-installation)
+- [What's New](#-whats-new)
+
+## 🔧 Requirements
+
+- **Go 1.24 or later** (for generic type alias support)
+
+## ⚠️ Breaking Changes
+
+### 1. Generic Type Aliases
+
+V2 uses [generic type aliases](https://github.com/golang/go/issues/46477) which require Go 1.24+. This is the most significant change and enables cleaner type definitions.
+
+**V1:**
+```go
+type ReaderIOEither[R, E, A any] RD.Reader[R, IOE.IOEither[E, A]]
+```
+
+**V2:**
+```go
+type ReaderIOEither[R, E, A any] = RD.Reader[R, IOE.IOEither[E, A]]
+```
+
+### 2. Generic Type Parameter Ordering
+
+Type parameters that **cannot** be inferred from function arguments now come first, improving type inference.
+
+**V1:**
+```go
+// Ap in V1 - less intuitive ordering
+func Ap[R, E, A, B any](fa ReaderIOEither[R, E, A]) func(ReaderIOEither[R, E, func(A) B]) ReaderIOEither[R, E, B]
+```
+
+**V2:**
+```go
+// Ap in V2 - B comes first as it cannot be inferred
+func Ap[B, R, E, A any](fa ReaderIOEither[R, E, A]) func(ReaderIOEither[R, E, func(A) B]) ReaderIOEither[R, E, B]
+```
+
+This change allows the Go compiler to infer more types automatically, reducing the need for explicit type parameters.
+
+### 3. Pair Monad Semantics
+
+Monadic operations for `Pair` now operate on the **second argument** to align with the [Haskell definition](https://hackage.haskell.org/package/TypeCompose-0.9.14/docs/Data-Pair.html).
+
+**V1:**
+```go
+// Operations on first element
+pair := MakePair(1, "hello")
+result := Map(func(x int) int { return x * 2 })(pair) // Pair(2, "hello")
+```
+
+**V2:**
+```go
+// Operations on second element (Haskell-compatible)
+pair := MakePair(1, "hello")
+result := Map(func(s string) string { return s + "!" })(pair) // Pair(1, "hello!")
+```
+
+## ✨ Key Improvements
+
+### 1. Simplified Type Declarations
+
+Generic type aliases eliminate the need for namespace imports in type declarations.
+
+**V1 Approach:**
+```go
+import (
+    ET "github.com/IBM/fp-go/either"
+    OPT "github.com/IBM/fp-go/option"
+)
+
+func processData(input string) ET.Either[error, OPT.Option[int]] {
+    // implementation
+}
+```
+
+**V2 Approach:**
+```go
+import (
+    "github.com/IBM/fp-go/v2/either"
+    "github.com/IBM/fp-go/v2/option"
+)
+
+// Define type aliases once
+type Either[A any] = either.Either[error, A]
+type Option[A any] = option.Option[A]
+
+// Use them throughout your codebase
+func processData(input string) Either[Option[int]] {
+    // implementation
+}
+```
+
+### 2. No More `generic` Subpackages
+
+The library implementation no longer requires separate `generic` subpackages, making the codebase simpler and easier to understand.
+
+**V1 Structure:**
+```
+either/
+  either.go
+  generic/
+    either.go  // Generic implementation
+```
+
+**V2 Structure:**
+```
+either/
+  either.go  // Single, clean implementation
+```
+
+### 3. Better Type Inference
+
+The reordered type parameters allow the Go compiler to infer more types automatically:
+
+**V1:**
+```go
+// Often need explicit type parameters
+result := Map[Context, error, int, string](transform)(value)
+```
+
+**V2:**
+```go
+// Compiler can infer more types
+result := Map(transform)(value)  // Cleaner!
+```
+
+## 🚀 Migration Guide
+
+### Step 1: Update Go Version
+
+Ensure you're using Go 1.24 or later:
+
+```bash
+go version  # Should show go1.24 or higher
+```
+
+### Step 2: Update Import Paths
+
+Change all import paths from `github.com/IBM/fp-go` to `github.com/IBM/fp-go/v2`:
+
+**Before:**
+```go
+import (
+    "github.com/IBM/fp-go/either"
+    "github.com/IBM/fp-go/option"
+)
+```
+
+**After:**
+```go
+import (
+    "github.com/IBM/fp-go/v2/either"
+    "github.com/IBM/fp-go/v2/option"
+)
+```
+
+### Step 3: Remove `generic` Subpackage Imports
+
+If you were using generic subpackages, remove them:
+
+**Before:**
+```go
+import (
+    E "github.com/IBM/fp-go/either/generic"
+)
+```
+
+**After:**
+```go
+import (
+    "github.com/IBM/fp-go/v2/either"
+)
+```
+
+### Step 4: Update Type Parameter Order
+
+Review functions like `Ap` where type parameter order has changed. The compiler will help identify these:
+
+**Before:**
+```go
+result := Ap[Context, error, int, string](value)(funcInContext)
+```
+
+**After:**
+```go
+result := Ap[string, Context, error, int](value)(funcInContext)
+// Or better yet, let the compiler infer:
+result := Ap(value)(funcInContext)
+```
+
+### Step 5: Update Pair Operations
+
+If you're using `Pair`, update operations to work on the second element:
+
+**Before (V1):**
+```go
+pair := MakePair(42, "data")
+// Map operates on first element
+result := Map(func(x int) int { return x * 2 })(pair)
+```
+
+**After (V2):**
+```go
+pair := MakePair(42, "data")
+// Map operates on second element
+result := Map(func(s string) string { return s + "!" })(pair)
+```
+
+### Step 6: Simplify Type Aliases
+
+Create project-wide type aliases for common patterns:
+
+```go
+// types.go - Define once, use everywhere
+package myapp
+
+import (
+    "github.com/IBM/fp-go/v2/either"
+    "github.com/IBM/fp-go/v2/option"
+    "github.com/IBM/fp-go/v2/ioeither"
+)
+
+type Either[A any] = either.Either[error, A]
+type Option[A any] = option.Option[A]
+type IOEither[A any] = ioeither.IOEither[error, A]
+```
+
+## 📦 Installation
+
+```bash
+go get github.com/IBM/fp-go/v2
+```
+
+## 🆕 What's New
+
+### Cleaner API Surface
+
+The elimination of `generic` subpackages means:
+- Fewer imports to manage
+- Simpler package structure
+- Easier to navigate documentation
+- More intuitive API
+
+### Example: Before and After
+
+**V1 Complex Example:**
+```go
+import (
+    ET "github.com/IBM/fp-go/either"
+    EG "github.com/IBM/fp-go/either/generic"
+    IOET "github.com/IBM/fp-go/ioeither"
+    IOEG "github.com/IBM/fp-go/ioeither/generic"
+)
+
+func process() IOET.IOEither[error, string] {
+    return IOEG.Map[error, int, string](
+        func(x int) string { return fmt.Sprintf("%d", x) },
+    )(fetchData())
+}
+```
+
+**V2 Simplified Example:**
+```go
+import (
+    "github.com/IBM/fp-go/v2/either"
+    "github.com/IBM/fp-go/v2/ioeither"
+)
+
+type IOEither[A any] = ioeither.IOEither[error, A]
+
+func process() IOEither[string] {
+    return ioeither.Map(
+        func(x int) string { return fmt.Sprintf("%d", x) },
+    )(fetchData())
+}
+```
+
+## 📚 Additional Resources
+
+- [Main README](../README.md) - Core concepts and design philosophy
+- [API Documentation](https://pkg.go.dev/github.com/IBM/fp-go/v2)
+- [Code Samples](../samples/)
+- [Go 1.24 Release Notes](https://tip.golang.org/doc/go1.24)
+
+## 🤔 Should I Migrate?
+
+**Migrate to V2 if:**
+- ✅ You can use Go 1.24+
+- ✅ You want cleaner, more maintainable code
+- ✅ You want better type inference
+- ✅ You're starting a new project
+
+**Stay on V1 if:**
+- ⚠️ You're locked to Go < 1.24
+- ⚠️ Migration effort outweighs benefits for your project
+- ⚠️ You need stability in production (V2 is newer)
+
+## 🐛 Issues and Feedback
+
+Found a bug or have a suggestion? Please [open an issue](https://github.com/IBM/fp-go/issues) on GitHub.
+
+## 📄 License
+
+This project is licensed under the Apache License 2.0 - see the LICENSE file for details.
--- a/v2/array/any.go
+++ b/v2/array/any.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 array
+
+import (
+	G "github.com/IBM/fp-go/v2/array/generic"
+)
+
+// AnyWithIndex tests if any of the elements in the array matches the predicate.
+// The predicate receives both the index and the element.
+// Returns true if at least one element satisfies the predicate, false otherwise.
+//
+// Example:
+//
+//	hasEvenAtEvenIndex := array.AnyWithIndex(func(i, x int) bool {
+//	    return i%2 == 0 && x%2 == 0
+//	})
+//	result := hasEvenAtEvenIndex([]int{1, 3, 4, 5}) // true (4 is at index 2)
+//
+//go:inline
+func AnyWithIndex[A any](pred func(int, A) bool) func([]A) bool {
+	return G.AnyWithIndex[[]A](pred)
+}
+
+// Any tests if any of the elements in the array matches the predicate.
+// Returns true if at least one element satisfies the predicate, false otherwise.
+// Returns false for an empty array.
+//
+// Example:
+//
+//	hasEven := array.Any(func(x int) bool { return x%2 == 0 })
+//	result := hasEven([]int{1, 3, 4, 5}) // true
+//
+//go:inline
+func Any[A any](pred func(A) bool) func([]A) bool {
+	return G.Any[[]A](pred)
+}
--- a/v2/array/any_test.go
+++ b/v2/array/any_test.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 array
+
+import (
+	"testing"
+
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAny(t *testing.T) {
+	anyBool := Any(F.Identity[bool])
+
+	assert.True(t, anyBool(From(false, true, false)))
+	assert.False(t, anyBool(From(false, false, false)))
+}
--- a/v2/array/array.go
+++ b/v2/array/array.go
@@ -0,0 +1,538 @@
+// 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 array
+
+import (
+	G "github.com/IBM/fp-go/v2/array/generic"
+	EM "github.com/IBM/fp-go/v2/endomorphism"
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/internal/array"
+	M "github.com/IBM/fp-go/v2/monoid"
+	O "github.com/IBM/fp-go/v2/option"
+	"github.com/IBM/fp-go/v2/tuple"
+)
+
+// From constructs an array from a set of variadic arguments
+//
+//go:inline
+func From[A any](data ...A) []A {
+	return G.From[[]A](data...)
+}
+
+// MakeBy returns a `Array` of length `n` with element `i` initialized with `f(i)`.
+//
+//go:inline
+func MakeBy[F ~func(int) A, A any](n int, f F) []A {
+	return G.MakeBy[[]A](n, f)
+}
+
+// Replicate creates a `Array` containing a value repeated the specified number of times.
+//
+//go:inline
+func Replicate[A any](n int, a A) []A {
+	return G.Replicate[[]A](n, a)
+}
+
+// MonadMap applies a function to each element of an array, returning a new array with the results.
+// This is the monadic version of Map that takes the array as the first parameter.
+//
+//go:inline
+func MonadMap[A, B any](as []A, f func(a A) B) []B {
+	return G.MonadMap[[]A, []B](as, f)
+}
+
+// MonadMapRef applies a function to a pointer to each element of an array, returning a new array with the results.
+// This is useful when you need to access elements by reference without copying.
+func MonadMapRef[A, B any](as []A, f func(a *A) B) []B {
+	count := len(as)
+	bs := make([]B, count)
+	for i := count - 1; i >= 0; i-- {
+		bs[i] = f(&as[i])
+	}
+	return bs
+}
+
+// MapWithIndex applies a function to each element and its index in an array, returning a new array with the results.
+//
+//go:inline
+func MapWithIndex[A, B any](f func(int, A) B) func([]A) []B {
+	return G.MapWithIndex[[]A, []B](f)
+}
+
+// Map applies a function to each element of an array, returning a new array with the results.
+// This is the curried version that returns a function.
+//
+// Example:
+//
+//	double := array.Map(func(x int) int { return x * 2 })
+//	result := double([]int{1, 2, 3}) // [2, 4, 6]
+//
+//go:inline
+func Map[A, B any](f func(a A) B) func([]A) []B {
+	return G.Map[[]A, []B, A, B](f)
+}
+
+// MapRef applies a function to a pointer to each element of an array, returning a new array with the results.
+// This is the curried version that returns a function.
+func MapRef[A, B any](f func(a *A) B) func([]A) []B {
+	return F.Bind2nd(MonadMapRef[A, B], f)
+}
+
+func filterRef[A any](fa []A, pred func(a *A) bool) []A {
+	var result []A
+	count := len(fa)
+	for i := 0; i < count; i++ {
+		a := fa[i]
+		if pred(&a) {
+			result = append(result, a)
+		}
+	}
+	return result
+}
+
+func filterMapRef[A, B any](fa []A, pred func(a *A) bool, f func(a *A) B) []B {
+	var result []B
+	count := len(fa)
+	for i := 0; i < count; i++ {
+		a := fa[i]
+		if pred(&a) {
+			result = append(result, f(&a))
+		}
+	}
+	return result
+}
+
+// Filter returns a new array with all elements from the original array that match a predicate
+//
+//go:inline
+func Filter[A any](pred func(A) bool) EM.Endomorphism[[]A] {
+	return G.Filter[[]A](pred)
+}
+
+// FilterWithIndex returns a new array with all elements from the original array that match a predicate
+//
+//go:inline
+func FilterWithIndex[A any](pred func(int, A) bool) EM.Endomorphism[[]A] {
+	return G.FilterWithIndex[[]A](pred)
+}
+
+// FilterRef returns a new array with all elements from the original array that match a predicate operating on pointers.
+func FilterRef[A any](pred func(*A) bool) EM.Endomorphism[[]A] {
+	return F.Bind2nd(filterRef[A], pred)
+}
+
+// MonadFilterMap maps an array with a function that returns an Option and keeps only the Some values.
+// This is the monadic version that takes the array as the first parameter.
+//
+//go:inline
+func MonadFilterMap[A, B any](fa []A, f func(A) O.Option[B]) []B {
+	return G.MonadFilterMap[[]A, []B](fa, f)
+}
+
+// MonadFilterMapWithIndex maps an array with a function that takes an index and returns an Option,
+// keeping only the Some values. This is the monadic version that takes the array as the first parameter.
+//
+//go:inline
+func MonadFilterMapWithIndex[A, B any](fa []A, f func(int, A) O.Option[B]) []B {
+	return G.MonadFilterMapWithIndex[[]A, []B](fa, f)
+}
+
+// FilterMap maps an array with an iterating function that returns an [O.Option] and it keeps only the Some values discarding the Nones.
+//
+//go:inline
+func FilterMap[A, B any](f func(A) O.Option[B]) func([]A) []B {
+	return G.FilterMap[[]A, []B](f)
+}
+
+// FilterMapWithIndex maps an array with an iterating function that returns an [O.Option] and it keeps only the Some values discarding the Nones.
+//
+//go:inline
+func FilterMapWithIndex[A, B any](f func(int, A) O.Option[B]) func([]A) []B {
+	return G.FilterMapWithIndex[[]A, []B](f)
+}
+
+// FilterChain maps an array with an iterating function that returns an [O.Option] of an array. It keeps only the Some values discarding the Nones and then flattens the result.
+//
+//go:inline
+func FilterChain[A, B any](f func(A) O.Option[[]B]) func([]A) []B {
+	return G.FilterChain[[]A](f)
+}
+
+// FilterMapRef filters an array using a predicate on pointers and maps the matching elements using a function on pointers.
+func FilterMapRef[A, B any](pred func(a *A) bool, f func(a *A) B) func([]A) []B {
+	return func(fa []A) []B {
+		return filterMapRef(fa, pred, f)
+	}
+}
+
+func reduceRef[A, B any](fa []A, f func(B, *A) B, initial B) B {
+	current := initial
+	count := len(fa)
+	for i := 0; i < count; i++ {
+		current = f(current, &fa[i])
+	}
+	return current
+}
+
+//go:inline
+func MonadReduce[A, B any](fa []A, f func(B, A) B, initial B) B {
+	return G.MonadReduce(fa, f, initial)
+}
+
+// Reduce folds an array from left to right, applying a function to accumulate a result.
+//
+// Example:
+//
+//	sum := array.Reduce(func(acc, x int) int { return acc + x }, 0)
+//	result := sum([]int{1, 2, 3, 4, 5}) // 15
+//
+//go:inline
+func Reduce[A, B any](f func(B, A) B, initial B) func([]A) B {
+	return G.Reduce[[]A](f, initial)
+}
+
+// ReduceWithIndex folds an array from left to right with access to the index,
+// applying a function to accumulate a result.
+//
+//go:inline
+func ReduceWithIndex[A, B any](f func(int, B, A) B, initial B) func([]A) B {
+	return G.ReduceWithIndex[[]A](f, initial)
+}
+
+// ReduceRight folds an array from right to left, applying a function to accumulate a result.
+//
+//go:inline
+func ReduceRight[A, B any](f func(A, B) B, initial B) func([]A) B {
+	return G.ReduceRight[[]A](f, initial)
+}
+
+// ReduceRightWithIndex folds an array from right to left with access to the index,
+// applying a function to accumulate a result.
+//
+//go:inline
+func ReduceRightWithIndex[A, B any](f func(int, A, B) B, initial B) func([]A) B {
+	return G.ReduceRightWithIndex[[]A](f, initial)
+}
+
+// ReduceRef folds an array from left to right using pointers to elements,
+// applying a function to accumulate a result.
+func ReduceRef[A, B any](f func(B, *A) B, initial B) func([]A) B {
+	return func(as []A) B {
+		return reduceRef(as, f, initial)
+	}
+}
+
+// Append adds an element to the end of an array, returning a new array.
+//
+//go:inline
+func Append[A any](as []A, a A) []A {
+	return G.Append(as, a)
+}
+
+// IsEmpty checks if an array has no elements.
+//
+//go:inline
+func IsEmpty[A any](as []A) bool {
+	return G.IsEmpty(as)
+}
+
+// IsNonEmpty checks if an array has at least one element.
+func IsNonEmpty[A any](as []A) bool {
+	return len(as) > 0
+}
+
+// Empty returns an empty array of type A.
+//
+//go:inline
+func Empty[A any]() []A {
+	return G.Empty[[]A]()
+}
+
+// Zero returns an empty array of type A (alias for Empty).
+func Zero[A any]() []A {
+	return Empty[A]()
+}
+
+// Of constructs a single element array
+//
+//go:inline
+func Of[A any](a A) []A {
+	return G.Of[[]A](a)
+}
+
+// MonadChain applies a function that returns an array to each element and flattens the results.
+// This is the monadic version that takes the array as the first parameter (also known as FlatMap).
+//
+//go:inline
+func MonadChain[A, B any](fa []A, f func(a A) []B) []B {
+	return G.MonadChain[[]A, []B](fa, f)
+}
+
+// Chain applies a function that returns an array to each element and flattens the results.
+// This is the curried version (also known as FlatMap).
+//
+// Example:
+//
+//	duplicate := array.Chain(func(x int) []int { return []int{x, x} })
+//	result := duplicate([]int{1, 2, 3}) // [1, 1, 2, 2, 3, 3]
+//
+//go:inline
+func Chain[A, B any](f func(A) []B) func([]A) []B {
+	return G.Chain[[]A, []B](f)
+}
+
+// MonadAp applies an array of functions to an array of values, producing all combinations.
+// This is the monadic version that takes both arrays as parameters.
+//
+//go:inline
+func MonadAp[B, A any](fab []func(A) B, fa []A) []B {
+	return G.MonadAp[[]B](fab, fa)
+}
+
+// Ap applies an array of functions to an array of values, producing all combinations.
+// This is the curried version.
+//
+//go:inline
+func Ap[B, A any](fa []A) func([]func(A) B) []B {
+	return G.Ap[[]B, []func(A) B](fa)
+}
+
+// Match performs pattern matching on an array, calling onEmpty if empty or onNonEmpty if not.
+//
+//go:inline
+func Match[A, B any](onEmpty func() B, onNonEmpty func([]A) B) func([]A) B {
+	return G.Match[[]A](onEmpty, onNonEmpty)
+}
+
+// MatchLeft performs pattern matching on an array, calling onEmpty if empty or onNonEmpty with head and tail if not.
+//
+//go:inline
+func MatchLeft[A, B any](onEmpty func() B, onNonEmpty func(A, []A) B) func([]A) B {
+	return G.MatchLeft[[]A](onEmpty, onNonEmpty)
+}
+
+// Tail returns all elements except the first, wrapped in an Option.
+// Returns None if the array is empty.
+//
+//go:inline
+func Tail[A any](as []A) O.Option[[]A] {
+	return G.Tail(as)
+}
+
+// Head returns the first element of an array, wrapped in an Option.
+// Returns None if the array is empty.
+//
+//go:inline
+func Head[A any](as []A) O.Option[A] {
+	return G.Head(as)
+}
+
+// First returns the first element of an array, wrapped in an Option (alias for Head).
+// Returns None if the array is empty.
+//
+//go:inline
+func First[A any](as []A) O.Option[A] {
+	return G.First(as)
+}
+
+// Last returns the last element of an array, wrapped in an Option.
+// Returns None if the array is empty.
+//
+//go:inline
+func Last[A any](as []A) O.Option[A] {
+	return G.Last(as)
+}
+
+// PrependAll inserts a separator before each element of an array.
+func PrependAll[A any](middle A) EM.Endomorphism[[]A] {
+	return func(as []A) []A {
+		count := len(as)
+		dst := count * 2
+		result := make([]A, dst)
+		for i := count - 1; i >= 0; i-- {
+			dst--
+			result[dst] = as[i]
+			dst--
+			result[dst] = middle
+		}
+		return result
+	}
+}
+
+// Intersperse inserts a separator between each element of an array.
+//
+// Example:
+//
+//	result := array.Intersperse(0)([]int{1, 2, 3}) // [1, 0, 2, 0, 3]
+func Intersperse[A any](middle A) EM.Endomorphism[[]A] {
+	prepend := PrependAll(middle)
+	return func(as []A) []A {
+		if IsEmpty(as) {
+			return as
+		}
+		return prepend(as)[1:]
+	}
+}
+
+// Intercalate inserts a separator between elements and concatenates them using a Monoid.
+func Intercalate[A any](m M.Monoid[A]) func(A) func([]A) A {
+	return func(middle A) func([]A) A {
+		return Match(m.Empty, F.Flow2(Intersperse(middle), ConcatAll[A](m)))
+	}
+}
+
+// Flatten converts a nested array into a flat array by concatenating all inner arrays.
+//
+// Example:
+//
+//	result := array.Flatten([][]int{{1, 2}, {3, 4}, {5}}) // [1, 2, 3, 4, 5]
+//
+//go:inline
+func Flatten[A any](mma [][]A) []A {
+	return G.Flatten(mma)
+}
+
+// Slice extracts a subarray from index low (inclusive) to high (exclusive).
+func Slice[A any](low, high int) func(as []A) []A {
+	return array.Slice[[]A](low, high)
+}
+
+// Lookup returns the element at the specified index, wrapped in an Option.
+// Returns None if the index is out of bounds.
+//
+//go:inline
+func Lookup[A any](idx int) func([]A) O.Option[A] {
+	return G.Lookup[[]A](idx)
+}
+
+// UpsertAt returns a function that inserts or updates an element at a specific index.
+// If the index is out of bounds, the element is appended.
+//
+//go:inline
+func UpsertAt[A any](a A) EM.Endomorphism[[]A] {
+	return G.UpsertAt[[]A](a)
+}
+
+// Size returns the number of elements in an array.
+//
+//go:inline
+func Size[A any](as []A) int {
+	return G.Size(as)
+}
+
+// MonadPartition splits an array into two arrays based on a predicate.
+// The first array contains elements for which the predicate returns false,
+// the second contains elements for which it returns true.
+//
+//go:inline
+func MonadPartition[A any](as []A, pred func(A) bool) tuple.Tuple2[[]A, []A] {
+	return G.MonadPartition(as, pred)
+}
+
+// Partition creates two new arrays out of one, the left result contains the elements
+// for which the predicate returns false, the right one those for which the predicate returns true
+//
+//go:inline
+func Partition[A any](pred func(A) bool) func([]A) tuple.Tuple2[[]A, []A] {
+	return G.Partition[[]A](pred)
+}
+
+// IsNil checks if the array is set to nil
+func IsNil[A any](as []A) bool {
+	return array.IsNil(as)
+}
+
+// IsNonNil checks if the array is set to nil
+func IsNonNil[A any](as []A) bool {
+	return array.IsNonNil(as)
+}
+
+// ConstNil returns a nil array
+func ConstNil[A any]() []A {
+	return array.ConstNil[[]A]()
+}
+
+// SliceRight extracts a subarray from the specified start index to the end.
+//
+//go:inline
+func SliceRight[A any](start int) EM.Endomorphism[[]A] {
+	return G.SliceRight[[]A](start)
+}
+
+// Copy creates a shallow copy of the array
+//
+//go:inline
+func Copy[A any](b []A) []A {
+	return G.Copy(b)
+}
+
+// Clone creates a deep copy of the array using the provided endomorphism to clone the values
+//
+//go:inline
+func Clone[A any](f func(A) A) func(as []A) []A {
+	return G.Clone[[]A](f)
+}
+
+// FoldMap maps and folds an array. Map the Array passing each value to the iterating function. Then fold the results using the provided Monoid.
+//
+//go:inline
+func FoldMap[A, B any](m M.Monoid[B]) func(func(A) B) func([]A) B {
+	return G.FoldMap[[]A](m)
+}
+
+// FoldMapWithIndex maps and folds an array. Map the Array passing each value to the iterating function. Then fold the results using the provided Monoid.
+//
+//go:inline
+func FoldMapWithIndex[A, B any](m M.Monoid[B]) func(func(int, A) B) func([]A) B {
+	return G.FoldMapWithIndex[[]A](m)
+}
+
+// Fold folds the array using the provided Monoid.
+//
+//go:inline
+func Fold[A any](m M.Monoid[A]) func([]A) A {
+	return G.Fold[[]A](m)
+}
+
+// Push adds an element to the end of an array (alias for Append).
+//
+//go:inline
+func Push[A any](a A) EM.Endomorphism[[]A] {
+	return G.Push[EM.Endomorphism[[]A]](a)
+}
+
+// MonadFlap applies a value to an array of functions, producing an array of results.
+// This is the monadic version that takes both parameters.
+//
+//go:inline
+func MonadFlap[B, A any](fab []func(A) B, a A) []B {
+	return G.MonadFlap[func(A) B, []func(A) B, []B, A, B](fab, a)
+}
+
+// Flap applies a value to an array of functions, producing an array of results.
+// This is the curried version.
+//
+//go:inline
+func Flap[B, A any](a A) func([]func(A) B) []B {
+	return G.Flap[func(A) B, []func(A) B, []B, A, B](a)
+}
+
+// Prepend adds an element to the beginning of an array, returning a new array.
+//
+//go:inline
+func Prepend[A any](head A) EM.Endomorphism[[]A] {
+	return G.Prepend[EM.Endomorphism[[]A]](head)
+}
--- a/v2/array/array_extended_test.go
+++ b/v2/array/array_extended_test.go
@@ -0,0 +1,323 @@
+// 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 array
+
+import (
+	"fmt"
+	"testing"
+
+	N "github.com/IBM/fp-go/v2/number"
+	O "github.com/IBM/fp-go/v2/option"
+	S "github.com/IBM/fp-go/v2/string"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestReplicate(t *testing.T) {
+	result := Replicate(3, "a")
+	assert.Equal(t, []string{"a", "a", "a"}, result)
+
+	empty := Replicate(0, 42)
+	assert.Equal(t, []int{}, empty)
+}
+
+func TestMonadMap(t *testing.T) {
+	src := []int{1, 2, 3}
+	result := MonadMap(src, func(x int) int { return x * 2 })
+	assert.Equal(t, []int{2, 4, 6}, result)
+}
+
+func TestMonadMapRef(t *testing.T) {
+	src := []int{1, 2, 3}
+	result := MonadMapRef(src, func(x *int) int { return *x * 2 })
+	assert.Equal(t, []int{2, 4, 6}, result)
+}
+
+func TestMapWithIndex(t *testing.T) {
+	src := []string{"a", "b", "c"}
+	mapper := MapWithIndex(func(i int, s string) string {
+		return fmt.Sprintf("%d:%s", i, s)
+	})
+	result := mapper(src)
+	assert.Equal(t, []string{"0:a", "1:b", "2:c"}, result)
+}
+
+func TestMapRef(t *testing.T) {
+	src := []int{1, 2, 3}
+	mapper := MapRef(func(x *int) int { return *x * 2 })
+	result := mapper(src)
+	assert.Equal(t, []int{2, 4, 6}, result)
+}
+
+func TestFilterWithIndex(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	filter := FilterWithIndex(func(i, x int) bool {
+		return i%2 == 0 && x > 2
+	})
+	result := filter(src)
+	assert.Equal(t, []int{3, 5}, result)
+}
+
+func TestFilterRef(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	filter := FilterRef(func(x *int) bool { return *x > 2 })
+	result := filter(src)
+	assert.Equal(t, []int{3, 4, 5}, result)
+}
+
+func TestMonadFilterMap(t *testing.T) {
+	src := []int{1, 2, 3, 4}
+	result := MonadFilterMap(src, func(x int) O.Option[string] {
+		if x%2 == 0 {
+			return O.Some(fmt.Sprintf("even:%d", x))
+		}
+		return O.None[string]()
+	})
+	assert.Equal(t, []string{"even:2", "even:4"}, result)
+}
+
+func TestMonadFilterMapWithIndex(t *testing.T) {
+	src := []int{1, 2, 3, 4}
+	result := MonadFilterMapWithIndex(src, func(i, x int) O.Option[string] {
+		if i%2 == 0 {
+			return O.Some(fmt.Sprintf("%d:%d", i, x))
+		}
+		return O.None[string]()
+	})
+	assert.Equal(t, []string{"0:1", "2:3"}, result)
+}
+
+func TestFilterMapWithIndex(t *testing.T) {
+	src := []int{1, 2, 3, 4}
+	filter := FilterMapWithIndex(func(i, x int) O.Option[string] {
+		if i%2 == 0 {
+			return O.Some(fmt.Sprintf("%d:%d", i, x))
+		}
+		return O.None[string]()
+	})
+	result := filter(src)
+	assert.Equal(t, []string{"0:1", "2:3"}, result)
+}
+
+func TestFilterMapRef(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	filter := FilterMapRef(
+		func(x *int) bool { return *x > 2 },
+		func(x *int) string { return fmt.Sprintf("val:%d", *x) },
+	)
+	result := filter(src)
+	assert.Equal(t, []string{"val:3", "val:4", "val:5"}, result)
+}
+
+func TestReduceWithIndex(t *testing.T) {
+	src := []int{1, 2, 3}
+	reducer := ReduceWithIndex(func(i, acc, x int) int {
+		return acc + i + x
+	}, 0)
+	result := reducer(src)
+	assert.Equal(t, 9, result) // 0 + (0+1) + (1+2) + (2+3) = 9
+}
+
+func TestReduceRightWithIndex(t *testing.T) {
+	src := []string{"a", "b", "c"}
+	reducer := ReduceRightWithIndex(func(i int, x, acc string) string {
+		return fmt.Sprintf("%s%d:%s", acc, i, x)
+	}, "")
+	result := reducer(src)
+	assert.Equal(t, "2:c1:b0:a", result)
+}
+
+func TestReduceRef(t *testing.T) {
+	src := []int{1, 2, 3}
+	reducer := ReduceRef(func(acc int, x *int) int {
+		return acc + *x
+	}, 0)
+	result := reducer(src)
+	assert.Equal(t, 6, result)
+}
+
+func TestZero(t *testing.T) {
+	result := Zero[int]()
+	assert.Equal(t, []int{}, result)
+	assert.True(t, IsEmpty(result))
+}
+
+func TestMonadChain(t *testing.T) {
+	src := []int{1, 2, 3}
+	result := MonadChain(src, func(x int) []int {
+		return []int{x, x * 10}
+	})
+	assert.Equal(t, []int{1, 10, 2, 20, 3, 30}, result)
+}
+
+func TestChain(t *testing.T) {
+	src := []int{1, 2, 3}
+	chain := Chain(func(x int) []int {
+		return []int{x, x * 10}
+	})
+	result := chain(src)
+	assert.Equal(t, []int{1, 10, 2, 20, 3, 30}, result)
+}
+
+func TestMonadAp(t *testing.T) {
+	fns := []func(int) int{
+		func(x int) int { return x * 2 },
+		func(x int) int { return x + 10 },
+	}
+	values := []int{1, 2}
+	result := MonadAp(fns, values)
+	assert.Equal(t, []int{2, 4, 11, 12}, result)
+}
+
+func TestMatchLeft(t *testing.T) {
+	matcher := MatchLeft(
+		func() string { return "empty" },
+		func(head int, tail []int) string {
+			return fmt.Sprintf("head:%d,tail:%v", head, tail)
+		},
+	)
+
+	assert.Equal(t, "empty", matcher([]int{}))
+	assert.Equal(t, "head:1,tail:[2 3]", matcher([]int{1, 2, 3}))
+}
+
+func TestTail(t *testing.T) {
+	assert.Equal(t, O.None[[]int](), Tail([]int{}))
+	assert.Equal(t, O.Some([]int{2, 3}), Tail([]int{1, 2, 3}))
+	assert.Equal(t, O.Some([]int{}), Tail([]int{1}))
+}
+
+func TestFirst(t *testing.T) {
+	assert.Equal(t, O.None[int](), First([]int{}))
+	assert.Equal(t, O.Some(1), First([]int{1, 2, 3}))
+}
+
+func TestLast(t *testing.T) {
+	assert.Equal(t, O.None[int](), Last([]int{}))
+	assert.Equal(t, O.Some(3), Last([]int{1, 2, 3}))
+	assert.Equal(t, O.Some(1), Last([]int{1}))
+}
+
+func TestUpsertAt(t *testing.T) {
+	src := []int{1, 2, 3}
+	upsert := UpsertAt(99)
+
+	result1 := upsert(src)
+	assert.Equal(t, []int{1, 2, 3, 99}, result1)
+}
+
+func TestSize(t *testing.T) {
+	assert.Equal(t, 0, Size([]int{}))
+	assert.Equal(t, 3, Size([]int{1, 2, 3}))
+}
+
+func TestMonadPartition(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	result := MonadPartition(src, func(x int) bool { return x > 2 })
+	assert.Equal(t, []int{1, 2}, result.F1)
+	assert.Equal(t, []int{3, 4, 5}, result.F2)
+}
+
+func TestIsNil(t *testing.T) {
+	var nilSlice []int
+	assert.True(t, IsNil(nilSlice))
+	assert.False(t, IsNil([]int{}))
+	assert.False(t, IsNil([]int{1}))
+}
+
+func TestIsNonNil(t *testing.T) {
+	var nilSlice []int
+	assert.False(t, IsNonNil(nilSlice))
+	assert.True(t, IsNonNil([]int{}))
+	assert.True(t, IsNonNil([]int{1}))
+}
+
+func TestConstNil(t *testing.T) {
+	result := ConstNil[int]()
+	assert.True(t, IsNil(result))
+}
+
+func TestSliceRight(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	slicer := SliceRight[int](2)
+	result := slicer(src)
+	assert.Equal(t, []int{3, 4, 5}, result)
+}
+
+func TestCopy(t *testing.T) {
+	src := []int{1, 2, 3}
+	copied := Copy(src)
+	assert.Equal(t, src, copied)
+	// Verify it's a different slice
+	copied[0] = 99
+	assert.Equal(t, 1, src[0])
+	assert.Equal(t, 99, copied[0])
+}
+
+func TestClone(t *testing.T) {
+	src := []int{1, 2, 3}
+	cloner := Clone(func(x int) int { return x * 2 })
+	result := cloner(src)
+	assert.Equal(t, []int{2, 4, 6}, result)
+}
+
+func TestFoldMapWithIndex(t *testing.T) {
+	src := []string{"a", "b", "c"}
+	folder := FoldMapWithIndex[string](S.Monoid)(func(i int, s string) string {
+		return fmt.Sprintf("%d:%s", i, s)
+	})
+	result := folder(src)
+	assert.Equal(t, "0:a1:b2:c", result)
+}
+
+func TestFold(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	folder := Fold(N.MonoidSum[int]())
+	result := folder(src)
+	assert.Equal(t, 15, result)
+}
+
+func TestPush(t *testing.T) {
+	src := []int{1, 2, 3}
+	pusher := Push(4)
+	result := pusher(src)
+	assert.Equal(t, []int{1, 2, 3, 4}, result)
+}
+
+func TestMonadFlap(t *testing.T) {
+	fns := []func(int) string{
+		func(x int) string { return fmt.Sprintf("a%d", x) },
+		func(x int) string { return fmt.Sprintf("b%d", x) },
+	}
+	result := MonadFlap(fns, 5)
+	assert.Equal(t, []string{"a5", "b5"}, result)
+}
+
+func TestFlap(t *testing.T) {
+	fns := []func(int) string{
+		func(x int) string { return fmt.Sprintf("a%d", x) },
+		func(x int) string { return fmt.Sprintf("b%d", x) },
+	}
+	flapper := Flap[string](5)
+	result := flapper(fns)
+	assert.Equal(t, []string{"a5", "b5"}, result)
+}
+
+func TestPrepend(t *testing.T) {
+	src := []int{2, 3, 4}
+	prepender := Prepend(1)
+	result := prepender(src)
+	assert.Equal(t, []int{1, 2, 3, 4}, result)
+}
--- a/v2/array/array_test.go
+++ b/v2/array/array_test.go
@@ -0,0 +1,216 @@
+// 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 array
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/internal/utils"
+	O "github.com/IBM/fp-go/v2/option"
+	S "github.com/IBM/fp-go/v2/string"
+	T "github.com/IBM/fp-go/v2/tuple"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMap1(t *testing.T) {
+
+	src := []string{"a", "b", "c"}
+
+	up := Map(strings.ToUpper)(src)
+
+	var up1 = []string{}
+	for _, s := range src {
+		up1 = append(up1, strings.ToUpper(s))
+	}
+
+	var up2 = []string{}
+	for i := range src {
+		up2 = append(up2, strings.ToUpper(src[i]))
+	}
+
+	assert.Equal(t, up, up1)
+	assert.Equal(t, up, up2)
+}
+
+func TestMap(t *testing.T) {
+
+	mapper := Map(utils.Upper)
+
+	src := []string{"a", "b", "c"}
+
+	dst := mapper(src)
+
+	assert.Equal(t, dst, []string{"A", "B", "C"})
+}
+
+func TestReduceRight(t *testing.T) {
+	values := From("a", "b", "c")
+	f := func(a, acc string) string {
+		return fmt.Sprintf("%s%s", acc, a)
+	}
+	b := ""
+
+	assert.Equal(t, "cba", ReduceRight(f, b)(values))
+	assert.Equal(t, "", ReduceRight(f, b)(Empty[string]()))
+}
+
+func TestReduce(t *testing.T) {
+
+	values := MakeBy(101, F.Identity[int])
+
+	sum := func(val int, current int) int {
+		return val + current
+	}
+	reducer := Reduce(sum, 0)
+
+	result := reducer(values)
+	assert.Equal(t, result, 5050)
+
+}
+
+func TestEmpty(t *testing.T) {
+	assert.True(t, IsNonEmpty(MakeBy(101, F.Identity[int])))
+	assert.True(t, IsEmpty([]int{}))
+}
+
+func TestAp(t *testing.T) {
+	assert.Equal(t,
+		[]int{2, 4, 6, 3, 6, 9},
+		F.Pipe1(
+			[]func(int) int{
+				utils.Double,
+				utils.Triple,
+			},
+			Ap[int, int]([]int{1, 2, 3}),
+		),
+	)
+}
+
+func TestIntercalate(t *testing.T) {
+	is := Intercalate(S.Monoid)("-")
+
+	assert.Equal(t, "", is(Empty[string]()))
+	assert.Equal(t, "a", is([]string{"a"}))
+	assert.Equal(t, "a-b-c", is([]string{"a", "b", "c"}))
+	assert.Equal(t, "a--c", is([]string{"a", "", "c"}))
+	assert.Equal(t, "a-b", is([]string{"a", "b"}))
+	assert.Equal(t, "a-b-c-d", is([]string{"a", "b", "c", "d"}))
+}
+
+func TestIntersperse(t *testing.T) {
+	// Test with empty array
+	assert.Equal(t, []int{}, Intersperse(0)([]int{}))
+
+	// Test with single element
+	assert.Equal(t, []int{1}, Intersperse(0)([]int{1}))
+
+	// Test with multiple elements
+	assert.Equal(t, []int{1, 0, 2, 0, 3}, Intersperse(0)([]int{1, 2, 3}))
+}
+
+func TestPrependAll(t *testing.T) {
+	empty := Empty[int]()
+	prep := PrependAll(0)
+	assert.Equal(t, empty, prep(empty))
+	assert.Equal(t, []int{0, 1, 0, 2, 0, 3}, prep([]int{1, 2, 3}))
+	assert.Equal(t, []int{0, 1}, prep([]int{1}))
+	assert.Equal(t, []int{0, 1, 0, 2, 0, 3, 0, 4}, prep([]int{1, 2, 3, 4}))
+}
+
+func TestFlatten(t *testing.T) {
+	assert.Equal(t, []int{1, 2, 3}, Flatten([][]int{{1}, {2}, {3}}))
+}
+
+func TestLookup(t *testing.T) {
+	data := []int{0, 1, 2}
+	none := O.None[int]()
+
+	assert.Equal(t, none, Lookup[int](-1)(data))
+	assert.Equal(t, none, Lookup[int](10)(data))
+	assert.Equal(t, O.Some(1), Lookup[int](1)(data))
+}
+
+func TestSlice(t *testing.T) {
+	data := []int{0, 1, 2, 3}
+
+	assert.Equal(t, []int{1, 2}, Slice[int](1, 3)(data))
+}
+
+func TestFrom(t *testing.T) {
+	assert.Equal(t, []int{1, 2, 3}, From(1, 2, 3))
+}
+
+func TestPartition(t *testing.T) {
+
+	pred := func(n int) bool {
+		return n > 2
+	}
+
+	assert.Equal(t, T.MakeTuple2(Empty[int](), Empty[int]()), Partition(pred)(Empty[int]()))
+	assert.Equal(t, T.MakeTuple2(From(1), From(3)), Partition(pred)(From(1, 3)))
+}
+
+func TestFilterChain(t *testing.T) {
+	src := From(1, 2, 3)
+
+	f := func(i int) O.Option[[]string] {
+		if i%2 != 0 {
+			return O.Of(From(fmt.Sprintf("a%d", i), fmt.Sprintf("b%d", i)))
+		}
+		return O.None[[]string]()
+	}
+
+	res := FilterChain(f)(src)
+
+	assert.Equal(t, From("a1", "b1", "a3", "b3"), res)
+}
+
+func TestFilterMap(t *testing.T) {
+	src := From(1, 2, 3)
+
+	f := func(i int) O.Option[string] {
+		if i%2 != 0 {
+			return O.Of(fmt.Sprintf("a%d", i))
+		}
+		return O.None[string]()
+	}
+
+	res := FilterMap(f)(src)
+
+	assert.Equal(t, From("a1", "a3"), res)
+}
+
+func TestFoldMap(t *testing.T) {
+	src := From("a", "b", "c")
+
+	fold := FoldMap[string](S.Monoid)(strings.ToUpper)
+
+	assert.Equal(t, "ABC", fold(src))
+}
+
+func ExampleFoldMap() {
+	src := From("a", "b", "c")
+
+	fold := FoldMap[string](S.Monoid)(strings.ToUpper)
+
+	fmt.Println(fold(src))
+
+	// Output: ABC
+
+}
--- a/v2/array/bind.go
+++ b/v2/array/bind.go
@@ -0,0 +1,148 @@
+// 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 array
+
+import (
+	G "github.com/IBM/fp-go/v2/array/generic"
+)
+
+// Do creates an empty context of type S to be used with the Bind operation.
+// This is the starting point for monadic do-notation style computations.
+//
+// Example:
+//
+//	type State struct {
+//	    X int
+//	    Y int
+//	}
+//	result := array.Do(State{})
+//
+//go:inline
+func Do[S any](
+	empty S,
+) []S {
+	return G.Do[[]S, S](empty)
+}
+
+// Bind attaches the result of a computation to a context S1 to produce a context S2.
+// The setter function defines how to update the context with the computation result.
+// This enables monadic composition where each step can produce multiple results.
+//
+// Example:
+//
+//	result := F.Pipe2(
+//	    array.Do(struct{ X, Y int }{}),
+//	    array.Bind(
+//	        func(x int) func(s struct{}) struct{ X int } {
+//	            return func(s struct{}) struct{ X int } { return struct{ X int }{x} }
+//	        },
+//	        func(s struct{}) []int { return []int{1, 2} },
+//	    ),
+//	)
+//
+//go:inline
+func Bind[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) []T,
+) func([]S1) []S2 {
+	return G.Bind[[]S1, []S2, []T, S1, S2, T](setter, f)
+}
+
+// Let attaches the result of a pure computation to a context S1 to produce a context S2.
+// Unlike Bind, the computation function returns a plain value T rather than []T.
+//
+// Example:
+//
+//	result := array.Let(
+//	    func(sum int) func(s struct{ X int }) struct{ X, Sum int } {
+//	        return func(s struct{ X int }) struct{ X, Sum int } {
+//	            return struct{ X, Sum int }{s.X, sum}
+//	        }
+//	    },
+//	    func(s struct{ X int }) int { return s.X * 2 },
+//	)
+//
+//go:inline
+func Let[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) T,
+) func([]S1) []S2 {
+	return G.Let[[]S1, []S2, S1, S2, T](setter, f)
+}
+
+// LetTo attaches a constant value to a context S1 to produce a context S2.
+// This is useful for adding constant values to the context.
+//
+// Example:
+//
+//	result := array.LetTo(
+//	    func(name string) func(s struct{ X int }) struct{ X int; Name string } {
+//	        return func(s struct{ X int }) struct{ X int; Name string } {
+//	            return struct{ X int; Name string }{s.X, name}
+//	        }
+//	    },
+//	    "constant",
+//	)
+//
+//go:inline
+func LetTo[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	b T,
+) func([]S1) []S2 {
+	return G.LetTo[[]S1, []S2, S1, S2, T](setter, b)
+}
+
+// BindTo initializes a new state S1 from a value T.
+// This is typically the first operation after Do to start building the context.
+//
+// Example:
+//
+//	result := F.Pipe2(
+//	    []int{1, 2, 3},
+//	    array.BindTo(func(x int) struct{ X int } {
+//	        return struct{ X int }{x}
+//	    }),
+//	)
+//
+//go:inline
+func BindTo[S1, T any](
+	setter func(T) S1,
+) func([]T) []S1 {
+	return G.BindTo[[]S1, []T, S1, T](setter)
+}
+
+// ApS attaches a value to a context S1 to produce a context S2 by considering
+// the context and the value concurrently (using applicative semantics).
+// This produces all combinations of context values and array values.
+//
+// Example:
+//
+//	result := array.ApS(
+//	    func(y int) func(s struct{ X int }) struct{ X, Y int } {
+//	        return func(s struct{ X int }) struct{ X, Y int } {
+//	            return struct{ X, Y int }{s.X, y}
+//	        }
+//	    },
+//	    []int{10, 20},
+//	)
+//
+//go:inline
+func ApS[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa []T,
+) func([]S1) []S2 {
+	return G.ApS[[]S1, []S2, []T, S1, S2, T](setter, fa)
+}
--- a/v2/array/bind_extended_test.go
+++ b/v2/array/bind_extended_test.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 array
+
+import (
+	"testing"
+
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/stretchr/testify/assert"
+)
+
+type TestState1 struct {
+	X int
+}
+
+type TestState2 struct {
+	X int
+	Y int
+}
+
+func TestLet(t *testing.T) {
+	result := F.Pipe2(
+		Do(TestState1{}),
+		Let(
+			func(y int) func(s TestState1) TestState2 {
+				return func(s TestState1) TestState2 {
+					return TestState2{X: s.X, Y: y}
+				}
+			},
+			func(s TestState1) int { return s.X * 2 },
+		),
+		Map(func(s TestState2) int { return s.X + s.Y }),
+	)
+
+	assert.Equal(t, []int{0}, result)
+}
+
+func TestLetTo(t *testing.T) {
+	result := F.Pipe2(
+		Do(TestState1{X: 5}),
+		LetTo(
+			func(y int) func(s TestState1) TestState2 {
+				return func(s TestState1) TestState2 {
+					return TestState2{X: s.X, Y: y}
+				}
+			},
+			42,
+		),
+		Map(func(s TestState2) int { return s.X + s.Y }),
+	)
+
+	assert.Equal(t, []int{47}, result)
+}
+
+func TestBindTo(t *testing.T) {
+	result := F.Pipe1(
+		[]int{1, 2, 3},
+		BindTo(func(x int) TestState1 {
+			return TestState1{X: x}
+		}),
+	)
+
+	expected := []TestState1{{X: 1}, {X: 2}, {X: 3}}
+	assert.Equal(t, expected, result)
+}
--- a/v2/array/bind_test.go
+++ b/v2/array/bind_test.go
@@ -0,0 +1,56 @@
+// 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 array
+
+import (
+	"testing"
+
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/internal/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+func getLastName(s utils.Initial) []string {
+	return Of("Doe")
+}
+
+func getGivenName(s utils.WithLastName) []string {
+	return Of("John")
+}
+
+func TestBind(t *testing.T) {
+
+	res := F.Pipe3(
+		Do(utils.Empty),
+		Bind(utils.SetLastName, getLastName),
+		Bind(utils.SetGivenName, getGivenName),
+		Map(utils.GetFullName),
+	)
+
+	assert.Equal(t, res, Of("John Doe"))
+}
+
+func TestApS(t *testing.T) {
+
+	res := F.Pipe3(
+		Do(utils.Empty),
+		ApS(utils.SetLastName, Of("Doe")),
+		ApS(utils.SetGivenName, Of("John")),
+		Map(utils.GetFullName),
+	)
+
+	assert.Equal(t, res, Of("John Doe"))
+}
--- a/v2/array/doc.go
+++ b/v2/array/doc.go
@@ -0,0 +1,251 @@
+// 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 array provides functional programming utilities for working with Go slices.
+//
+// This package treats Go slices as immutable arrays and provides a rich set of operations
+// for transforming, filtering, folding, and combining arrays in a functional style.
+// All operations return new arrays rather than modifying existing ones.
+//
+// # Core Concepts
+//
+// The array package implements several functional programming abstractions:
+//   - Functor: Transform array elements with Map
+//   - Applicative: Apply functions in arrays to values in arrays
+//   - Monad: Chain operations that produce arrays with Chain/FlatMap
+//   - Foldable: Reduce arrays to single values with Reduce/Fold
+//   - Traversable: Transform arrays while preserving structure
+//
+// # Basic Operations
+//
+//	// Creating arrays
+//	arr := array.From(1, 2, 3, 4, 5)
+//	repeated := array.Replicate(3, "hello")
+//	generated := array.MakeBy(5, func(i int) int { return i * 2 })
+//
+//	// Transforming arrays
+//	doubled := array.Map(func(x int) int { return x * 2 })(arr)
+//	filtered := array.Filter(func(x int) bool { return x > 2 })(arr)
+//
+//	// Combining arrays
+//	combined := array.Flatten([][]int{{1, 2}, {3, 4}})
+//	zipped := array.Zip([]string{"a", "b"})([]int{1, 2})
+//
+// # Mapping and Filtering
+//
+// Transform array elements with Map, or filter elements with Filter:
+//
+//	numbers := []int{1, 2, 3, 4, 5}
+//
+//	// Map transforms each element
+//	doubled := array.Map(func(x int) int { return x * 2 })(numbers)
+//	// Result: [2, 4, 6, 8, 10]
+//
+//	// Filter keeps elements matching a predicate
+//	evens := array.Filter(func(x int) bool { return x%2 == 0 })(numbers)
+//	// Result: [2, 4]
+//
+//	// FilterMap combines both operations
+//	import "github.com/IBM/fp-go/v2/option"
+//	result := array.FilterMap(func(x int) option.Option[int] {
+//	    if x%2 == 0 {
+//	        return option.Some(x * 2)
+//	    }
+//	    return option.None[int]()
+//	})(numbers)
+//	// Result: [4, 8]
+//
+// # Folding and Reducing
+//
+// Reduce arrays to single values:
+//
+//	numbers := []int{1, 2, 3, 4, 5}
+//
+//	// Sum all elements
+//	sum := array.Reduce(func(acc, x int) int { return acc + x }, 0)(numbers)
+//	// Result: 15
+//
+//	// Using a Monoid
+//	import "github.com/IBM/fp-go/v2/monoid"
+//	sum := array.Fold(monoid.MonoidSum[int]())(numbers)
+//	// Result: 15
+//
+// # Chaining Operations
+//
+// Chain operations that produce arrays (also known as FlatMap):
+//
+//	numbers := []int{1, 2, 3}
+//	result := array.Chain(func(x int) []int {
+//	    return []int{x, x * 10}
+//	})(numbers)
+//	// Result: [1, 10, 2, 20, 3, 30]
+//
+// # Finding Elements
+//
+// Search for elements matching predicates:
+//
+//	numbers := []int{1, 2, 3, 4, 5}
+//
+//	// Find first element > 3
+//	first := array.FindFirst(func(x int) bool { return x > 3 })(numbers)
+//	// Result: Some(4)
+//
+//	// Find last element > 3
+//	last := array.FindLast(func(x int) bool { return x > 3 })(numbers)
+//	// Result: Some(5)
+//
+//	// Get head and tail
+//	head := array.Head(numbers) // Some(1)
+//	tail := array.Tail(numbers) // Some([2, 3, 4, 5])
+//
+// # Sorting
+//
+// Sort arrays using Ord instances:
+//
+//	import "github.com/IBM/fp-go/v2/ord"
+//
+//	numbers := []int{3, 1, 4, 1, 5}
+//	sorted := array.Sort(ord.FromStrictCompare[int]())(numbers)
+//	// Result: [1, 1, 3, 4, 5]
+//
+//	// Sort by extracted key
+//	type Person struct { Name string; Age int }
+//	people := []Person{{"Alice", 30}, {"Bob", 25}}
+//	byAge := array.SortByKey(ord.FromStrictCompare[int](), func(p Person) int {
+//	    return p.Age
+//	})(people)
+//
+// # Uniqueness
+//
+// Remove duplicate elements:
+//
+//	numbers := []int{1, 2, 2, 3, 3, 3}
+//	unique := array.StrictUniq(numbers)
+//	// Result: [1, 2, 3]
+//
+//	// Unique by key
+//	type Person struct { Name string; Age int }
+//	people := []Person{{"Alice", 30}, {"Bob", 25}, {"Alice", 35}}
+//	uniqueByName := array.Uniq(func(p Person) string { return p.Name })(people)
+//	// Result: [{"Alice", 30}, {"Bob", 25}]
+//
+// # Zipping
+//
+// Combine multiple arrays:
+//
+//	names := []string{"Alice", "Bob", "Charlie"}
+//	ages := []int{30, 25, 35}
+//
+//	// Zip into tuples
+//	pairs := array.Zip(ages)(names)
+//	// Result: [(Alice, 30), (Bob, 25), (Charlie, 35)]
+//
+//	// Zip with custom function
+//	result := array.ZipWith(names, ages, func(name string, age int) string {
+//	    return fmt.Sprintf("%s is %d", name, age)
+//	})
+//
+// # Monadic Do Notation
+//
+// Build complex array computations using do-notation style:
+//
+//	result := array.Do(
+//	    struct{ X, Y int }{},
+//	)(
+//	    array.Bind(
+//	        func(x int) func(s struct{}) struct{ X int } {
+//	            return func(s struct{}) struct{ X int } { return struct{ X int }{x} }
+//	        },
+//	        func(s struct{}) []int { return []int{1, 2, 3} },
+//	    ),
+//	    array.Bind(
+//	        func(y int) func(s struct{ X int }) struct{ X, Y int } {
+//	            return func(s struct{ X int }) struct{ X, Y int } {
+//	                return struct{ X, Y int }{s.X, y}
+//	            }
+//	        },
+//	        func(s struct{ X int }) []int { return []int{4, 5} },
+//	    ),
+//	)
+//	// Produces all combinations: [{1,4}, {1,5}, {2,4}, {2,5}, {3,4}, {3,5}]
+//
+// # Sequence and Traverse
+//
+// Transform arrays of effects into effects of arrays:
+//
+//	import "github.com/IBM/fp-go/v2/option"
+//
+//	// Sequence: []Option[A] -> Option[[]A]
+//	opts := []option.Option[int]{
+//	    option.Some(1),
+//	    option.Some(2),
+//	    option.Some(3),
+//	}
+//	result := array.ArrayOption[int]()(opts)
+//	// Result: Some([1, 2, 3])
+//
+//	// If any is None, result is None
+//	opts2 := []option.Option[int]{
+//	    option.Some(1),
+//	    option.None[int](),
+//	    option.Some(3),
+//	}
+//	result2 := array.ArrayOption[int]()(opts2)
+//	// Result: None
+//
+// # Equality and Comparison
+//
+// Compare arrays for equality:
+//
+//	import "github.com/IBM/fp-go/v2/eq"
+//
+//	eq := array.Eq(eq.FromStrictEquals[int]())
+//	equal := eq.Equals([]int{1, 2, 3}, []int{1, 2, 3})
+//	// Result: true
+//
+// # Monoid Operations
+//
+// Combine arrays using monoid operations:
+//
+//	import "github.com/IBM/fp-go/v2/monoid"
+//
+//	// Concatenate arrays
+//	m := array.Monoid[int]()
+//	result := m.Concat([]int{1, 2}, []int{3, 4})
+//	// Result: [1, 2, 3, 4]
+//
+//	// Concatenate multiple arrays efficiently
+//	result := array.ArrayConcatAll(
+//	    []int{1, 2},
+//	    []int{3, 4},
+//	    []int{5, 6},
+//	)
+//	// Result: [1, 2, 3, 4, 5, 6]
+//
+// # Performance Considerations
+//
+// Most operations create new arrays rather than modifying existing ones. For performance-critical
+// code, consider:
+//   - Using Copy for shallow copies when needed
+//   - Using Clone with a custom cloning function for deep copies
+//   - Batching operations to minimize intermediate allocations
+//   - Using ArrayConcatAll for efficient concatenation of multiple arrays
+//
+// # Subpackages
+//
+//   - array/generic: Generic implementations for custom array-like types
+//   - array/nonempty: Operations for non-empty arrays with compile-time guarantees
+//   - array/testing: Testing utilities for array laws and properties
+package array
--- a/v2/array/eq.go
+++ b/v2/array/eq.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 array
+
+import (
+	E "github.com/IBM/fp-go/v2/eq"
+)
+
+func equals[T any](left []T, right []T, eq func(T, T) bool) bool {
+	if len(left) != len(right) {
+		return false
+	}
+	for i, v1 := range left {
+		v2 := right[i]
+		if !eq(v1, v2) {
+			return false
+		}
+	}
+	return true
+}
+
+// Eq creates an equality checker for arrays given an equality checker for elements.
+// Two arrays are considered equal if they have the same length and all corresponding
+// elements are equal according to the provided Eq instance.
+//
+// Example:
+//
+//	import "github.com/IBM/fp-go/v2/eq"
+//
+//	intArrayEq := array.Eq(eq.FromStrictEquals[int]())
+//	result := intArrayEq.Equals([]int{1, 2, 3}, []int{1, 2, 3}) // true
+//	result2 := intArrayEq.Equals([]int{1, 2, 3}, []int{1, 2, 4}) // false
+func Eq[T any](e E.Eq[T]) E.Eq[[]T] {
+	eq := e.Equals
+	return E.FromEquals(func(left, right []T) bool {
+		return equals(left, right, eq)
+	})
+}
--- a/v2/array/eq_test.go
+++ b/v2/array/eq_test.go
@@ -0,0 +1,44 @@
+// 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 array
+
+import (
+	"testing"
+
+	E "github.com/IBM/fp-go/v2/eq"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEq(t *testing.T) {
+	intEq := Eq(E.FromStrictEquals[int]())
+
+	// Test equal arrays
+	assert.True(t, intEq.Equals([]int{1, 2, 3}, []int{1, 2, 3}))
+
+	// Test different lengths
+	assert.False(t, intEq.Equals([]int{1, 2, 3}, []int{1, 2}))
+
+	// Test different values
+	assert.False(t, intEq.Equals([]int{1, 2, 3}, []int{1, 2, 4}))
+
+	// Test empty arrays
+	assert.True(t, intEq.Equals([]int{}, []int{}))
+
+	// Test string arrays
+	stringEq := Eq(E.FromStrictEquals[string]())
+	assert.True(t, stringEq.Equals([]string{"a", "b"}, []string{"a", "b"}))
+	assert.False(t, stringEq.Equals([]string{"a", "b"}, []string{"a", "c"}))
+}
--- a/v2/array/example_any_test.go
+++ b/v2/array/example_any_test.go
@@ -0,0 +1,77 @@
+// 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 array
+
+import (
+	"fmt"
+
+	F "github.com/IBM/fp-go/v2/function"
+	O "github.com/IBM/fp-go/v2/option"
+)
+
+func Example_any() {
+
+	pred := func(val int) bool {
+		return val&2 == 0
+	}
+
+	data1 := From(1, 2, 3)
+
+	fmt.Println(Any(pred)(data1))
+
+	// Output:
+	// true
+}
+
+func Example_any_filter() {
+
+	pred := func(val int) bool {
+		return val&2 == 0
+	}
+
+	data1 := From(1, 2, 3)
+
+	// Any tests if any of the entries in the array matches the condition
+	Any := F.Flow2(
+		Filter(pred),
+		IsNonEmpty[int],
+	)
+
+	fmt.Println(Any(data1))
+
+	// Output:
+	// true
+}
+
+func Example_any_find() {
+
+	pred := func(val int) bool {
+		return val&2 == 0
+	}
+
+	data1 := From(1, 2, 3)
+
+	// Any tests if any of the entries in the array matches the condition
+	Any := F.Flow2(
+		FindFirst(pred),
+		O.IsSome[int],
+	)
+
+	fmt.Println(Any(data1))
+
+	// Output:
+	// true
+}
--- a/v2/array/example_find_test.go
+++ b/v2/array/example_find_test.go
@@ -0,0 +1,55 @@
+// 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 array
+
+import (
+	"fmt"
+
+	F "github.com/IBM/fp-go/v2/function"
+)
+
+func Example_find() {
+
+	pred := func(val int) bool {
+		return val&2 == 0
+	}
+
+	data1 := From(1, 2, 3)
+
+	fmt.Println(FindFirst(pred)(data1))
+
+	// Output:
+	// Some[int](1)
+}
+
+func Example_find_filter() {
+
+	pred := func(val int) bool {
+		return val&2 == 0
+	}
+
+	data1 := From(1, 2, 3)
+
+	Find := F.Flow2(
+		Filter(pred),
+		Head[int],
+	)
+
+	fmt.Println(Find(data1))
+
+	// Output:
+	// Some[int](1)
+}
--- a/v2/array/examples_basic_test.go
+++ b/v2/array/examples_basic_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 array
+
+import (
+	"fmt"
+
+	F "github.com/IBM/fp-go/v2/function"
+	O "github.com/IBM/fp-go/v2/option"
+)
+
+// Example_basic adapts examples from [https://github.com/inato/fp-ts-cheatsheet#basic-manipulation]
+func Example_basic() {
+
+	someArray := From(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) // []int
+
+	isEven := func(num int) bool {
+		return num%2 == 0
+	}
+
+	square := func(num int) int {
+		return num * num
+	}
+
+	// filter and map
+	result := F.Pipe2(
+		someArray,
+		Filter(isEven),
+		Map(square),
+	) // [0 4 16 36 64]
+
+	// or in one go with filterMap
+	resultFilterMap := F.Pipe1(
+		someArray,
+		FilterMap(
+			F.Flow2(O.FromPredicate(isEven), O.Map(square)),
+		),
+	)
+
+	fmt.Println(result)
+	fmt.Println(resultFilterMap)
+
+	// Output:
+	// [0 4 16 36 64]
+	// [0 4 16 36 64]
+}
--- a/v2/array/examples_sort_test.go
+++ b/v2/array/examples_sort_test.go
@@ -0,0 +1,92 @@
+// 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 array
+
+import (
+	"fmt"
+
+	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"
+)
+
+type user struct {
+	name string
+	age  O.Option[int]
+}
+
+func (user user) GetName() string {
+	return user.name
+}
+
+func (user user) GetAge() O.Option[int] {
+	return user.age
+}
+
+// Example_sort adapts examples from [https://github.com/inato/fp-ts-cheatsheet#sort-elements-with-ord]
+func Example_sort() {
+
+	strings := From("zyx", "abc", "klm")
+
+	sortedStrings := F.Pipe1(
+		strings,
+		Sort(S.Ord),
+	) // => ['abc', 'klm', 'zyx']
+
+	// reverse sort
+	reverseSortedStrings := F.Pipe1(
+		strings,
+		Sort(ord.Reverse(S.Ord)),
+	) // => ['zyx', 'klm', 'abc']
+
+	// sort Option
+	optionalNumbers := From(O.Some(1337), O.None[int](), O.Some(42))
+
+	sortedNums := F.Pipe1(
+		optionalNumbers,
+		Sort(O.Ord(I.Ord)),
+	)
+
+	// complex object with different rules
+	byName := F.Pipe1(
+		S.Ord,
+		ord.Contramap(user.GetName),
+	) // ord.Ord[user]
+
+	byAge := F.Pipe1(
+		O.Ord(I.Ord),
+		ord.Contramap(user.GetAge),
+	) // ord.Ord[user]
+
+	sortedUsers := F.Pipe1(
+		From(user{name: "a", age: O.Of(30)}, user{name: "d", age: O.Of(10)}, user{name: "c"}, user{name: "b", age: O.Of(10)}),
+		SortBy(From(byAge, byName)),
+	)
+
+	fmt.Println(sortedStrings)
+	fmt.Println(reverseSortedStrings)
+	fmt.Println(sortedNums)
+	fmt.Println(sortedUsers)
+
+	// Output:
+	// [abc klm zyx]
+	// [zyx klm abc]
+	// [None[int] Some[int](42) Some[int](1337)]
+	// [{c {false 0}} {b {true 10}} {d {true 10}} {a {true 30}}]
+
+}
--- a/v2/array/find.go
+++ b/v2/array/find.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 array
+
+import (
+	G "github.com/IBM/fp-go/v2/array/generic"
+	O "github.com/IBM/fp-go/v2/option"
+)
+
+// FindFirst finds the first element which satisfies a predicate function.
+// Returns Some(element) if found, None if no element matches.
+//
+// Example:
+//
+//	findGreaterThan3 := array.FindFirst(func(x int) bool { return x > 3 })
+//	result := findGreaterThan3([]int{1, 2, 4, 5}) // Some(4)
+//	result2 := findGreaterThan3([]int{1, 2, 3}) // None
+//
+//go:inline
+func FindFirst[A any](pred func(A) bool) func([]A) O.Option[A] {
+	return G.FindFirst[[]A](pred)
+}
+
+// FindFirstWithIndex finds the first element which satisfies a predicate function that also receives the index.
+// Returns Some(element) if found, None if no element matches.
+//
+// Example:
+//
+//	findEvenAtEvenIndex := array.FindFirstWithIndex(func(i, x int) bool {
+//	    return i%2 == 0 && x%2 == 0
+//	})
+//	result := findEvenAtEvenIndex([]int{1, 3, 4, 5}) // Some(4)
+//
+//go:inline
+func FindFirstWithIndex[A any](pred func(int, A) bool) func([]A) O.Option[A] {
+	return G.FindFirstWithIndex[[]A](pred)
+}
+
+// FindFirstMap finds the first element for which the selector function returns Some.
+// This combines finding and mapping in a single operation.
+//
+// Example:
+//
+//	import "strconv"
+//
+//	parseFirst := array.FindFirstMap(func(s string) option.Option[int] {
+//	    if n, err := strconv.Atoi(s); err == nil {
+//	        return option.Some(n)
+//	    }
+//	    return option.None[int]()
+//	})
+//	result := parseFirst([]string{"a", "42", "b"}) // Some(42)
+//
+//go:inline
+func FindFirstMap[A, B any](sel func(A) O.Option[B]) func([]A) O.Option[B] {
+	return G.FindFirstMap[[]A](sel)
+}
+
+// FindFirstMapWithIndex finds the first element for which the selector function returns Some.
+// The selector receives both the index and the element.
+//
+//go:inline
+func FindFirstMapWithIndex[A, B any](sel func(int, A) O.Option[B]) func([]A) O.Option[B] {
+	return G.FindFirstMapWithIndex[[]A](sel)
+}
+
+// FindLast finds the last element which satisfies a predicate function.
+// Returns Some(element) if found, None if no element matches.
+//
+// Example:
+//
+//	findGreaterThan3 := array.FindLast(func(x int) bool { return x > 3 })
+//	result := findGreaterThan3([]int{1, 4, 2, 5}) // Some(5)
+//
+//go:inline
+func FindLast[A any](pred func(A) bool) func([]A) O.Option[A] {
+	return G.FindLast[[]A](pred)
+}
+
+// FindLastWithIndex finds the last element which satisfies a predicate function that also receives the index.
+// Returns Some(element) if found, None if no element matches.
+//
+//go:inline
+func FindLastWithIndex[A any](pred func(int, A) bool) func([]A) O.Option[A] {
+	return G.FindLastWithIndex[[]A](pred)
+}
+
+// FindLastMap finds the last element for which the selector function returns Some.
+// This combines finding and mapping in a single operation, searching from the end.
+//
+//go:inline
+func FindLastMap[A, B any](sel func(A) O.Option[B]) func([]A) O.Option[B] {
+	return G.FindLastMap[[]A](sel)
+}
+
+// FindLastMapWithIndex finds the last element for which the selector function returns Some.
+// The selector receives both the index and the element, searching from the end.
+//
+//go:inline
+func FindLastMapWithIndex[A, B any](sel func(int, A) O.Option[B]) func([]A) O.Option[B] {
+	return G.FindLastMapWithIndex[[]A](sel)
+}
--- a/v2/array/find_test.go
+++ b/v2/array/find_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 array
+
+import (
+	"fmt"
+	"testing"
+
+	O "github.com/IBM/fp-go/v2/option"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFindFirstWithIndex(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	finder := FindFirstWithIndex(func(i, x int) bool {
+		return i > 2 && x%2 == 0
+	})
+	result := finder(src)
+	assert.Equal(t, O.Some(4), result)
+
+	notFound := FindFirstWithIndex(func(i, x int) bool {
+		return i > 10
+	})
+	assert.Equal(t, O.None[int](), notFound(src))
+}
+
+func TestFindFirstMap(t *testing.T) {
+	src := []string{"a", "42", "b", "100"}
+	finder := FindFirstMap(func(s string) O.Option[int] {
+		if len(s) > 1 {
+			return O.Some(len(s))
+		}
+		return O.None[int]()
+	})
+	result := finder(src)
+	assert.Equal(t, O.Some(2), result)
+}
+
+func TestFindFirstMapWithIndex(t *testing.T) {
+	src := []string{"a", "b", "c", "d"}
+	finder := FindFirstMapWithIndex(func(i int, s string) O.Option[string] {
+		if i > 1 {
+			return O.Some(fmt.Sprintf("%d:%s", i, s))
+		}
+		return O.None[string]()
+	})
+	result := finder(src)
+	assert.Equal(t, O.Some("2:c"), result)
+}
+
+func TestFindLast(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	finder := FindLast(func(x int) bool { return x%2 == 0 })
+	result := finder(src)
+	assert.Equal(t, O.Some(4), result)
+
+	notFound := FindLast(func(x int) bool { return x > 10 })
+	assert.Equal(t, O.None[int](), notFound(src))
+}
+
+func TestFindLastWithIndex(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	finder := FindLastWithIndex(func(i, x int) bool {
+		return i < 3 && x%2 == 0
+	})
+	result := finder(src)
+	assert.Equal(t, O.Some(2), result)
+}
+
+func TestFindLastMap(t *testing.T) {
+	src := []string{"a", "42", "b", "100"}
+	finder := FindLastMap(func(s string) O.Option[int] {
+		if len(s) > 1 {
+			return O.Some(len(s))
+		}
+		return O.None[int]()
+	})
+	result := finder(src)
+	assert.Equal(t, O.Some(3), result)
+}
+
+func TestFindLastMapWithIndex(t *testing.T) {
+	src := []string{"a", "b", "c", "d"}
+	finder := FindLastMapWithIndex(func(i int, s string) O.Option[string] {
+		if i < 3 {
+			return O.Some(fmt.Sprintf("%d:%s", i, s))
+		}
+		return O.None[string]()
+	})
+	result := finder(src)
+	assert.Equal(t, O.Some("2:c"), result)
+}
--- a/v2/array/generic/any.go
+++ b/v2/array/generic/any.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 generic
+
+import (
+	F "github.com/IBM/fp-go/v2/function"
+	O "github.com/IBM/fp-go/v2/option"
+)
+
+// AnyWithIndex tests if any of the elements in the array matches the predicate
+func AnyWithIndex[AS ~[]A, PRED ~func(int, A) bool, A any](pred PRED) func(AS) bool {
+	return F.Flow2(
+		FindFirstWithIndex[AS](pred),
+		O.IsSome[A],
+	)
+}
+
+// Any tests if any of the elements in the array matches the predicate
+func Any[AS ~[]A, PRED ~func(A) bool, A any](pred PRED) func(AS) bool {
+	return AnyWithIndex[AS](F.Ignore1of2[int](pred))
+}
--- a/v2/array/generic/array.go
+++ b/v2/array/generic/array.go
@@ -0,0 +1,366 @@
+// 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 (
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/internal/array"
+	FC "github.com/IBM/fp-go/v2/internal/functor"
+	M "github.com/IBM/fp-go/v2/monoid"
+	O "github.com/IBM/fp-go/v2/option"
+	"github.com/IBM/fp-go/v2/tuple"
+)
+
+// Of constructs a single element array
+func Of[GA ~[]A, A any](value A) GA {
+	return GA{value}
+}
+
+func Reduce[GA ~[]A, A, B any](f func(B, A) B, initial B) func(GA) B {
+	return func(as GA) B {
+		return MonadReduce[GA](as, f, initial)
+	}
+}
+
+func ReduceWithIndex[GA ~[]A, A, B any](f func(int, B, A) B, initial B) func(GA) B {
+	return func(as GA) B {
+		return MonadReduceWithIndex[GA](as, f, initial)
+	}
+}
+
+func ReduceRight[GA ~[]A, A, B any](f func(A, B) B, initial B) func(GA) B {
+	return func(as GA) B {
+		return MonadReduceRight[GA](as, f, initial)
+	}
+}
+
+func ReduceRightWithIndex[GA ~[]A, A, B any](f func(int, A, B) B, initial B) func(GA) B {
+	return func(as GA) B {
+		return MonadReduceRightWithIndex[GA](as, f, initial)
+	}
+}
+
+func MonadReduce[GA ~[]A, A, B any](fa GA, f func(B, A) B, initial B) B {
+	return array.Reduce(fa, f, initial)
+}
+
+func MonadReduceWithIndex[GA ~[]A, A, B any](fa GA, f func(int, B, A) B, initial B) B {
+	return array.ReduceWithIndex(fa, f, initial)
+}
+
+func MonadReduceRight[GA ~[]A, A, B any](fa GA, f func(A, B) B, initial B) B {
+	return array.ReduceRight(fa, f, initial)
+}
+
+func MonadReduceRightWithIndex[GA ~[]A, A, B any](fa GA, f func(int, A, B) B, initial B) B {
+	return array.ReduceRightWithIndex(fa, f, initial)
+}
+
+// From constructs an array from a set of variadic arguments
+func From[GA ~[]A, A any](data ...A) GA {
+	return data
+}
+
+// MakeBy returns a `Array` of length `n` with element `i` initialized with `f(i)`.
+func MakeBy[AS ~[]A, F ~func(int) A, A any](n int, f F) AS {
+	// sanity check
+	if n <= 0 {
+		return Empty[AS]()
+	}
+	// run the generator function across the input
+	as := make(AS, n)
+	for i := n - 1; i >= 0; i-- {
+		as[i] = f(i)
+	}
+	return as
+}
+
+func Replicate[AS ~[]A, A any](n int, a A) AS {
+	return MakeBy[AS](n, F.Constant1[int](a))
+}
+
+func Lookup[GA ~[]A, A any](idx int) func(GA) O.Option[A] {
+	none := O.None[A]()
+	if idx < 0 {
+		return F.Constant1[GA](none)
+	}
+	return func(as GA) O.Option[A] {
+		if idx < len(as) {
+			return O.Some(as[idx])
+		}
+		return none
+	}
+}
+
+func Tail[GA ~[]A, A any](as GA) O.Option[GA] {
+	if array.IsEmpty(as) {
+		return O.None[GA]()
+	}
+	return O.Some(as[1:])
+}
+
+func Head[GA ~[]A, A any](as GA) O.Option[A] {
+	if array.IsEmpty(as) {
+		return O.None[A]()
+	}
+	return O.Some(as[0])
+}
+
+func First[GA ~[]A, A any](as GA) O.Option[A] {
+	return Head(as)
+}
+
+func Last[GA ~[]A, A any](as GA) O.Option[A] {
+	if array.IsEmpty(as) {
+		return O.None[A]()
+	}
+	return O.Some(as[len(as)-1])
+}
+
+func Append[GA ~[]A, A any](as GA, a A) GA {
+	return array.Append(as, a)
+}
+
+func Empty[GA ~[]A, A any]() GA {
+	return array.Empty[GA]()
+}
+
+func UpsertAt[GA ~[]A, A any](a A) func(GA) GA {
+	return array.UpsertAt[GA](a)
+}
+
+func MonadMap[GA ~[]A, GB ~[]B, A, B any](as GA, f func(a A) B) GB {
+	return array.MonadMap[GA, GB](as, f)
+}
+
+func Map[GA ~[]A, GB ~[]B, A, B any](f func(a A) B) func(GA) GB {
+	return array.Map[GA, GB](f)
+}
+
+func MonadMapWithIndex[GA ~[]A, GB ~[]B, A, B any](as GA, f func(int, A) B) GB {
+	return array.MonadMapWithIndex[GA, GB](as, f)
+}
+
+func MapWithIndex[GA ~[]A, GB ~[]B, A, B any](f func(int, A) B) func(GA) GB {
+	return F.Bind2nd(MonadMapWithIndex[GA, GB, A, B], f)
+}
+
+func Size[GA ~[]A, A any](as GA) int {
+	return len(as)
+}
+
+func filterMap[GA ~[]A, GB ~[]B, A, B any](fa GA, f func(A) O.Option[B]) GB {
+	result := make(GB, 0, len(fa))
+	for _, a := range fa {
+		O.Map(func(b B) B {
+			result = append(result, b)
+			return b
+		})(f(a))
+	}
+	return result
+}
+
+func filterMapWithIndex[GA ~[]A, GB ~[]B, A, B any](fa GA, f func(int, A) O.Option[B]) GB {
+	result := make(GB, 0, len(fa))
+	for i, a := range fa {
+		O.Map(func(b B) B {
+			result = append(result, b)
+			return b
+		})(f(i, a))
+	}
+	return result
+}
+
+func MonadFilterMap[GA ~[]A, GB ~[]B, A, B any](fa GA, f func(A) O.Option[B]) GB {
+	return filterMap[GA, GB](fa, f)
+}
+
+func MonadFilterMapWithIndex[GA ~[]A, GB ~[]B, A, B any](fa GA, f func(int, A) O.Option[B]) GB {
+	return filterMapWithIndex[GA, GB](fa, f)
+}
+
+func filterWithIndex[AS ~[]A, PRED ~func(int, A) bool, A any](fa AS, pred PRED) AS {
+	result := make(AS, 0, len(fa))
+	for i, a := range fa {
+		if pred(i, a) {
+			result = append(result, a)
+		}
+	}
+	return result
+}
+
+func FilterWithIndex[AS ~[]A, PRED ~func(int, A) bool, A any](pred PRED) func(AS) AS {
+	return F.Bind2nd(filterWithIndex[AS, PRED, A], pred)
+}
+
+func Filter[AS ~[]A, PRED ~func(A) bool, A any](pred PRED) func(AS) AS {
+	return FilterWithIndex[AS](F.Ignore1of2[int](pred))
+}
+
+func FilterChain[GA ~[]A, GB ~[]B, A, B any](f func(a A) O.Option[GB]) func(GA) GB {
+	return F.Flow2(
+		FilterMap[GA, []GB](f),
+		Flatten[[]GB],
+	)
+}
+
+func Flatten[GAA ~[]GA, GA ~[]A, A any](mma GAA) GA {
+	return MonadChain(mma, F.Identity[GA])
+}
+
+func FilterMap[GA ~[]A, GB ~[]B, A, B any](f func(A) O.Option[B]) func(GA) GB {
+	return F.Bind2nd(MonadFilterMap[GA, GB, A, B], f)
+}
+
+func FilterMapWithIndex[GA ~[]A, GB ~[]B, A, B any](f func(int, A) O.Option[B]) func(GA) GB {
+	return F.Bind2nd(MonadFilterMapWithIndex[GA, GB, A, B], f)
+}
+
+func MonadPartition[GA ~[]A, A any](as GA, pred func(A) bool) tuple.Tuple2[GA, GA] {
+	left := Empty[GA]()
+	right := Empty[GA]()
+	array.Reduce(as, func(c bool, a A) bool {
+		if pred(a) {
+			right = append(right, a)
+		} else {
+			left = append(left, a)
+		}
+		return c
+	}, true)
+	// returns the partition
+	return tuple.MakeTuple2(left, right)
+}
+
+func Partition[GA ~[]A, A any](pred func(A) bool) func(GA) tuple.Tuple2[GA, GA] {
+	return F.Bind2nd(MonadPartition[GA, A], pred)
+}
+
+func MonadChain[AS ~[]A, BS ~[]B, A, B any](fa AS, f func(a A) BS) BS {
+	return array.Reduce(fa, func(bs BS, a A) BS {
+		return append(bs, f(a)...)
+	}, Empty[BS]())
+}
+
+func Chain[AS ~[]A, BS ~[]B, A, B any](f func(A) BS) func(AS) BS {
+	return F.Bind2nd(MonadChain[AS, BS, A, B], f)
+}
+
+func MonadAp[BS ~[]B, ABS ~[]func(A) B, AS ~[]A, B, A any](fab ABS, fa AS) BS {
+	return MonadChain(fab, F.Bind1st(MonadMap[AS, BS, A, B], fa))
+}
+
+func Ap[BS ~[]B, ABS ~[]func(A) B, AS ~[]A, B, A any](fa AS) func(ABS) BS {
+	return F.Bind2nd(MonadAp[BS, ABS, AS], fa)
+}
+
+func IsEmpty[AS ~[]A, A any](as AS) bool {
+	return array.IsEmpty(as)
+}
+
+func IsNil[GA ~[]A, A any](as GA) bool {
+	return array.IsNil(as)
+}
+
+func IsNonNil[GA ~[]A, A any](as GA) bool {
+	return array.IsNonNil(as)
+}
+
+func Match[AS ~[]A, A, B any](onEmpty func() B, onNonEmpty func(AS) B) func(AS) B {
+	return func(as AS) B {
+		if IsEmpty(as) {
+			return onEmpty()
+		}
+		return onNonEmpty(as)
+	}
+}
+
+func MatchLeft[AS ~[]A, A, B any](onEmpty func() B, onNonEmpty func(A, AS) B) func(AS) B {
+	return func(as AS) B {
+		if IsEmpty(as) {
+			return onEmpty()
+		}
+		return onNonEmpty(as[0], as[1:])
+	}
+}
+
+//go:inline
+func Slice[AS ~[]A, A any](start int, end int) func(AS) AS {
+	return array.Slice[AS](start, end)
+}
+
+//go:inline
+func SliceRight[AS ~[]A, A any](start int) func(AS) AS {
+	return array.SliceRight[AS](start)
+}
+
+func Copy[AS ~[]A, A any](b AS) AS {
+	buf := make(AS, len(b))
+	copy(buf, b)
+	return buf
+}
+
+func Clone[AS ~[]A, A any](f func(A) A) func(as AS) AS {
+	// implementation assumes that map does not optimize for the empty array
+	return Map[AS, AS](f)
+}
+
+func FoldMap[AS ~[]A, A, B any](m M.Monoid[B]) func(func(A) B) func(AS) B {
+	empty := m.Empty()
+	concat := m.Concat
+	return func(f func(A) B) func(AS) B {
+		return func(as AS) B {
+			return array.Reduce(as, func(cur B, a A) B {
+				return concat(cur, f(a))
+			}, empty)
+		}
+	}
+}
+
+func FoldMapWithIndex[AS ~[]A, A, B any](m M.Monoid[B]) func(func(int, A) B) func(AS) B {
+	empty := m.Empty()
+	concat := m.Concat
+	return func(f func(int, A) B) func(AS) B {
+		return func(as AS) B {
+			return array.ReduceWithIndex(as, func(idx int, cur B, a A) B {
+				return concat(cur, f(idx, a))
+			}, empty)
+		}
+	}
+}
+
+func Fold[AS ~[]A, A any](m M.Monoid[A]) func(AS) A {
+	empty := m.Empty()
+	concat := m.Concat
+	return func(as AS) A {
+		return array.Reduce(as, concat, empty)
+	}
+}
+
+func Push[ENDO ~func(GA) GA, GA ~[]A, A any](a A) ENDO {
+	return F.Bind2nd(array.Push[GA, A], a)
+}
+
+func MonadFlap[FAB ~func(A) B, GFAB ~[]FAB, GB ~[]B, A, B any](fab GFAB, a A) GB {
+	return FC.MonadFlap(MonadMap[GFAB, GB], fab, a)
+}
+
+func Flap[FAB ~func(A) B, GFAB ~[]FAB, GB ~[]B, A, B any](a A) func(GFAB) GB {
+	return FC.Flap(Map[GFAB, GB], a)
+}
+
+func Prepend[ENDO ~func(AS) AS, AS []A, A any](head A) ENDO {
+	return array.Prepend[ENDO](head)
+}
--- a/v2/array/generic/bind.go
+++ b/v2/array/generic/bind.go
@@ -0,0 +1,163 @@
+// 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 (
+	A "github.com/IBM/fp-go/v2/internal/apply"
+	C "github.com/IBM/fp-go/v2/internal/chain"
+	F "github.com/IBM/fp-go/v2/internal/functor"
+)
+
+// Do creates an empty context of type [S] to be used with the [Bind] operation.
+// This is the starting point for do-notation style composition.
+//
+// Example:
+//
+//	type State struct {
+//	    X int
+//	    Y int
+//	}
+//	result := generic.Do[[]State, State](State{})
+func Do[GS ~[]S, S any](
+	empty S,
+) GS {
+	return Of[GS](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2].
+// This enables sequential composition where each step can depend on the results of previous steps.
+// For arrays, this produces the cartesian product where later steps can use values from earlier steps.
+//
+// The setter function takes the result of the computation and returns a function that
+// updates the context from S1 to S2.
+//
+// Example:
+//
+//	type State struct {
+//	    X int
+//	    Y int
+//	}
+//
+//	result := F.Pipe2(
+//	    generic.Do[[]State, State](State{}),
+//	    generic.Bind[[]State, []State, []int, State, State, int](
+//	        func(x int) func(State) State {
+//	            return func(s State) State { s.X = x; return s }
+//	        },
+//	        func(s State) []int {
+//	            return []int{1, 2, 3}
+//	        },
+//	    ),
+//	    generic.Bind[[]State, []State, []int, State, State, int](
+//	        func(y int) func(State) State {
+//	            return func(s State) State { s.Y = y; return s }
+//	        },
+//	        func(s State) []int {
+//	            // This can access s.X from the previous step
+//	            return []int{s.X * 10, s.X * 20}
+//	        },
+//	    ),
+//	) // Produces: {1,10}, {1,20}, {2,20}, {2,40}, {3,30}, {3,60}
+func Bind[GS1 ~[]S1, GS2 ~[]S2, GT ~[]T, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) GT,
+) func(GS1) GS2 {
+	return C.Bind(
+		Chain[GS1, GS2, S1, S2],
+		Map[GT, GS2, T, S2],
+		setter,
+		f,
+	)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[GS1 ~[]S1, GS2 ~[]S2, S1, S2, T any](
+	key func(T) func(S1) S2,
+	f func(S1) T,
+) func(GS1) GS2 {
+	return F.Let(
+		Map[GS1, GS2, S1, S2],
+		key,
+		f,
+	)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[GS1 ~[]S1, GS2 ~[]S2, S1, S2, B any](
+	key func(B) func(S1) S2,
+	b B,
+) func(GS1) GS2 {
+	return F.LetTo(
+		Map[GS1, GS2, S1, S2],
+		key,
+		b,
+	)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[GS1 ~[]S1, GT ~[]T, S1, T any](
+	setter func(T) S1,
+) func(GT) GS1 {
+	return C.BindTo(
+		Map[GT, GS1, T, S1],
+		setter,
+	)
+}
+
+// ApS attaches a value to a context [S1] to produce a context [S2] by considering
+// the context and the value concurrently (using Applicative rather than Monad).
+// This allows independent computations to be combined without one depending on the result of the other.
+//
+// Unlike Bind, which sequences operations, ApS can be used when operations are independent
+// and can conceptually run in parallel. For arrays, this produces the cartesian product.
+//
+// Example:
+//
+//	type State struct {
+//	    X int
+//	    Y string
+//	}
+//
+//	// These operations are independent and can be combined with ApS
+//	xValues := []int{1, 2}
+//	yValues := []string{"a", "b"}
+//
+//	result := F.Pipe2(
+//	    generic.Do[[]State, State](State{}),
+//	    generic.ApS[[]State, []State, []int, State, State, int](
+//	        func(x int) func(State) State {
+//	            return func(s State) State { s.X = x; return s }
+//	        },
+//	        xValues,
+//	    ),
+//	    generic.ApS[[]State, []State, []string, State, State, string](
+//	        func(y string) func(State) State {
+//	            return func(s State) State { s.Y = y; return s }
+//	        },
+//	        yValues,
+//	    ),
+//	) // [{1,"a"}, {1,"b"}, {2,"a"}, {2,"b"}]
+func ApS[GS1 ~[]S1, GS2 ~[]S2, GT ~[]T, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa GT,
+) func(GS1) GS2 {
+	return A.ApS(
+		Ap[GS2, []func(T) S2, GT, S2, T],
+		Map[GS1, []func(T) S2, S1, func(T) S2],
+		setter,
+		fa,
+	)
+}
--- a/v2/array/generic/find.go
+++ b/v2/array/generic/find.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 generic
+
+import (
+	F "github.com/IBM/fp-go/v2/function"
+	O "github.com/IBM/fp-go/v2/option"
+)
+
+// FindFirstWithIndex finds the first element which satisfies a predicate (or a refinement) function
+func FindFirstWithIndex[AS ~[]A, PRED ~func(int, A) bool, A any](pred PRED) func(AS) O.Option[A] {
+	none := O.None[A]()
+	return func(as AS) O.Option[A] {
+		for i, a := range as {
+			if pred(i, a) {
+				return O.Some(a)
+			}
+		}
+		return none
+	}
+}
+
+// FindFirst finds the first element which satisfies a predicate (or a refinement) function
+func FindFirst[AS ~[]A, PRED ~func(A) bool, A any](pred PRED) func(AS) O.Option[A] {
+	return FindFirstWithIndex[AS](F.Ignore1of2[int](pred))
+}
+
+// FindFirstMapWithIndex finds the first element returned by an [O.Option] based selector function
+func FindFirstMapWithIndex[AS ~[]A, PRED ~func(int, A) O.Option[B], A, B any](pred PRED) func(AS) O.Option[B] {
+	none := O.None[B]()
+	return func(as AS) O.Option[B] {
+		count := len(as)
+		for i := 0; i < count; i++ {
+			out := pred(i, as[i])
+			if O.IsSome(out) {
+				return out
+			}
+		}
+		return none
+	}
+}
+
+// FindFirstMap finds the first element returned by an [O.Option] based selector function
+func FindFirstMap[AS ~[]A, PRED ~func(A) O.Option[B], A, B any](pred PRED) func(AS) O.Option[B] {
+	return FindFirstMapWithIndex[AS](F.Ignore1of2[int](pred))
+}
+
+// FindLastWithIndex finds the first element which satisfies a predicate (or a refinement) function
+func FindLastWithIndex[AS ~[]A, PRED ~func(int, A) bool, A any](pred PRED) func(AS) O.Option[A] {
+	none := O.None[A]()
+	return func(as AS) O.Option[A] {
+		for i := len(as) - 1; i >= 0; i-- {
+			a := as[i]
+			if pred(i, a) {
+				return O.Some(a)
+			}
+		}
+		return none
+	}
+}
+
+// FindLast finds the first element which satisfies a predicate (or a refinement) function
+func FindLast[AS ~[]A, PRED ~func(A) bool, A any](pred PRED) func(AS) O.Option[A] {
+	return FindLastWithIndex[AS](F.Ignore1of2[int](pred))
+}
+
+// FindLastMapWithIndex finds the first element returned by an [O.Option] based selector function
+func FindLastMapWithIndex[AS ~[]A, PRED ~func(int, A) O.Option[B], A, B any](pred PRED) func(AS) O.Option[B] {
+	none := O.None[B]()
+	return func(as AS) O.Option[B] {
+		for i := len(as) - 1; i >= 0; i-- {
+			out := pred(i, as[i])
+			if O.IsSome(out) {
+				return out
+			}
+		}
+		return none
+	}
+}
+
+// FindLastMap finds the first element returned by an [O.Option] based selector function
+func FindLastMap[AS ~[]A, PRED ~func(A) O.Option[B], A, B any](pred PRED) func(AS) O.Option[B] {
+	return FindLastMapWithIndex[AS](F.Ignore1of2[int](pred))
+}
--- a/v2/array/generic/monad.go
+++ b/v2/array/generic/monad.go
@@ -0,0 +1,43 @@
+// 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 generic
+
+import (
+	"github.com/IBM/fp-go/v2/internal/monad"
+)
+
+type arrayMonad[A, B any, GA ~[]A, GB ~[]B, GAB ~[]func(A) B] struct{}
+
+func (o *arrayMonad[A, B, GA, GB, GAB]) Of(a A) GA {
+	return Of[GA, A](a)
+}
+
+func (o *arrayMonad[A, B, GA, GB, GAB]) Map(f func(A) B) func(GA) GB {
+	return Map[GA, GB, A, B](f)
+}
+
+func (o *arrayMonad[A, B, GA, GB, GAB]) Chain(f func(A) GB) func(GA) GB {
+	return Chain[GA, GB, A, B](f)
+}
+
+func (o *arrayMonad[A, B, GA, GB, GAB]) Ap(fa GA) func(GAB) GB {
+	return Ap[GB, GAB, GA, B, A](fa)
+}
+
+// Monad implements the monadic operations for an array
+func Monad[A, B any, GA ~[]A, GB ~[]B, GAB ~[]func(A) B]() monad.Monad[A, B, GA, GB, GAB] {
+	return &arrayMonad[A, B, GA, GB, GAB]{}
+}
--- a/v2/array/generic/sort.go
+++ b/v2/array/generic/sort.go
@@ -0,0 +1,56 @@
+// 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 (
+	"sort"
+
+	F "github.com/IBM/fp-go/v2/function"
+	O "github.com/IBM/fp-go/v2/ord"
+)
+
+// Sort implements a stable sort on the array given the provided ordering
+func Sort[GA ~[]T, T any](ord O.Ord[T]) func(ma GA) GA {
+	return SortByKey[GA](ord, F.Identity[T])
+}
+
+// SortByKey implements a stable sort on the array given the provided ordering on an extracted key
+func SortByKey[GA ~[]T, K, T any](ord O.Ord[K], f func(T) K) func(ma GA) GA {
+
+	return func(ma GA) GA {
+		// nothing to sort
+		l := len(ma)
+		if l < 2 {
+			return ma
+		}
+		// copy
+		cpy := make(GA, l)
+		copy(cpy, ma)
+		sort.Slice(cpy, func(i, j int) bool {
+			return ord.Compare(f(cpy[i]), f(cpy[j])) < 0
+		})
+		return cpy
+	}
+}
+
+// SortBy implements a stable sort on the array given the provided ordering
+func SortBy[GA ~[]T, GO ~[]O.Ord[T], T any](ord GO) func(ma GA) GA {
+	return F.Pipe2(
+		ord,
+		Fold[GO](O.Monoid[T]()),
+		Sort[GA, T],
+	)
+}
--- a/v2/array/generic/uniq.go
+++ b/v2/array/generic/uniq.go
@@ -0,0 +1,32 @@
+package generic
+
+import F "github.com/IBM/fp-go/v2/function"
+
+// StrictUniq converts an array of arbitrary items into an array or unique items
+// where uniqueness is determined by the built-in uniqueness constraint
+func StrictUniq[AS ~[]A, A comparable](as AS) AS {
+	return Uniq[AS](F.Identity[A])(as)
+}
+
+// uniquePredUnsafe returns a predicate on a map for uniqueness
+func uniquePredUnsafe[PRED ~func(A) K, A any, K comparable](f PRED) func(int, A) bool {
+	lookup := make(map[K]bool)
+	return func(_ int, a A) bool {
+		k := f(a)
+		_, has := lookup[k]
+		if has {
+			return false
+		}
+		lookup[k] = true
+		return true
+	}
+}
+
+// Uniq converts an array of arbitrary items into an array or unique items
+// where uniqueness is determined based on a key extractor function
+func Uniq[AS ~[]A, PRED ~func(A) K, A any, K comparable](f PRED) func(as AS) AS {
+	return func(as AS) AS {
+		// we need to create a new predicate for each iteration
+		return filterWithIndex(as, uniquePredUnsafe(f))
+	}
+}
--- a/v2/array/generic/zip.go
+++ b/v2/array/generic/zip.go
@@ -0,0 +1,52 @@
+// 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 (
+	F "github.com/IBM/fp-go/v2/function"
+	N "github.com/IBM/fp-go/v2/number"
+	T "github.com/IBM/fp-go/v2/tuple"
+)
+
+// ZipWith applies a function to pairs of elements at the same index in two arrays, collecting the results in a new array. If one
+// input array is short, excess elements of the longer array are discarded.
+func ZipWith[AS ~[]A, BS ~[]B, CS ~[]C, FCT ~func(A, B) C, A, B, C any](fa AS, fb BS, f FCT) CS {
+	l := N.Min(len(fa), len(fb))
+	res := make(CS, l)
+	for i := l - 1; i >= 0; i-- {
+		res[i] = f(fa[i], fb[i])
+	}
+	return res
+}
+
+// Zip takes two arrays and returns an array of corresponding pairs. If one input array is short, excess elements of the
+// longer array are discarded
+func Zip[AS ~[]A, BS ~[]B, CS ~[]T.Tuple2[A, B], A, B any](fb BS) func(AS) CS {
+	return F.Bind23of3(ZipWith[AS, BS, CS, func(A, B) T.Tuple2[A, B]])(fb, T.MakeTuple2[A, B])
+}
+
+// Unzip is the function is reverse of [Zip]. Takes an array of pairs and return two corresponding arrays
+func Unzip[AS ~[]A, BS ~[]B, CS ~[]T.Tuple2[A, B], A, B any](cs CS) T.Tuple2[AS, BS] {
+	l := len(cs)
+	as := make(AS, l)
+	bs := make(BS, l)
+	for i := l - 1; i >= 0; i-- {
+		t := cs[i]
+		as[i] = t.F1
+		bs[i] = t.F2
+	}
+	return T.MakeTuple2(as, bs)
+}
--- a/v2/array/magma.go
+++ b/v2/array/magma.go
@@ -0,0 +1,40 @@
+// 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 array
+
+import (
+	M "github.com/IBM/fp-go/v2/monoid"
+)
+
+// ConcatAll concatenates all elements of an array using the provided Monoid.
+// This reduces the array to a single value by repeatedly applying the Monoid's concat operation.
+//
+// Example:
+//
+//	import "github.com/IBM/fp-go/v2/monoid"
+//
+//	// Sum all numbers
+//	sumAll := array.ConcatAll(monoid.MonoidSum[int]())
+//	result := sumAll([]int{1, 2, 3, 4, 5}) // 15
+//
+//	// Concatenate all strings
+//	concatStrings := array.ConcatAll(monoid.MonoidString())
+//	result2 := concatStrings([]string{"Hello", " ", "World"}) // "Hello World"
+//
+//go:inline
+func ConcatAll[A any](m M.Monoid[A]) func([]A) A {
+	return Reduce(m.Concat, m.Empty())
+}
--- a/v2/array/magma_test.go
+++ b/v2/array/magma_test.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 array
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	M "github.com/IBM/fp-go/v2/monoid"
+)
+
+var subInt = M.MakeMonoid(func(first int, second int) int {
+	return first - second
+}, 0)
+
+func TestConcatAll(t *testing.T) {
+
+	var subAll = ConcatAll(subInt)
+
+	assert.Equal(t, subAll([]int{1, 2, 3}), -6)
+
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Dr. Carsten Leue	0c742b81e6	fix: better performance for either Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-08 10:01:14 +01:00
Dr. Carsten Leue	a1d6c94b15	fix: run benchmarks Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-08 09:31:48 +01:00
Dr. Carsten Leue	e4e28a6556	fix: more Kleisli simplified types Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-07 17:53:47 +01:00
Dr. Carsten Leue	7e7cc06f11	fix: add more Kleisli definitions Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-07 17:42:54 +01:00
Dr. Carsten Leue	54d5dbd04a	fix: more tests for iso and prism Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-07 17:31:27 +01:00
Dr. Carsten Leue	51adce0c95	fix: better package import Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-07 16:15:16 +01:00
Dr. Carsten Leue	aa5e908810	fix: introduce Kleisli type Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-07 14:35:46 +01:00
Dr. Carsten Leue	b3bd5e9ad3	fix: bind docs Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-06 16:18:15 +01:00
Dr. Carsten Leue	178df09ff7	fix: document ApS Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-06 16:08:35 +01:00
Dr. Carsten Leue	92eb9715bd	fix: implement some useful prisms Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-06 13:53:02 +01:00
Dr. Carsten Leue	41ebb04ae0	fix: upload coverage to coverall Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-06 11:45:01 +01:00
Dr. Carsten Leue	b2705e3adf	fix: disable to version updates Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-06 11:39:17 +01:00
renovate[bot]	b232183e47	chore(config): migrate config renovate.json (#143 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-11-06 11:26:23 +01:00
Dr. Carsten Leue	0f9f89f16d	doc: improve documentation Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-06 11:20:50 +01:00
Dr. Carsten Leue	0d3a8634b1	fix: add inline annotations Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-06 10:54:24 +01:00
Dr. Carsten Leue	56c8f1b034	fix: fix build Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-06 09:57:58 +01:00
Dr. Carsten Leue	bad86cd769	fix: try to fix build Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-06 09:50:03 +01:00
Dr. Carsten Leue	d0c5f32111	fix: add go 1.25 to build matrix Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-06 09:43:27 +01:00
renovate[bot]	77745c1348	fix(deps): update go dependencies (#142 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-11-06 09:39:27 +01:00
李鑫	2c96cef500	feat: add array.MonadReduce() function (#132 ) Signed-off-by: lixin <lixin@dustess.com> Co-authored-by: lixin <lixin@dustess.com>	2025-11-06 09:28:20 +01:00
Carsten Leue	3385c705dc	Implement v2 using type aliases (#141 ) * fix: initial checkin of v2 Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: slowly migrate IO Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: migrate MonadTraverseArray and TraverseArray Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: migrate traversal Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: complete migration of IO Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: migrate ioeither Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: refactorY Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: next step in migration Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: adjust IO generation code Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: get rid of more IO methods Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: get rid of more IO * fix: convert iooption Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: convert reader Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: convert a bit of reader Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: new build script Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: cleanup Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: reformat Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: simplify Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: some cleanup Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: adjust Pair to Haskell semantic Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: documentation and testcases Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: some performance optimizations Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: remove coverage Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> * fix: better doc Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com> --------- Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2025-11-06 09:27:00 +01:00
ibm-mend-app[bot]	7874859c4b	Add .whitesource configuration file (#140 ) Co-authored-by: ibm-mend-app[bot] <142626574+ibm-mend-app[bot]@users.noreply.github.com>	2025-11-06 09:22:43 +01:00
renovate[bot]	25e3d1d85c	fix(deps): update module github.com/stretchr/testify to v1.11.1 (#139 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-08-27 22:40:53 +00:00
renovate[bot]	d7ff994fb7	fix(deps): update module github.com/stretchr/testify to v1.11.0 (#138 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-08-25 01:44:33 +00:00
renovate[bot]	1cdca552b2	chore(deps): update actions/checkout action to v4.3.0 (#137 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-08-11 18:38:27 +00:00
renovate[bot]	73480ca030	fix(deps): update module github.com/urfave/cli/v2 to v2.27.7 (#136 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-06-14 10:26:20 +00:00
renovate[bot]	734e2b0055	chore(deps): update actions/setup-node action to v4.4.0 (#134 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-04-14 10:54:36 +00:00
renovate[bot]	4c28859e89	chore(deps): update actions/setup-node action to v4.3.0 (#131 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-03-17 06:44:51 +00:00
renovate[bot]	a516849c07	fix(deps): update module github.com/urfave/cli/v2 to v2.27.6 (#130 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-03-05 22:50:57 +00:00
sarabande	29200d34dc	docs(iterator): update Cycle function documentation (#128 )	2025-03-02 00:21:41 +01:00
renovate[bot]	7a3989989b	chore(deps): update actions/setup-node action to v4.2.0 (#127 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-01-27 22:04:25 +00:00
renovate[bot]	6a6d53f025	fix(deps): update module github.com/stretchr/testify to v1.10.0 (#126 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2024-11-23 15:33:28 +00:00
renovate[bot]	078da752cd	chore(deps): update actions/setup-node action to v4.1.0	2024-10-24 20:12:43 +00:00
renovate[bot]	1a489fde27	chore(deps): update actions/checkout action to v4.2.2	2024-10-23 19:31:36 +00:00
renovate[bot]	a135b2acae	fix(deps): update module github.com/urfave/cli/v2 to v2.27.5	2024-10-13 20:09:16 +00:00
renovate[bot]	9e9dfa1f5f	chore(deps): update actions/checkout action to v4.2.1	2024-10-07 22:39:01 +00:00
renovate[bot]	dd87ea12b3	chore(deps): update actions/checkout action to v4.2.0	2024-09-25 21:29:08 +00:00
renovate[bot]	5fc0d18c97	chore(deps): update actions/setup-node action to v4.0.4	2024-09-19 20:14:45 +00:00
CRaLFa	76c1297576	fix typos in README and comment (#119 ) Signed-off-by: CRaLFa <minami.smd@gmail.com>	2024-09-12 09:40:19 +02:00
Dr. Carsten Leue	68aeb4c725	fix: script Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2024-08-27 16:57:59 +02:00
Dr. Carsten Leue	53f3fa1828	fix: semantic release Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2024-08-27 16:43:21 +02:00
Dr. Carsten Leue	97e1e4d92d	fix: add test for go 1.23 Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2024-08-27 16:39:52 +02:00
Dr. Carsten Leue	ec57d5cd4a	fix: go mod tidy Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2024-08-27 16:37:22 +02:00
renovate[bot]	0ae5b43724	fix(deps): update module github.com/urfave/cli/v2 to v2.27.4	2024-08-11 19:12:08 +00:00
renovate[bot]	e73e14c0ae	fix(deps): update module github.com/urfave/cli/v2 to v2.27.3	2024-07-25 03:34:59 +00:00
renovate[bot]	325bc376f9	chore(deps): update actions/setup-node action to v4.0.3	2024-07-09 20:06:20 +00:00
Dr. Carsten Leue	f646ace9fe	chore: git mod tidy Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2024-06-24 09:24:15 +02:00
Laglangyue	9f8161fbc1	chore: ignore fp-go file for unix machine (#115 ) Signed-off-by: tangjiafu <tangjiafu@apache.org> Co-authored-by: tangjiafu <tangjiafu@apache.org>	2024-06-24 09:22:40 +02:00
renovate[bot]	1c4f2c0403	chore(deps): update actions/checkout action to v4.1.7	2024-06-13 02:39:23 +00:00
Dr. Carsten Leue	3b3b80aed0	fix: some more tests Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2024-05-27 11:54:04 +02:00
Dr. Carsten Leue	fdff4e4735	fix: more tests Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2024-05-26 16:23:40 +02:00
Dr. Carsten Leue	391754e5a6	fix: more testing Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2024-05-25 15:41:32 +02:00
Dr. Carsten Leue	598a7b261b	fix: add more tests Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2024-05-24 23:19:24 +02:00
Dr. Carsten Leue	f0f1a48965	fix: do not use v8 Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2024-05-24 21:43:36 +02:00
Dr. Carsten Leue	e39e5e0920	fix: add missing Fold to ReaderIOEither Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2024-05-24 12:55:20 +02:00
李鑫	9c7a5bb24b	fix: string format of pair.pairString() (#113 ) Signed-off-by: lixin <lixin@dustess.com> Co-authored-by: lixin <lixin@dustess.com>	2024-05-20 21:48:24 +02:00
renovate[bot]	89bda4f500	chore(deps): update actions/checkout action to v4.1.6	2024-05-17 05:37:34 +00:00
renovate[bot]	15dffb3256	chore(deps): update actions/checkout action to v4.1.5	2024-05-09 02:10:28 +00:00
t-hg	95fbd93696	Fix typo (#106 ) Opertator -> Operator	2024-04-29 08:47:26 +02:00
renovate[bot]	6e0d5704bc	fix(deps): update module github.com/urfave/cli/v2 to v2.27.2	2024-04-27 19:09:18 +00:00
renovate[bot]	0aa95e656b	chore(deps): update actions/checkout action to v4.1.4	2024-04-25 18:08:51 +00:00
renovate[bot]	b3544a32fc	chore(deps): update actions/checkout action to v4.1.3	2024-04-22 16:18:16 +00:00
Dr. Carsten Leue	9ad9b4a9bf	fix: update dependencies Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2024-03-20 21:43:03 +01:00
Francis Zhou	74763bdadc	correct the generic type for FromIO (#104 ) Signed-off-by: francis <francis.tm@me.com>	2024-03-11 16:18:30 +01:00
renovate[bot]	9aa2ae041f	fix(deps): update module github.com/stretchr/testify to v1.9.0	2024-03-02 18:23:13 +00:00
Dr. Carsten Leue	d356fa3c89	fix: more auto generated templates fo DI Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2024-02-29 16:27:23 +01:00