fix: add Do and Bind support to Monads

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

.github/workflows/build.yml

@@ -4,7 +4,9 @@ on:
   push:
     branches:
       - main
+
   pull_request:
+
   workflow_dispatch:
     inputs:
       dryRun:
@@ -13,109 +15,35 @@ on:
         required: false
 
 env:
+  # Currently no way to detect automatically
   DEFAULT_BRANCH: main
-  LATEST_GO_VERSION: 1.25.2 # renovate: datasource=golang-version depName=golang
-  NODE_VERSION: 24
+  GO_VERSION: 1.21.6 # renovate: datasource=golang-version depName=golang
+  NODE_VERSION: 20
   DRY_RUN: true
 
 jobs:
-  build-v1:
-    name: Build v1 (Go ${{ matrix.go-version }})
+  build:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        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
+        go-version: [ '1.20.x', '1.21.x']
     steps:
       # full checkout for semantic-release
-      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         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 }}
-          cache: true  # Enable Go module caching
-      - name: Run tests
+      -
+        name: Tests
         run: |
           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: ./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
+          go test -v ./...
 
   release:
-    name: Release
-    needs:
-      - build-v1
-      - build-v2
+    needs: [build]
     if: github.repository == 'IBM/fp-go' && github.event_name != 'pull_request'
     runs-on: ubuntu-latest
     timeout-minutes: 15
@@ -123,37 +51,38 @@ jobs:
       contents: write
       issues: write
       pull-requests: write
+
     steps:
       # full checkout for semantic-release
       - name: Full checkout
-        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         with:
           fetch-depth: 0
 
       - name: Set up Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+        uses: actions/setup-node@b39b52d1213e96004bfcb1c61a8a6fa8ab84f3e8 # v4.0.1
         with:
           node-version: ${{ env.NODE_VERSION }}
 
-      - name: Set up Go
+      - name: Set up go ${{env.GO_VERSION}}
         uses: actions/setup-go@v5
         with:
-          go-version: ${{ env.LATEST_GO_VERSION }}
-          cache: true  # Enable Go module caching
+          go-version: ${{env.GO_VERSION}}
 
-      - name: Determine release mode
-        id: release-mode
+      # 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
         run: |
-          if [[ "${{ github.event_name }}" == "workflow_dispatch" && "${{ github.event.inputs.dryRun }}" != "true" ]]; then
+          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
             echo "DRY_RUN=false" >> $GITHUB_ENV
-          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
+          elif [[ "${{github.ref}}" =~ ^refs/heads/v[0-9]+(\.[0-9]+)?$ ]]; then
             echo "DRY_RUN=false" >> $GITHUB_ENV
           fi
 
-      - name: Run semantic release
+      - name: 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 }}
+  

.gitignore

@@ -1,5 +1,4 @@
 fp-go.exe
-fp-go
 main.exe
 build/
 .idea

.whitesource

@@ -1,3 +0,0 @@
-{
-  "settingsInheritedFrom": "ibm-mend-config/mend-config@main"
-}

README.md

@@ -1,312 +1,207 @@
-# fp-go: Functional Programming Library for Go
+# Functional programming library for golang
 
-[![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.
+**🚧 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.
 
 ![logo](resources/images/logo.png)
 
-A comprehensive functional programming library for Go, strongly influenced by the excellent [fp-ts](https://github.com/gcanti/fp-ts) library for TypeScript.
+This library is strongly influenced by the awesome [fp-ts](https://github.com/gcanti/fp-ts).
 
-## 📚 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
+## Getting started
 
 ```bash
 go get github.com/IBM/fp-go
 ```
 
-### Quick Example
+Refer to the [samples](./samples/).
 
-```go
-import (
-    "errors"
-    "github.com/IBM/fp-go/either"
-    "github.com/IBM/fp-go/function"
-)
+Find API documentation [here](https://pkg.go.dev/github.com/IBM/fp-go)
 
-// 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)
-}
+## Design Goal
 
-// 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
-```
+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:
 
-### Resources
+- 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
 
-- 📖 [API Documentation](https://pkg.go.dev/github.com/IBM/fp-go)
-- 💡 [Code Samples](./samples/)
-- 🆕 [V2 Documentation](./v2/README.md) (requires Go 1.24+)
+### How does this play with the [🧘🏽 Zen Of Go](https://the-zen-of-go.netlify.app/)?
 
-## 🎯 Design Goals
+#### 🧘🏽 Each package fulfils a single purpose
 
-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:
+✔️ 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.
 
-### Core Principles
+#### 🧘🏽 Handle errors explicitly
 
-- **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
+✔️ 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.
 
-### 🧘🏽 Alignment with the Zen of Go
+#### 🧘🏽 Return early rather than nesting deeply
 
-This library respects and aligns with [The Zen of Go](https://the-zen-of-go.netlify.app/):
+✔️ 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.
 
-| 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 |
+#### 🧘🏽 Leave concurrency to the caller
 
-## 💡 Core Concepts
+✔️ All pure are synchronous by default. The I/O operations are asynchronous per default.
 
-### Data Types
+#### 🧘🏽 Before you launch a goroutine, know when it will stop
 
-The library provides several key functional 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.
 
-- **`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
+#### 🧘🏽 Avoid package level state
 
-### Monadic Operations
+✔️ No package level state anywhere, this would be a significant anti-pattern
 
-All data types support common monadic operations:
+#### 🧘🏽 Simplicity matters
 
-- **`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
+✔️ 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.
 
 ## Comparison to Idiomatic Go
 
-This section explains how functional APIs differ from idiomatic Go and how to convert between them.
+In this section we discuss how the functional APIs differ from idiomatic go function signatures and how to convert back and forth.
 
-### Pure Functions
+### Pure functions
 
-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.
+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.
 
 #### Without Errors
 
-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
-}
-```
+If your pure function does not return an error, the idiomatic signature is just fine and no changes are required.
 
 #### With Errors
 
-**Idiomatic Go:**
-```go
-func divide(a, b int) (int, error) {
-    if b == 0 {
-        return 0, errors.New("division by zero")
-    }
-    return a / b, nil
-}
-```
+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.
 
-**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)
-}
-```
+### Effectful functions
 
-**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.
+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.
 
 #### Without Errors
 
-**Functional signature:** `IO[T]`
-
-```go
-func getCurrentTime() io.IO[time.Time] {
-    return func() time.Time {
-        return time.Now()
-    }
-}
-```
+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)
 
 #### With Errors
 
-**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
+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.
 
 ### Go Context
 
-Functions that take a `context.Context` are effectful because they depend on mutable 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.
 
-**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
+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.
 
 ## Implementation Notes
 
 ### Generics
 
-All monadic operations use Go generics for type safety:
+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.
 
-- ✅ **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
+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.
 
 ### Ordering of Generic Type Parameters
 
-Go requires all type parameters on the global function definition. Parameters that cannot be auto-detected come first:
+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
-// 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]
+func Map[A, B any](f func(A) B) [R, E any]func(fa ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B]
 ```
 
-This ordering maximizes type inference where possible.
+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:
 
-### Use of the ~ Operator
+```go
+func Map[R, E, A, B any](f func(A) B) func(fa ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B]
+```
 
-Go doesn't support generic type aliases (until Go 1.24), only type definitions. The `~` operator allows generic implementations to work with compatible types:
+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
 type ReaderIOEither[R, E, A any] RD.Reader[R, IOE.IOEither[E, A]]
 ```
 
-**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
+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.
 
-### Higher Kinded Types (HKT)
+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.
 
-Go doesn't support HKT natively. This library addresses this by:
+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*.
 
-- Introducing HKTs as individual types (e.g., `HKTA` for `HKT[A]`)
-- Implementing generic algorithms in the `internal` package
-- Keeping complexity hidden from end-users
+### Higher Kinded Types
 
-## Common Operations
+Go does not support higher kinded types (HKT). Such types occur if a generic type itself is parametrized by another generic type. Example:
 
-### 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
+The `Map` operation for `ReaderIOEither` is defined as:
 
 ```go
-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 }),
-)
+func Map[R, E, A, B any](f func(A) B) func(fa ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B]
 ```
 
-## 📚 Resources
+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):
 
-- [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
+```go
+func Map[HKT, R, E, A, B any](f func(A) B) func(HKT[R, E, A]) HKT[R, E, B]
+```
 
-## 🤝 Contributing
+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.
 
-Contributions are welcome! Please feel free to submit issues or pull requests.
+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.
 
-## 📄 License
+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.
 
-This project is licensed under the Apache License 2.0 - see the LICENSE file for details.
+## 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]` |

array/array.go

@@ -58,7 +58,7 @@ func MapWithIndex[A, B any](f func(int, A) B) func([]A) []B {
 }
 
 func Map[A, B any](f func(a A) B) func([]A) []B {
-	return G.Map[[]A, []B, A, B](f)
+	return F.Bind2nd(MonadMap[A, B], f)
 }
 
 func MapRef[A, B any](f func(a *A) B) func([]A) []B {
@@ -141,10 +141,6 @@ 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)
 }

array/generic/array.go

@@ -147,7 +147,7 @@ func MonadMap[GA ~[]A, GB ~[]B, A, B any](as GA, f func(a A) B) GB {
 }
 
 func Map[GA ~[]A, GB ~[]B, A, B any](f func(a A) B) func(GA) GB {
-	return array.Map[GA, GB](f)
+	return F.Bind2nd(MonadMap[GA, GB, A, B], f)
 }
 
 func MonadMapWithIndex[GA ~[]A, GB ~[]B, A, B any](as GA, f func(int, A) B) GB {
@@ -344,7 +344,7 @@ func MonadFlap[FAB ~func(A) B, GFAB ~[]FAB, GB ~[]B, A, B any](fab GFAB, a A) GB
 }
 
 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)
+	return F.Bind2nd(MonadFlap[FAB, GFAB, GB, A, B], a)
 }
 
 func Prepend[ENDO ~func(AS) AS, AS []A, A any](head A) ENDO {

array/generic/monad.go

@@ -1,43 +0,0 @@
-// 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/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]{}
-}

array/monad.go

@@ -1,26 +0,0 @@
-// 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 array
-
-import (
-	G "github.com/IBM/fp-go/array/generic"
-	"github.com/IBM/fp-go/internal/monad"
-)
-
-// Monad returns the monadic operations for an array
-func Monad[A, B any]() monad.Monad[A, B, []A, []B, []func(A) B] {
-	return G.Monad[A, B, []A, []B, []func(A) B]()
-}

array/nonempty/array.go

@@ -44,11 +44,11 @@ func From[A any](first A, data ...A) NonEmptyArray[A] {
 	return buffer
 }
 
-func IsEmpty[A any](_ NonEmptyArray[A]) bool {
+func IsEmpty[A any](as NonEmptyArray[A]) bool {
 	return false
 }
 
-func IsNonEmpty[A any](_ NonEmptyArray[A]) bool {
+func IsNonEmpty[A any](as NonEmptyArray[A]) bool {
 	return true
 }
 

bounded/bounded.go

@@ -32,20 +32,20 @@ type bounded[T any] struct {
 	b T
 }
 
-func (b bounded[T]) Equals(x, y T) bool {
-	return b.e(x, y)
+func (self bounded[T]) Equals(x, y T) bool {
+	return self.e(x, y)
 }
 
-func (b bounded[T]) Compare(x, y T) int {
-	return b.c(x, y)
+func (self bounded[T]) Compare(x, y T) int {
+	return self.c(x, y)
 }
 
-func (b bounded[T]) Top() T {
-	return b.t
+func (self bounded[T]) Top() T {
+	return self.t
 }
 
-func (b bounded[T]) Bottom() T {
-	return b.b
+func (self bounded[T]) Bottom() T {
+	return self.b
 }
 
 // MakeBounded creates an instance of a bounded type

bytes/bytes.go

@@ -15,10 +15,6 @@
 
 package bytes
 
-func Empty() []byte {
-	return Monoid.Empty()
-}
-
 func ToString(a []byte) string {
 	return string(a)
 }

cli/contextreaderioeither.go

@@ -365,70 +365,6 @@ 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 {
@@ -484,12 +420,10 @@ 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)

cli/pipe.go

@@ -265,15 +265,10 @@ func generatePipe(f *os.File, i int) {
 		fmt.Fprintf(f, ", f%d F%d", j, j)
 	}
 	fmt.Fprintf(f, ") T%d {\n", i)
-	fmt.Fprintf(f, "  return ")
-	for j := i; j >= 1; j-- {
-		fmt.Fprintf(f, "f%d(", j)
-	}
-	fmt.Fprintf(f, "t0")
 	for j := 1; j <= i; j++ {
-		fmt.Fprintf(f, ")")
+		fmt.Fprintf(f, "  t%d := f%d(t%d)\n", j, j, j-1)
 	}
-	fmt.Fprintf(f, "\n")
+	fmt.Fprintf(f, "  return t%d\n", i)
 	fmt.Fprintln(f, "}")
 }
 

cli/readerioeither.go

@@ -136,70 +136,6 @@ 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 {
@@ -261,16 +197,12 @@ 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

cli/templates/functions.go

@@ -1,15 +0,0 @@
-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))
-}

cli/tuple.go

@@ -405,6 +405,8 @@ func generateTupleHelpers(filename string, count int) error {
 
 	fmt.Fprintf(f, `
 import (
+	"fmt"
+	"encoding/json"
 	M "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/ord"	
 )
@@ -455,7 +457,7 @@ func generateTupleMarshal(f *os.File, i int) {
 	fmt.Fprintf(f, "func (t ")
 	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, ") MarshalJSON() ([]byte, error) {\n")
-	fmt.Fprintf(f, "  return tupleMarshalJSON(")
+	fmt.Fprintf(f, "  return json.Marshal([]any{")
 	// function prototypes
 	for j := 1; j <= i; j++ {
 		if j > 1 {
@@ -463,7 +465,7 @@ func generateTupleMarshal(f *os.File, i int) {
 		}
 		fmt.Fprintf(f, "t.F%d", j)
 	}
-	fmt.Fprintf(f, ")\n")
+	fmt.Fprintf(f, "})\n")
 	fmt.Fprintf(f, "}\n")
 }
 
@@ -473,12 +475,19 @@ func generateTupleUnmarshal(f *os.File, i int) {
 	fmt.Fprintf(f, "func (t *")
 	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, ") UnmarshalJSON(data []byte) error {\n")
-	fmt.Fprintf(f, "  return tupleUnmarshalJSON(data")
-	// function prototypes
+	fmt.Fprintf(f, "  var tmp []json.RawMessage\n")
+	fmt.Fprintf(f, "  if err := json.Unmarshal(data, &tmp); err != nil {return err}\n")
+	fmt.Fprintf(f, "  l := len(tmp)\n")
+	// unmarshal fields
 	for j := 1; j <= i; j++ {
-		fmt.Fprintf(f, ", &t.F%d", j)
+		fmt.Fprintf(f, "  if l > %d {\n", j-1)
+		fmt.Fprintf(f, "  if err := json.Unmarshal(tmp[%d], &t.F%d); err != nil {return err}\n", j-1, j)
 	}
-	fmt.Fprintf(f, ")\n")
+	fmt.Fprintf(f, "  ")
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, "}")
+	}
+	fmt.Fprintf(f, "\n  return nil\n")
 	fmt.Fprintf(f, "}\n")
 }
 
@@ -561,13 +570,30 @@ func generateTupleString(f *os.File, i int) {
 	writeTupleType(f, "T", i)
 	fmt.Fprintf(f, ") String() string {\n")
 	// convert to string
-	fmt.Fprint(f, "  return tupleString(")
+	fmt.Fprintf(f, "  return fmt.Sprintf(\"Tuple%d[", i)
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "%s", "%T")
+	}
+	fmt.Fprintf(f, "](")
+	for j := 1; j <= i; j++ {
+		if j > 1 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "%s", "%v")
+	}
+	fmt.Fprintf(f, ")\", ")
 	for j := 1; j <= i; j++ {
 		if j > 1 {
 			fmt.Fprintf(f, ", ")
 		}
 		fmt.Fprintf(f, "t.F%d", j)
 	}
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, ", t.F%d", j)
+	}
 	fmt.Fprintf(f, ")\n")
 	fmt.Fprintf(f, "}\n")
 }

constant/const.go

@@ -37,7 +37,7 @@ func Of[E, A any](m M.Monoid[E]) func(A) Const[E, A] {
 	return F.Constant1[A](Make[E, A](m.Empty()))
 }
 
-func MonadMap[E, A, B any](fa Const[E, A], _ func(A) B) Const[E, B] {
+func MonadMap[E, A, B any](fa Const[E, A], f func(A) B) Const[E, B] {
 	return Make[E, B](fa.value)
 }
 

context/readerioeither/file/file_test.go

@@ -47,5 +47,5 @@ func ExampleReadFile() {
 	fmt.Println(result())
 
 	// Output:
-	// Right[string](Carsten)
+	// Right[<nil>, string](Carsten)
 }

context/readerioeither/file/write.go

@@ -26,7 +26,7 @@ import (
 func onWriteAll[W io.Writer](data []byte) func(w W) RIOE.ReaderIOEither[[]byte] {
 	return func(w W) RIOE.ReaderIOEither[[]byte] {
 		return F.Pipe1(
-			RIOE.TryCatch(func(_ context.Context) func() ([]byte, error) {
+			RIOE.TryCatch(func(ctx context.Context) func() ([]byte, error) {
 				return func() ([]byte, error) {
 					_, err := w.Write(data)
 					return data, err

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
-// 2024-05-24 22:24:01.4250895 +0200 CEST m=+0.014515801
+// 2023-10-23 08:30:39.012572 +0200 CEST m=+0.008846101
 
 import (
 	"context"
@@ -17,24 +17,12 @@ 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)
@@ -86,12 +74,6 @@ 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)
@@ -143,12 +125,6 @@ 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)
@@ -200,12 +176,6 @@ 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)
@@ -257,12 +227,6 @@ 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)
@@ -314,12 +278,6 @@ 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)
@@ -371,12 +329,6 @@ 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)
@@ -428,12 +380,6 @@ 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)
@@ -485,12 +431,6 @@ 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)
@@ -542,12 +482,6 @@ 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)

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
-// 2024-05-24 22:24:01.4250895 +0200 CEST m=+0.014515801
+// 2023-10-23 08:30:39.012572 +0200 CEST m=+0.008846101
 
 import (
 	"context"
@@ -19,28 +19,12 @@ 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,
@@ -185,14 +169,6 @@ 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,
@@ -388,14 +364,6 @@ 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,
@@ -642,14 +610,6 @@ 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,
@@ -947,14 +907,6 @@ 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,
@@ -1303,14 +1255,6 @@ 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,
@@ -1710,14 +1654,6 @@ 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,
@@ -2168,14 +2104,6 @@ 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,
@@ -2677,14 +2605,6 @@ 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,
@@ -3237,14 +3157,6 @@ 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,

context/readerioeither/generic/reader.go

@@ -182,7 +182,10 @@ func withCancelCauseFunc[
 		ma,
 		IOE.Swap[GIOA, func() E.Either[A, error]],
 		IOE.ChainFirstIOK[func() E.Either[A, error], func() any](func(err error) func() any {
-			return IO.FromImpure[func() any](func() { cancel(err) })
+			return IO.MakeIO[func() any](func() any {
+				cancel(err)
+				return nil
+			})
 		}),
 		IOE.Swap[func() E.Either[A, error], GIOA],
 	)

context/readerioeither/http/builder/builder.go

@@ -61,7 +61,7 @@ func Requester(builder *R.Builder) RIOEH.Requester {
 	return F.Pipe5(
 		builder.GetBody(),
 		O.Fold(LZ.Of(E.Of[error](withoutBody)), E.Map[error](withBody)),
-		E.Ap[func(string) RIOE.ReaderIOEither[*http.Request]](builder.GetTargetURL()),
+		E.Ap[func(string) RIOE.ReaderIOEither[*http.Request]](builder.GetTargetUrl()),
 		E.Flap[error, RIOE.ReaderIOEither[*http.Request]](builder.GetMethod()),
 		E.GetOrElse(RIOE.Left[*http.Request]),
 		RIOE.Map(func(req *http.Request) *http.Request {

context/readerioeither/http/builder/builder_test.go

@@ -32,12 +32,12 @@ import (
 func TestBuilderWithQuery(t *testing.T) {
 	// add some query
 	withLimit := R.WithQueryArg("limit")("10")
-	withURL := R.WithURL("http://www.example.org?a=b")
+	withUrl := R.WithUrl("http://www.example.org?a=b")
 
 	b := F.Pipe2(
 		R.Default,
 		withLimit,
-		withURL,
+		withUrl,
 	)
 
 	req := F.Pipe3(

context/readerioeither/http/request.go

@@ -26,7 +26,7 @@ import (
 	IOE "github.com/IBM/fp-go/ioeither"
 	IOEF "github.com/IBM/fp-go/ioeither/file"
 	J "github.com/IBM/fp-go/json"
-	P "github.com/IBM/fp-go/pair"
+	T "github.com/IBM/fp-go/tuple"
 )
 
 type (
@@ -79,7 +79,7 @@ func ReadFullResponse(client Client) func(Requester) RIOE.ReaderIOEither[H.FullR
 						IOE.Of[error, io.ReadCloser],
 						IOEF.ReadAll[io.ReadCloser],
 					),
-					IOE.Map[error](F.Bind1st(P.MakePair[*http.Response, []byte], resp)),
+					IOE.Map[error](F.Bind1st(T.MakeTuple2[*http.Response, []byte], resp)),
 				)
 			}),
 		)
@@ -103,27 +103,16 @@ func ReadText(client Client) func(Requester) RIOE.ReaderIOEither[string] {
 }
 
 // ReadJson sends a request, reads the response and parses the response as JSON
-//
-// Deprecated: use [ReadJSON] instead
 func ReadJson[A any](client Client) func(Requester) RIOE.ReaderIOEither[A] {
-	return ReadJSON[A](client)
-}
-
-func readJSON(client Client) func(Requester) RIOE.ReaderIOEither[[]byte] {
 	return F.Flow3(
 		ReadFullResponse(client),
 		RIOE.ChainFirstEitherK(F.Flow2(
 			H.Response,
-			H.ValidateJSONResponse,
+			H.ValidateJsonResponse,
+		)),
+		RIOE.ChainEitherK(F.Flow2(
+			H.Body,
+			J.Unmarshal[A],
 		)),
-		RIOE.Map(H.Body),
-	)
-}
-
-// ReadJSON sends a request, reads the response and parses the response as JSON
-func ReadJSON[A any](client Client) func(Requester) RIOE.ReaderIOEither[A] {
-	return F.Flow2(
-		readJSON(client),
-		RIOE.ChainEitherK(J.Unmarshal[A]),
 	)
 }

context/readerioeither/http/request_test.go

@@ -31,7 +31,7 @@ import (
 )
 
 type PostItem struct {
-	UserID uint   `json:"userId"`
+	UserId uint   `json:"userId"`
 	Id     uint   `json:"id"`
 	Title  string `json:"title"`
 	Body   string `json:"body"`
@@ -84,7 +84,7 @@ func TestSendSingleRequest(t *testing.T) {
 
 	req1 := MakeGetRequest("https://jsonplaceholder.typicode.com/posts/1")
 
-	readItem := ReadJSON[PostItem](client)
+	readItem := ReadJson[PostItem](client)
 
 	resp1 := readItem(req1)
 
@@ -112,7 +112,7 @@ func TestSendSingleRequestWithHeaderUnsafe(t *testing.T) {
 		R.Map(setHeaderUnsafe("Content-Type", "text/html")),
 	)
 
-	readItem := ReadJSON[PostItem](client)
+	readItem := ReadJson[PostItem](client)
 
 	resp1 := F.Pipe2(
 		req1,
@@ -140,7 +140,7 @@ func TestSendSingleRequestWithHeaderSafe(t *testing.T) {
 		WithHeader("Content-Type", "text/html").
 		Build()
 
-	readItem := ReadJSON[PostItem](client)
+	readItem := ReadJson[PostItem](client)
 
 	response := F.Pipe2(
 		request,

context/readerioeither/reader.go

@@ -25,7 +25,6 @@ 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] {
@@ -193,7 +192,8 @@ 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,15 +204,3 @@ 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)
-}

coverage.bat

@@ -1,3 +1,2 @@
 @echo off
-go tool cover -html=build/cover.out -o build/cover.html
-cov-report -ex ".*/cli/.*.go|.*/gen.go|.*/binds.go" build\cover.out
+go tool cover -html=build/cover.out -o build/cover.html

di/doc.go

@@ -40,4 +40,4 @@
 // [MakeInjector]: [github.com/IBM/fp-go/di/erasure.MakeInjector]
 package di
 
-//go:generate go run .. di --count 15 --filename gen.go
+//go:generate go run .. di --count 10 --filename gen.go

di/erasure/injector.go

@@ -127,7 +127,7 @@ func MakeInjector(providers []Provider) InjectableFactory {
 	var resolved sync.Map
 
 	// provide a mapping for all providers
-	factoryByID := assembleProviders(providers)
+	factoryById := assembleProviders(providers)
 
 	// the actual factory, we need lazy initialization
 	var injFct InjectableFactory
@@ -149,7 +149,7 @@ func MakeInjector(providers []Provider) InjectableFactory {
 					T.Map2(F.Flow3(
 						Dependency.Id,
 						R.Lookup[ProviderFactory, string],
-						I.Ap[O.Option[ProviderFactory]](factoryByID),
+						I.Ap[O.Option[ProviderFactory]](factoryById),
 					), handleMissingProvider),
 					T.Tupled2(O.MonadGetOrElse[ProviderFactory]),
 					IG.Ap[ProviderFactory](injFct),

di/gen.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2024-02-29 16:18:47.9991921 +0100 CET m=+0.012914901
+// 2023-12-18 21:40:11.0891062 +0100 CET m=+0.007755601
 
 package di
 
@@ -41,7 +41,7 @@ func MakeProviderFactory1[T1 any, R any](
 	)
 }
 
-// MakeTokenWithDefault1 creates an [InjectionToken] with a default implementation with 1 dependencies
+// MakeTokenWithDefault1 creates an [InjectionToken] with a default implementation with 1 dependenciess
 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 dependencies
+// MakeTokenWithDefault2 creates an [InjectionToken] with a default implementation with 2 dependenciess
 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 dependencies
+// MakeTokenWithDefault3 creates an [InjectionToken] with a default implementation with 3 dependenciess
 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 dependencies
+// MakeTokenWithDefault4 creates an [InjectionToken] with a default implementation with 4 dependenciess
 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 dependencies
+// MakeTokenWithDefault5 creates an [InjectionToken] with a default implementation with 5 dependenciess
 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 dependencies
+// MakeTokenWithDefault6 creates an [InjectionToken] with a default implementation with 6 dependenciess
 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 dependencies
+// MakeTokenWithDefault7 creates an [InjectionToken] with a default implementation with 7 dependenciess
 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 dependencies
+// MakeTokenWithDefault8 creates an [InjectionToken] with a default implementation with 8 dependenciess
 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 dependencies
+// MakeTokenWithDefault9 creates an [InjectionToken] with a default implementation with 9 dependenciess
 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 dependencies
+// MakeTokenWithDefault10 creates an [InjectionToken] with a default implementation with 10 dependenciess
 func MakeTokenWithDefault10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any, R any](
 	name string,
 	d1 Dependency[T1],
@@ -1011,878 +1011,3 @@ 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,
-		))
-}

di/provider.go

@@ -41,7 +41,7 @@ func eraseTuple[A, R any](f func(A) IOE.IOEither[error, R]) func(E.Either[error,
 }
 
 func eraseProviderFactory0[R any](f IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {
-	return func(_ ...any) IOE.IOEither[error, any] {
+	return func(params ...any) IOE.IOEither[error, any] {
 		return F.Pipe1(
 			f,
 			IOE.Map[error](F.ToAny[R]),

di/token.go

@@ -65,38 +65,34 @@ type MultiInjectionToken[T any] interface {
 }
 
 // makeID creates a generator of unique string IDs
-func makeID() IO.IO[string] {
+func makeId() IO.IO[string] {
 	var count atomic.Int64
 	return IO.MakeIO(func() string {
 		return strconv.FormatInt(count.Add(1), 16)
 	})
 }
 
-// genID is the common generator of unique string IDs
-var genID = makeID()
+// genId is the common generator of unique string IDs
+var genId = makeId()
 
-type tokenBase struct {
+type token[T any] struct {
 	name            string
 	id              string
 	flag            int
+	toType          func(val any) E.Either[error, T]
 	providerFactory O.Option[DIE.ProviderFactory]
 }
 
-type token[T any] struct {
-	base   *tokenBase
-	toType func(val any) E.Either[error, T]
-}
-
 func (t *token[T]) Id() string {
-	return t.base.id
+	return t.id
 }
 
 func (t *token[T]) Flag() int {
-	return t.base.flag
+	return t.flag
 }
 
 func (t *token[T]) String() string {
-	return t.base.name
+	return t.name
 }
 
 func (t *token[T]) Unerase(val any) E.Either[error, T] {
@@ -104,14 +100,11 @@ func (t *token[T]) Unerase(val any) E.Either[error, T] {
 }
 
 func (t *token[T]) ProviderFactory() O.Option[DIE.ProviderFactory] {
-	return t.base.providerFactory
-}
-func makeTokenBase(name string, id string, typ int, providerFactory O.Option[DIE.ProviderFactory]) *tokenBase {
-	return &tokenBase{name, id, typ, providerFactory}
+	return t.providerFactory
 }
 
 func makeToken[T any](name string, id string, typ int, unerase func(val any) E.Either[error, T], providerFactory O.Option[DIE.ProviderFactory]) Dependency[T] {
-	return &token[T]{makeTokenBase(name, id, typ, providerFactory), unerase}
+	return &token[T]{name, id, typ, unerase, providerFactory}
 }
 
 type injectionToken[T any] struct {
@@ -143,7 +136,7 @@ func (i *injectionToken[T]) IOOption() Dependency[IOO.IOOption[T]] {
 }
 
 func (i *injectionToken[T]) ProviderFactory() O.Option[DIE.ProviderFactory] {
-	return i.base.providerFactory
+	return i.providerFactory
 }
 
 func (m *multiInjectionToken[T]) Container() InjectionToken[[]T] {
@@ -156,10 +149,10 @@ func (m *multiInjectionToken[T]) Item() InjectionToken[T] {
 
 // makeToken create a unique [InjectionToken] for a specific type
 func makeInjectionToken[T any](name string, providerFactory O.Option[DIE.ProviderFactory]) InjectionToken[T] {
-	id := genID()
+	id := genId()
 	toIdentity := toType[T]()
 	return &injectionToken[T]{
-		token[T]{makeTokenBase(name, id, DIE.Identity, providerFactory), toIdentity},
+		token[T]{name, id, DIE.Identity, toIdentity, providerFactory},
 		makeToken[O.Option[T]](fmt.Sprintf("Option[%s]", name), id, DIE.Option, toOptionType(toIdentity), providerFactory),
 		makeToken[IOE.IOEither[error, T]](fmt.Sprintf("IOEither[%s]", name), id, DIE.IOEither, toIOEitherType(toIdentity), providerFactory),
 		makeToken[IOO.IOOption[T]](fmt.Sprintf("IOOption[%s]", name), id, DIE.IOOption, toIOOptionType(toIdentity), providerFactory),
@@ -178,7 +171,7 @@ func MakeTokenWithDefault[T any](name string, providerFactory DIE.ProviderFactor
 
 // MakeMultiToken creates a [MultiInjectionToken]
 func MakeMultiToken[T any](name string) MultiInjectionToken[T] {
-	id := genID()
+	id := genId()
 	toItem := toType[T]()
 	toContainer := toArrayType(toItem)
 	containerName := fmt.Sprintf("Container[%s]", name)
@@ -187,14 +180,14 @@ func MakeMultiToken[T any](name string) MultiInjectionToken[T] {
 	providerFactory := O.None[DIE.ProviderFactory]()
 	// container
 	container := &injectionToken[[]T]{
-		token[[]T]{makeTokenBase(containerName, id, DIE.Multi|DIE.Identity, providerFactory), toContainer},
+		token[[]T]{containerName, id, DIE.Multi | DIE.Identity, toContainer, providerFactory},
 		makeToken[O.Option[[]T]](fmt.Sprintf("Option[%s]", containerName), id, DIE.Multi|DIE.Option, toOptionType(toContainer), providerFactory),
 		makeToken[IOE.IOEither[error, []T]](fmt.Sprintf("IOEither[%s]", containerName), id, DIE.Multi|DIE.IOEither, toIOEitherType(toContainer), providerFactory),
 		makeToken[IOO.IOOption[[]T]](fmt.Sprintf("IOOption[%s]", containerName), id, DIE.Multi|DIE.IOOption, toIOOptionType(toContainer), providerFactory),
 	}
 	// item
 	item := &injectionToken[T]{
-		token[T]{makeTokenBase(itemName, id, DIE.Item|DIE.Identity, providerFactory), toItem},
+		token[T]{itemName, id, DIE.Item | DIE.Identity, toItem, providerFactory},
 		makeToken[O.Option[T]](fmt.Sprintf("Option[%s]", itemName), id, DIE.Item|DIE.Option, toOptionType(toItem), providerFactory),
 		makeToken[IOE.IOEither[error, T]](fmt.Sprintf("IOEither[%s]", itemName), id, DIE.Item|DIE.IOEither, toIOEitherType(toItem), providerFactory),
 		makeToken[IOO.IOOption[T]](fmt.Sprintf("IOOption[%s]", itemName), id, DIE.Item|DIE.IOOption, toIOOptionType(toItem), providerFactory),

di/utils.go

@@ -25,13 +25,6 @@ import (
 	O "github.com/IBM/fp-go/option"
 )
 
-var (
-	toOptionAny   = toType[O.Option[any]]()
-	toIOEitherAny = toType[IOE.IOEither[error, any]]()
-	toIOOptionAny = toType[IOO.IOOption[any]]()
-	toArrayAny    = toType[[]any]()
-)
-
 // asDependency converts a generic type to a [DIE.Dependency]
 func asDependency[T DIE.Dependency](t T) DIE.Dependency {
 	return t
@@ -45,7 +38,7 @@ func toType[T any]() func(t any) E.Either[error, T] {
 // toOptionType converts an any to an Option[any] and then to an Option[T]
 func toOptionType[T any](item func(any) E.Either[error, T]) func(t any) E.Either[error, O.Option[T]] {
 	return F.Flow2(
-		toOptionAny,
+		toType[O.Option[any]](),
 		E.Chain(O.Fold(
 			F.Nullary2(O.None[T], E.Of[error, O.Option[T]]),
 			F.Flow2(
@@ -59,7 +52,7 @@ func toOptionType[T any](item func(any) E.Either[error, T]) func(t any) E.Either
 // toIOEitherType converts an any to an IOEither[error, any] and then to an IOEither[error, T]
 func toIOEitherType[T any](item func(any) E.Either[error, T]) func(t any) E.Either[error, IOE.IOEither[error, T]] {
 	return F.Flow2(
-		toIOEitherAny,
+		toType[IOE.IOEither[error, any]](),
 		E.Map[error](IOE.ChainEitherK(item)),
 	)
 }
@@ -67,7 +60,7 @@ func toIOEitherType[T any](item func(any) E.Either[error, T]) func(t any) E.Eith
 // toIOOptionType converts an any to an IOOption[any] and then to an IOOption[T]
 func toIOOptionType[T any](item func(any) E.Either[error, T]) func(t any) E.Either[error, IOO.IOOption[T]] {
 	return F.Flow2(
-		toIOOptionAny,
+		toType[IOO.IOOption[any]](),
 		E.Map[error](IOO.ChainOptionK(F.Flow2(
 			item,
 			E.ToOption[error, T],
@@ -78,7 +71,7 @@ func toIOOptionType[T any](item func(any) E.Either[error, T]) func(t any) E.Eith
 // toArrayType converts an any to a []T
 func toArrayType[T any](item func(any) E.Either[error, T]) func(t any) E.Either[error, []T] {
 	return F.Flow2(
-		toArrayAny,
+		toType[[]any](),
 		E.Chain(E.TraverseArray(item)),
 	)
 }

either/array_test.go

@@ -1,10 +1,8 @@
 package either
 
 import (
-	"fmt"
 	"testing"
 
-	TST "github.com/IBM/fp-go/internal/testing"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -18,33 +16,3 @@ 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)
-}

either/core.go

@@ -20,45 +20,30 @@ import (
 )
 
 type (
-	either struct {
-		isLeft bool
-		value  any
-	}
-
 	// Either defines a data structure that logically holds either an E or an A. The flag discriminates the cases
-	Either[E, A any] either
+	Either[E, A any] struct {
+		isLeft bool
+		left   E
+		right  A
+	}
 )
 
-// String prints some debug info for the object
-//
-//go:noinline
-func eitherString(s *either) string {
-	if s.isLeft {
-		return fmt.Sprintf("Left[%T](%v)", s.value, s.value)
-	}
-	return fmt.Sprintf("Right[%T](%v)", s.value, s.value)
-}
-
-// Format prints some debug info for the object
-//
-//go:noinline
-func eitherFormat(e *either, f fmt.State, c rune) {
-	switch c {
-	case 's':
-		fmt.Fprint(f, eitherString(e))
-	default:
-		fmt.Fprint(f, eitherString(e))
-	}
-}
-
 // String prints some debug info for the object
 func (s Either[E, A]) String() string {
-	return eitherString((*either)(&s))
+	if s.isLeft {
+		return fmt.Sprintf("Left[%T, %T](%v)", s.left, s.right, s.left)
+	}
+	return fmt.Sprintf("Right[%T, %T](%v)", s.left, s.right, s.right)
 }
 
 // Format prints some debug info for the object
 func (s Either[E, A]) Format(f fmt.State, c rune) {
-	eitherFormat((*either)(&s), f, c)
+	switch c {
+	case 's':
+		fmt.Fprint(f, s.String())
+	default:
+		fmt.Fprint(f, s.String())
+	}
 }
 
 // IsLeft tests if the [Either] is a left value. Rather use [Fold] if you need to access the values. Inverse is [IsRight].
@@ -73,29 +58,23 @@ 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]{isLeft: true, left: value}
 }
 
 // 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]{isLeft: false, right: value}
 }
 
 // MonadFold extracts the values from an [Either] by invoking the [onLeft] callback or the [onRight] callback depending on the case
 func MonadFold[E, A, B any](ma Either[E, A], onLeft func(e E) B, onRight func(a A) B) B {
 	if ma.isLeft {
-		return onLeft(ma.value.(E))
+		return onLeft(ma.left)
 	}
-	return onRight(ma.value.(A))
+	return onRight(ma.right)
 }
 
 // Unwrap converts an [Either] into the idiomatic tuple
 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
-	}
+	return ma.right, ma.left
 }

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 15 --filename gen.go
+//go:generate go run .. either --count 10 --filename gen.go

either/either.go

@@ -22,7 +22,6 @@ package either
 import (
 	E "github.com/IBM/fp-go/errors"
 	F "github.com/IBM/fp-go/function"
-	C "github.com/IBM/fp-go/internal/chain"
 	FC "github.com/IBM/fp-go/internal/functor"
 	L "github.com/IBM/fp-go/lazy"
 	O "github.com/IBM/fp-go/option"
@@ -33,7 +32,7 @@ func Of[E, A any](value A) Either[E, A] {
 	return F.Pipe1(value, Right[E, A])
 }
 
-func FromIO[E any, IO ~func() A, A any](f IO) Either[E, A] {
+func FromIO[E, IO ~func() A, A any](f IO) Either[E, A] {
 	return F.Pipe1(f(), Right[E, A])
 }
 
@@ -65,7 +64,7 @@ func MonadMapTo[E, A, B any](fa Either[E, A], b B) Either[E, B] {
 }
 
 func MapTo[E, A, B any](b B) func(Either[E, A]) Either[E, B] {
-	return Map[E](F.Constant1[A](b))
+	return F.Bind2nd(MonadMapTo[E, A, B], b)
 }
 
 func MonadMapLeft[E1, A, E2 any](fa Either[E1, A], f func(E1) E2) Either[E2, A] {
@@ -78,7 +77,7 @@ func Map[E, A, B any](f func(a A) B) func(fa Either[E, A]) Either[E, B] {
 
 // MapLeft applies a mapping function to the error channel
 func MapLeft[A, E1, E2 any](f func(E1) E2) func(fa Either[E1, A]) Either[E2, A] {
-	return Fold(F.Flow2(f, Left[A, E2]), Right[E2, A])
+	return F.Bind2nd(MonadMapLeft[E1, A, E2], f)
 }
 
 func MonadChain[E, A, B any](fa Either[E, A], f func(a A) Either[E, B]) Either[E, B] {
@@ -86,15 +85,12 @@ func MonadChain[E, A, B any](fa Either[E, A], f func(a A) Either[E, B]) Either[E
 }
 
 func MonadChainFirst[E, A, B any](ma Either[E, A], f func(a A) Either[E, B]) Either[E, A] {
-	return C.MonadChainFirst(
-		MonadChain[E, A, A],
-		MonadMap[E, B, A],
-		ma,
-		f,
-	)
+	return MonadChain(ma, func(a A) Either[E, A] {
+		return MonadMap(f(a), F.Constant1[B](a))
+	})
 }
 
-func MonadChainTo[A, E, B any](_ Either[E, A], mb Either[E, B]) Either[E, B] {
+func MonadChainTo[A, E, B any](ma Either[E, A], mb Either[E, B]) Either[E, B] {
 	return mb
 }
 
@@ -110,19 +106,15 @@ func ChainOptionK[A, B, E any](onNone func() E) func(func(A) O.Option[B]) func(E
 }
 
 func ChainTo[A, E, B any](mb Either[E, B]) func(Either[E, A]) Either[E, B] {
-	return F.Constant1[Either[E, A]](mb)
+	return F.Bind2nd(MonadChainTo[A, E, B], mb)
 }
 
 func Chain[E, A, B any](f func(a A) Either[E, B]) func(Either[E, A]) Either[E, B] {
-	return Fold(Left[B, E], f)
+	return F.Bind2nd(MonadChain[E, A, B], f)
 }
 
 func ChainFirst[E, A, B any](f func(a A) Either[E, B]) func(Either[E, A]) Either[E, A] {
-	return C.ChainFirst(
-		Chain[E, A, A],
-		Map[E, B, A],
-		f,
-	)
+	return F.Bind2nd(MonadChainFirst[E, A, B], f)
 }
 
 func Flatten[E, A any](mma Either[E, Either[E, A]]) Either[E, A] {
@@ -259,7 +251,7 @@ func MonadFlap[E, B, A any](fab Either[E, func(A) B], a A) Either[E, B] {
 }
 
 func Flap[E, B, A any](a A) func(Either[E, func(A) B]) Either[E, B] {
-	return FC.Flap(Map[E, func(A) B, B], a)
+	return F.Bind2nd(MonadFlap[E, B, A], a)
 }
 
 func MonadAlt[E, A any](fa Either[E, A], that L.Lazy[Either[E, A]]) Either[E, A] {

either/either_test.go

@@ -17,17 +17,21 @@ package either
 
 import (
 	"errors"
-	"fmt"
 	"testing"
 
 	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"
 )
 
+func TestDefault(t *testing.T) {
+	var e Either[error, string]
+
+	assert.Equal(t, Of[error](""), e)
+}
+
 func TestIsLeft(t *testing.T) {
 	err := errors.New("Some error")
 	withError := Left[string](err)
@@ -72,6 +76,7 @@ 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
 
@@ -110,20 +115,3 @@ func TestFromOption(t *testing.T) {
 	assert.Equal(t, Left[int]("none"), FromOption[int](F.Constant("none"))(O.None[int]()))
 	assert.Equal(t, Right[string](1), FromOption[int](F.Constant("none"))(O.Some(1)))
 }
-
-func TestStringer(t *testing.T) {
-	e := Of[error]("foo")
-	exp := "Right[string](foo)"
-
-	assert.Equal(t, exp, e.String())
-
-	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)
-}

either/examples_create_test.go

@@ -48,11 +48,11 @@ func ExampleEither_creation() {
 	fmt.Println(rightFromPred)
 
 	// Output:
-	// Left[*errors.errorString](some error)
-	// Right[string](value)
-	// Left[*errors.errorString](value was nil)
+	// Left[*errors.errorString, string](some error)
+	// Right[<nil>, string](value)
+	// Left[*errors.errorString, *string](value was nil)
 	// true
-	// Left[*errors.errorString](3 is an odd number)
-	// Right[int](4)
+	// Left[*errors.errorString, int](3 is an odd number)
+	// Right[<nil>, int](4)
 
 }

either/examples_extract_test.go

@@ -53,8 +53,8 @@ func ExampleEither_extraction() {
 	fmt.Println(doubleFromRightBis)
 
 	// Output:
-	// Left[*errors.errorString](Division by Zero!)
-	// Right[int](10)
+	// Left[*errors.errorString, int](Division by Zero!)
+	// Right[<nil>, int](10)
 	// 0
 	// 10
 	// 0

either/functor.go

@@ -1,31 +0,0 @@
-// 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]{}
-}

either/gen.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2024-02-29 16:18:50.8721435 +0100 CET m=+0.070394501
+// 2023-10-23 08:30:40.410373 +0200 CEST m=+0.010337601
 
 package either
 
@@ -679,518 +679,3 @@ 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,
-		)
-	}
-}

either/monad.go

@@ -1,43 +0,0 @@
-// 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/monad"
-)
-
-type eitherMonad[E, A, B any] struct{}
-
-func (o *eitherMonad[E, A, B]) Of(a A) Either[E, A] {
-	return Of[E, A](a)
-}
-
-func (o *eitherMonad[E, A, B]) Map(f func(A) B) func(Either[E, A]) Either[E, B] {
-	return Map[E, A, B](f)
-}
-
-func (o *eitherMonad[E, A, B]) Chain(f func(A) Either[E, B]) func(Either[E, A]) Either[E, B] {
-	return Chain[E, A, B](f)
-}
-
-func (o *eitherMonad[E, A, B]) Ap(fa Either[E, A]) func(Either[E, func(A) B]) Either[E, B] {
-	return Ap[B, E, A](fa)
-}
-
-// Monad implements the monadic operations for [Either]
-func Monad[E, A, B any]() monad.Monad[A, B, Either[E, A], Either[E, B], Either[E, func(A) B]] {
-	return &eitherMonad[E, A, B]{}
-}

either/pointed.go

@@ -1,31 +0,0 @@
-// 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]{}
-}

either/traverse.go

@@ -19,17 +19,38 @@ import (
 	F "github.com/IBM/fp-go/function"
 )
 
+/*
+*
+We need to pass the members of the applicative explicitly, because golang does neither support higher kinded types nor template methods on structs or interfaces
+
+HKTRB = HKT<Either[B]>
+HKTA = HKT<A>
+HKTB = HKT<B>
+*/
+func traverse[E, A, B, HKTB, HKTRB any](
+	mof func(Either[E, B]) HKTRB,
+	mmap func(func(B) Either[E, B]) func(HKTB) HKTRB,
+) func(Either[E, A], func(A) HKTB) HKTRB {
+
+	left := F.Flow2(Left[B, E], mof)
+	right := mmap(Right[E, B])
+
+	return func(ta Either[E, A], f func(A) HKTB) HKTRB {
+		return MonadFold(ta,
+			left,
+			F.Flow2(f, right),
+		)
+	}
+}
+
 // Traverse converts an [Either] of some higher kinded type into the higher kinded type of an [Either]
 func Traverse[A, E, B, HKTB, HKTRB any](
 	mof func(Either[E, B]) HKTRB,
 	mmap func(func(B) Either[E, B]) func(HKTB) HKTRB,
 ) func(func(A) HKTB) func(Either[E, A]) HKTRB {
-
-	left := F.Flow2(Left[B, E], mof)
-	right := mmap(Right[E, B])
-
+	delegate := traverse[E, A, B](mof, mmap)
 	return func(f func(A) HKTB) func(Either[E, A]) HKTRB {
-		return Fold(left, F.Flow2(f, right))
+		return F.Bind2nd(delegate, f)
 	}
 }
 

eq/eq.go

@@ -27,8 +27,8 @@ type eq[T any] struct {
 	c func(x, y T) bool
 }
 
-func (e eq[T]) Equals(x, y T) bool {
-	return e.c(x, y)
+func (self eq[T]) Equals(x, y T) bool {
+	return self.c(x, y)
 }
 
 func strictEq[A comparable](a, b A) bool {

exec/exec.go

@@ -16,18 +16,18 @@
 package exec
 
 import (
-	P "github.com/IBM/fp-go/pair"
+	T "github.com/IBM/fp-go/tuple"
 )
 
 type (
 	// CommandOutput represents the output of executing a command. The first field in the [Tuple2] is
 	// stdout, the second one is stderr. Use [StdOut] and [StdErr] to access these fields
-	CommandOutput = P.Pair[[]byte, []byte]
+	CommandOutput = T.Tuple2[[]byte, []byte]
 )
 
 var (
 	// StdOut returns the field of a [CommandOutput] representing `stdout`
-	StdOut = P.Head[[]byte, []byte]
+	StdOut = T.First[[]byte, []byte]
 	// StdErr returns the field of a [CommandOutput] representing `stderr`
-	StdErr = P.Tail[[]byte, []byte]
+	StdErr = T.Second[[]byte, []byte]
 )

file/getters.go

@@ -32,11 +32,6 @@ func ToReader[R io.Reader](r R) io.Reader {
 	return r
 }
 
-// ToWriter converts a [io.Writer]
-func ToWriter[W io.Writer](w W) io.Writer {
-	return w
-}
-
 // ToCloser converts a [io.Closer]
 func ToCloser[C io.Closer](c C) io.Closer {
 	return c

function/binds.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2024-02-29 16:19:01.120389 +0100 CET m=+0.011216001
+// 2023-12-18 09:38:59.1616876 +0100 CET m=+0.008641801
 
 package function
 

function/cache.go

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

function/gen.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2024-02-29 16:18:53.6664566 +0100 CET m=+0.011085101
+// 2023-12-18 09:38:51.4946446 +0100 CET m=+0.008838401
 
 package function
 
@@ -34,7 +34,8 @@ func Unsliced0[F ~func([]T) R, T, R any](f F) func() R {
 // Pipe1 takes an initial value t0 and successively applies 1 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe1[F1 ~func(T0) T1, T0, T1 any](t0 T0, f1 F1) T1 {
-	return f1(t0)
+	t1 := f1(t0)
+	return t1
 }
 
 // Flow1 creates a function that takes an initial value t0 and successively applies 1 functions where the input of a function is the return value of the previous function
@@ -92,7 +93,9 @@ func Unsliced1[F ~func([]T) R, T, R any](f F) func(T) R {
 // Pipe2 takes an initial value t0 and successively applies 2 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe2[F1 ~func(T0) T1, F2 ~func(T1) T2, T0, T1, T2 any](t0 T0, f1 F1, f2 F2) T2 {
-	return f2(f1(t0))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	return t2
 }
 
 // Flow2 creates a function that takes an initial value t0 and successively applies 2 functions where the input of a function is the return value of the previous function
@@ -152,7 +155,10 @@ func Unsliced2[F ~func([]T) R, T, R any](f F) func(T, T) R {
 // Pipe3 takes an initial value t0 and successively applies 3 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe3[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, T0, T1, T2, T3 any](t0 T0, f1 F1, f2 F2, f3 F3) T3 {
-	return f3(f2(f1(t0)))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	return t3
 }
 
 // Flow3 creates a function that takes an initial value t0 and successively applies 3 functions where the input of a function is the return value of the previous function
@@ -214,7 +220,11 @@ func Unsliced3[F ~func([]T) R, T, R any](f F) func(T, T, T) R {
 // Pipe4 takes an initial value t0 and successively applies 4 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe4[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, T0, T1, T2, T3, T4 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4) T4 {
-	return f4(f3(f2(f1(t0))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	return t4
 }
 
 // Flow4 creates a function that takes an initial value t0 and successively applies 4 functions where the input of a function is the return value of the previous function
@@ -278,7 +288,12 @@ func Unsliced4[F ~func([]T) R, T, R any](f F) func(T, T, T, T) R {
 // Pipe5 takes an initial value t0 and successively applies 5 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe5[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, T0, T1, T2, T3, T4, T5 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) T5 {
-	return f5(f4(f3(f2(f1(t0)))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	return t5
 }
 
 // Flow5 creates a function that takes an initial value t0 and successively applies 5 functions where the input of a function is the return value of the previous function
@@ -344,7 +359,13 @@ func Unsliced5[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T) R {
 // Pipe6 takes an initial value t0 and successively applies 6 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe6[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, T0, T1, T2, T3, T4, T5, T6 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) T6 {
-	return f6(f5(f4(f3(f2(f1(t0))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	return t6
 }
 
 // Flow6 creates a function that takes an initial value t0 and successively applies 6 functions where the input of a function is the return value of the previous function
@@ -412,7 +433,14 @@ func Unsliced6[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T) R {
 // Pipe7 takes an initial value t0 and successively applies 7 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe7[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, T0, T1, T2, T3, T4, T5, T6, T7 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) T7 {
-	return f7(f6(f5(f4(f3(f2(f1(t0)))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	return t7
 }
 
 // Flow7 creates a function that takes an initial value t0 and successively applies 7 functions where the input of a function is the return value of the previous function
@@ -482,7 +510,15 @@ func Unsliced7[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T) R {
 // Pipe8 takes an initial value t0 and successively applies 8 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe8[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, T0, T1, T2, T3, T4, T5, T6, T7, T8 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) T8 {
-	return f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	return t8
 }
 
 // Flow8 creates a function that takes an initial value t0 and successively applies 8 functions where the input of a function is the return value of the previous function
@@ -554,7 +590,16 @@ func Unsliced8[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T) R {
 // Pipe9 takes an initial value t0 and successively applies 9 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe9[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) T9 {
-	return f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	return t9
 }
 
 // Flow9 creates a function that takes an initial value t0 and successively applies 9 functions where the input of a function is the return value of the previous function
@@ -628,7 +673,17 @@ func Unsliced9[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T) R
 // Pipe10 takes an initial value t0 and successively applies 10 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe10[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) T10 {
-	return f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	return t10
 }
 
 // Flow10 creates a function that takes an initial value t0 and successively applies 10 functions where the input of a function is the return value of the previous function
@@ -704,7 +759,18 @@ func Unsliced10[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe11 takes an initial value t0 and successively applies 11 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe11[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11) T11 {
-	return f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	return t11
 }
 
 // Flow11 creates a function that takes an initial value t0 and successively applies 11 functions where the input of a function is the return value of the previous function
@@ -782,7 +848,19 @@ func Unsliced11[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe12 takes an initial value t0 and successively applies 12 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe12[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12) T12 {
-	return f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	return t12
 }
 
 // Flow12 creates a function that takes an initial value t0 and successively applies 12 functions where the input of a function is the return value of the previous function
@@ -862,7 +940,20 @@ func Unsliced12[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe13 takes an initial value t0 and successively applies 13 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe13[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13) T13 {
-	return f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	t13 := f13(t12)
+	return t13
 }
 
 // Flow13 creates a function that takes an initial value t0 and successively applies 13 functions where the input of a function is the return value of the previous function
@@ -944,7 +1035,21 @@ func Unsliced13[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe14 takes an initial value t0 and successively applies 14 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe14[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14) T14 {
-	return f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	t13 := f13(t12)
+	t14 := f14(t13)
+	return t14
 }
 
 // Flow14 creates a function that takes an initial value t0 and successively applies 14 functions where the input of a function is the return value of the previous function
@@ -1028,7 +1133,22 @@ func Unsliced14[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe15 takes an initial value t0 and successively applies 15 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe15[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15) T15 {
-	return f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	t13 := f13(t12)
+	t14 := f14(t13)
+	t15 := f15(t14)
+	return t15
 }
 
 // Flow15 creates a function that takes an initial value t0 and successively applies 15 functions where the input of a function is the return value of the previous function
@@ -1114,7 +1234,23 @@ func Unsliced15[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe16 takes an initial value t0 and successively applies 16 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe16[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16) T16 {
-	return f16(f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	t13 := f13(t12)
+	t14 := f14(t13)
+	t15 := f15(t14)
+	t16 := f16(t15)
+	return t16
 }
 
 // Flow16 creates a function that takes an initial value t0 and successively applies 16 functions where the input of a function is the return value of the previous function
@@ -1202,7 +1338,24 @@ func Unsliced16[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe17 takes an initial value t0 and successively applies 17 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe17[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17) T17 {
-	return f17(f16(f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	t13 := f13(t12)
+	t14 := f14(t13)
+	t15 := f15(t14)
+	t16 := f16(t15)
+	t17 := f17(t16)
+	return t17
 }
 
 // Flow17 creates a function that takes an initial value t0 and successively applies 17 functions where the input of a function is the return value of the previous function
@@ -1292,7 +1445,25 @@ func Unsliced17[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe18 takes an initial value t0 and successively applies 18 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe18[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18) T18 {
-	return f18(f17(f16(f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	t13 := f13(t12)
+	t14 := f14(t13)
+	t15 := f15(t14)
+	t16 := f16(t15)
+	t17 := f17(t16)
+	t18 := f18(t17)
+	return t18
 }
 
 // Flow18 creates a function that takes an initial value t0 and successively applies 18 functions where the input of a function is the return value of the previous function
@@ -1384,7 +1555,26 @@ func Unsliced18[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe19 takes an initial value t0 and successively applies 19 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe19[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, F19 ~func(T18) T19, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18, f19 F19) T19 {
-	return f19(f18(f17(f16(f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0)))))))))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	t13 := f13(t12)
+	t14 := f14(t13)
+	t15 := f15(t14)
+	t16 := f16(t15)
+	t17 := f17(t16)
+	t18 := f18(t17)
+	t19 := f19(t18)
+	return t19
 }
 
 // Flow19 creates a function that takes an initial value t0 and successively applies 19 functions where the input of a function is the return value of the previous function
@@ -1478,7 +1668,27 @@ func Unsliced19[F ~func([]T) R, T, R any](f F) func(T, T, T, T, T, T, T, T, T, T
 // Pipe20 takes an initial value t0 and successively applies 20 functions where the input of a function is the return value of the previous function
 // The final return value is the result of the last function application
 func Pipe20[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, F19 ~func(T18) T19, F20 ~func(T19) T20, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 any](t0 T0, f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18, f19 F19, f20 F20) T20 {
-	return f20(f19(f18(f17(f16(f15(f14(f13(f12(f11(f10(f9(f8(f7(f6(f5(f4(f3(f2(f1(t0))))))))))))))))))))
+	t1 := f1(t0)
+	t2 := f2(t1)
+	t3 := f3(t2)
+	t4 := f4(t3)
+	t5 := f5(t4)
+	t6 := f6(t5)
+	t7 := f7(t6)
+	t8 := f8(t7)
+	t9 := f9(t8)
+	t10 := f10(t9)
+	t11 := f11(t10)
+	t12 := f12(t11)
+	t13 := f13(t12)
+	t14 := f14(t13)
+	t15 := f15(t14)
+	t16 := f16(t15)
+	t17 := f17(t16)
+	t18 := f18(t17)
+	t19 := f19(t18)
+	t20 := f20(t19)
+	return t20
 }
 
 // Flow20 creates a function that takes an initial value t0 and successively applies 20 functions where the input of a function is the return value of the previous function

go.mod

@@ -3,15 +3,15 @@ module github.com/IBM/fp-go
 go 1.20
 
 require (
-	github.com/stretchr/testify v1.11.1
-	github.com/urfave/cli/v2 v2.27.7
+	github.com/stretchr/testify v1.8.4
+	github.com/urfave/cli/v2 v2.27.1
 )
 
 require (
-	github.com/cpuguy83/go-md2man/v2 v2.0.7 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.3 // 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-20240521201337-686a1a2994c1 // indirect
+	github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,33 +1,17 @@
-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/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/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.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=
+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=
 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=

http/builder/builder.go

@@ -16,14 +16,9 @@
 package builder
 
 import (
-	"bytes"
-	"crypto/sha256"
-	"fmt"
 	"net/http"
 	"net/url"
 
-	A "github.com/IBM/fp-go/array"
-	B "github.com/IBM/fp-go/bytes"
 	E "github.com/IBM/fp-go/either"
 	ENDO "github.com/IBM/fp-go/endomorphism"
 	F "github.com/IBM/fp-go/function"
@@ -34,7 +29,6 @@ import (
 	LZ "github.com/IBM/fp-go/lazy"
 	L "github.com/IBM/fp-go/optics/lens"
 	O "github.com/IBM/fp-go/option"
-	R "github.com/IBM/fp-go/record"
 	S "github.com/IBM/fp-go/string"
 	T "github.com/IBM/fp-go/tuple"
 )
@@ -62,11 +56,7 @@ var (
 	Monoid = ENDO.Monoid[*Builder]()
 
 	// Url is a [L.Lens] for the URL
-	//
-	// Deprecated: use [URL] instead
-	Url = L.MakeLensRef((*Builder).GetURL, (*Builder).SetURL)
-	// URL is a [L.Lens] for the URL
-	URL = L.MakeLensRef((*Builder).GetURL, (*Builder).SetURL)
+	Url = L.MakeLensRef((*Builder).GetUrl, (*Builder).SetUrl)
 	// Method is a [L.Lens] for the HTTP method
 	Method = L.MakeLensRef((*Builder).GetMethod, (*Builder).SetMethod)
 	// Body is a [L.Lens] for the request body
@@ -86,19 +76,15 @@ var (
 	noBody     = O.None[E.Either[error, []byte]]()
 	noQueryArg = O.None[string]()
 
-	parseURL   = E.Eitherize1(url.Parse)
+	parseUrl   = E.Eitherize1(url.Parse)
 	parseQuery = E.Eitherize1(url.ParseQuery)
 
 	// WithQuery creates a [Endomorphism] for a complete set of query parameters
 	WithQuery = Query.Set
 	// WithMethod creates a [Endomorphism] for a certain method
 	WithMethod = Method.Set
-	// WithUrl creates a [Endomorphism] for the URL
-	//
-	// Deprecated: use [WithURL] instead
-	WithUrl = URL.Set
-	// WithURL creates a [Endomorphism] for the URL
-	WithURL = URL.Set
+	// WithUrl creates a [Endomorphism] for a certain method
+	WithUrl = Url.Set
 	// WithHeaders creates a [Endomorphism] for a set of headers
 	WithHeaders = Headers.Set
 	// WithBody creates a [Endomorphism] for a request body
@@ -144,9 +130,6 @@ var (
 		WithBytes,
 		ENDO.Chain(WithContentType(C.FormEncoded)),
 	)
-
-	// bodyAsBytes returns a []byte with a fallback to the empty array
-	bodyAsBytes = O.Fold(B.Empty, E.Fold(F.Ignore1of1[error](B.Empty), F.Identity[[]byte]))
 )
 
 func setRawQuery(u *url.URL, raw string) *url.URL {
@@ -165,19 +148,12 @@ func (builder *Builder) clone() *Builder {
 }
 
 // GetTargetUrl constructs a full URL with query parameters on top of the provided URL string
-//
-// Deprecated: use [GetTargetURL] instead
 func (builder *Builder) GetTargetUrl() E.Either[error, string] {
-	return builder.GetTargetURL()
-}
-
-// GetTargetURL constructs a full URL with query parameters on top of the provided URL string
-func (builder *Builder) GetTargetURL() E.Either[error, string] {
 	// construct the final URL
 	return F.Pipe3(
 		builder,
 		Url.Get,
-		parseURL,
+		parseUrl,
 		E.Chain(F.Flow4(
 			T.Replicate2[*url.URL],
 			T.Map2(
@@ -200,15 +176,10 @@ func (builder *Builder) GetTargetURL() E.Either[error, string] {
 	)
 }
 
-// Deprecated: use [GetURL] instead
 func (builder *Builder) GetUrl() string {
 	return builder.url
 }
 
-func (builder *Builder) GetURL() string {
-	return builder.url
-}
-
 func (builder *Builder) GetMethod() string {
 	return F.Pipe1(
 		builder.method,
@@ -238,17 +209,11 @@ func (builder *Builder) SetMethod(method string) *Builder {
 	return builder
 }
 
-// Deprecated: use [SetURL] instead
 func (builder *Builder) SetUrl(url string) *Builder {
 	builder.url = url
 	return builder
 }
 
-func (builder *Builder) SetURL(url string) *Builder {
-	builder.url = url
-	return builder
-}
-
 func (builder *Builder) SetHeaders(headers http.Header) *Builder {
 	builder.headers = headers
 	return builder
@@ -281,11 +246,6 @@ func (builder *Builder) GetHeaderValues(name string) []string {
 	return builder.headers.Values(name)
 }
 
-// GetHash returns a hash value for the builder that can be used as a cache key
-func (builder *Builder) GetHash() string {
-	return MakeHash(builder)
-}
-
 // Header returns a [L.Lens] for a single header
 func Header(name string) L.Lens[*Builder, O.Option[string]] {
 	get := getHeader(name)
@@ -318,21 +278,14 @@ func WithoutHeader(name string) Endomorphism {
 }
 
 // WithJson creates a [Endomorphism] to send JSON payload
-//
-// Deprecated: use [WithJSON] instead
 func WithJson[T any](data T) Endomorphism {
-	return WithJSON[T](data)
-}
-
-// WithJSON creates a [Endomorphism] to send JSON payload
-func WithJSON[T any](data T) Endomorphism {
 	return Monoid.Concat(
 		F.Pipe2(
 			data,
 			J.Marshal[T],
 			WithBody,
 		),
-		WithContentType(C.JSON),
+		WithContentType(C.Json),
 	)
 }
 
@@ -356,32 +309,3 @@ func WithQueryArg(name string) func(value string) Endomorphism {
 func WithoutQueryArg(name string) Endomorphism {
 	return QueryArg(name).Set(noQueryArg)
 }
-
-func hashWriteValue(buf *bytes.Buffer, value string) *bytes.Buffer {
-	buf.WriteString(value)
-	return buf
-}
-
-func hashWriteQuery(name string, buf *bytes.Buffer, values []string) *bytes.Buffer {
-	buf.WriteString(name)
-	return A.Reduce(hashWriteValue, buf)(values)
-}
-
-func makeBytes(b *Builder) []byte {
-	var buf bytes.Buffer
-
-	buf.WriteString(b.GetMethod())
-	buf.WriteString(b.GetURL())
-	b.GetHeaders().Write(&buf) // #nosec: G104
-
-	R.ReduceOrdWithIndex[[]string, *bytes.Buffer](S.Ord)(hashWriteQuery, &buf)(b.GetQuery())
-
-	buf.Write(bodyAsBytes(b.GetBody()))
-
-	return buf.Bytes()
-}
-
-// MakeHash converts a [Builder] into a hash string, convenient to use as a cache key
-func MakeHash(b *Builder) string {
-	return fmt.Sprintf("%x", sha256.Sum256(makeBytes(b)))
-}

http/builder/builder_test.go

@@ -16,7 +16,6 @@
 package builder
 
 import (
-	"fmt"
 	"testing"
 
 	F "github.com/IBM/fp-go/function"
@@ -35,7 +34,7 @@ func TestBuilder(t *testing.T) {
 
 	b1 := F.Pipe1(
 		Default,
-		withContentType(C.JSON),
+		withContentType(C.Json),
 	)
 
 	b2 := F.Pipe1(
@@ -49,7 +48,7 @@ func TestBuilder(t *testing.T) {
 	)
 
 	assert.Equal(t, O.None[string](), Default.GetHeader(name))
-	assert.Equal(t, O.Of(C.JSON), b1.GetHeader(name))
+	assert.Equal(t, O.Of(C.Json), b1.GetHeader(name))
 	assert.Equal(t, O.Of(C.TextPlain), b2.GetHeader(name))
 	assert.Equal(t, O.None[string](), b3.GetHeader(name))
 }
@@ -67,27 +66,3 @@ func TestWithFormData(t *testing.T) {
 
 	assert.Equal(t, C.FormEncoded, Headers.Get(res).Get(H.ContentType))
 }
-
-func TestHash(t *testing.T) {
-
-	b1 := F.Pipe4(
-		Default,
-		WithContentType(C.JSON),
-		WithHeader(H.Accept)(C.JSON),
-		WithURL("http://www.example.com"),
-		WithJSON(map[string]string{"a": "b"}),
-	)
-
-	b2 := F.Pipe4(
-		Default,
-		WithURL("http://www.example.com"),
-		WithHeader(H.Accept)(C.JSON),
-		WithContentType(C.JSON),
-		WithJSON(map[string]string{"a": "b"}),
-	)
-
-	assert.Equal(t, MakeHash(b1), MakeHash(b2))
-	assert.NotEqual(t, MakeHash(Default), MakeHash(b2))
-
-	fmt.Println(MakeHash(b1))
-}

http/content/content.go

@@ -17,7 +17,6 @@ package content
 
 const (
 	TextPlain   = "text/plain"
-	JSON        = "application/json"
-	Json        = JSON // Deprecated: use [JSON] instead
+	Json        = "application/json"
 	FormEncoded = "application/x-www-form-urlencoded"
 )

http/types.go

@@ -18,15 +18,15 @@ package http
 import (
 	H "net/http"
 
-	P "github.com/IBM/fp-go/pair"
+	T "github.com/IBM/fp-go/tuple"
 )
 
 type (
 	// FullResponse represents a full http response, including headers and body
-	FullResponse = P.Pair[*H.Response, []byte]
+	FullResponse = T.Tuple2[*H.Response, []byte]
 )
 
 var (
-	Response = P.Head[*H.Response, []byte]
-	Body     = P.Tail[*H.Response, []byte]
+	Response = T.First[*H.Response, []byte]
+	Body     = T.Second[*H.Response, []byte]
 )

http/utils.go

@@ -28,12 +28,12 @@ import (
 	"github.com/IBM/fp-go/errors"
 	F "github.com/IBM/fp-go/function"
 	O "github.com/IBM/fp-go/option"
-	P "github.com/IBM/fp-go/pair"
 	R "github.com/IBM/fp-go/record/generic"
+	T "github.com/IBM/fp-go/tuple"
 )
 
 type (
-	ParsedMediaType = P.Pair[string, map[string]string]
+	ParsedMediaType = T.Tuple2[string, map[string]string]
 
 	HttpError struct {
 		statusCode int
@@ -45,31 +45,29 @@ type (
 
 var (
 	// mime type to check if a media type matches
-	isJSONMimeType = regexp.MustCompile(`application/(?:\w+\+)?json`).MatchString
+	reJsonMimeType = regexp.MustCompile(`application/(?:\w+\+)?json`)
 	// ValidateResponse validates an HTTP response and returns an [E.Either] if the response is not a success
 	ValidateResponse = E.FromPredicate(isValidStatus, StatusCodeError)
 	// alidateJsonContentTypeString parses a content type a validates that it is valid JSON
-	validateJSONContentTypeString = F.Flow2(
+	validateJsonContentTypeString = F.Flow2(
 		ParseMediaType,
 		E.ChainFirst(F.Flow2(
-			P.Head[string, map[string]string],
-			E.FromPredicate(isJSONMimeType, errors.OnSome[string]("mimetype [%s] is not a valid JSON content type")),
+			T.First[string, map[string]string],
+			E.FromPredicate(reJsonMimeType.MatchString, func(mimeType string) error {
+				return fmt.Errorf("mimetype [%s] is not a valid JSON content type", mimeType)
+			}),
 		)),
 	)
-	// ValidateJSONResponse checks if an HTTP response is a valid JSON response
-	ValidateJSONResponse = F.Flow2(
+	// ValidateJsonResponse checks if an HTTP response is a valid JSON response
+	ValidateJsonResponse = F.Flow2(
 		E.Of[error, *H.Response],
 		E.ChainFirst(F.Flow5(
 			GetHeader,
 			R.Lookup[H.Header](HeaderContentType),
 			O.Chain(A.First[string]),
 			E.FromOption[string](errors.OnNone("unable to access the [%s] header", HeaderContentType)),
-			E.ChainFirst(validateJSONContentTypeString),
+			E.ChainFirst(validateJsonContentTypeString),
 		)))
-	// ValidateJsonResponse checks if an HTTP response is a valid JSON response
-	//
-	// Deprecated: use [ValidateJSONResponse] instead
-	ValidateJsonResponse = ValidateJSONResponse
 )
 
 const (
@@ -79,7 +77,7 @@ const (
 // ParseMediaType parses a media type into a tuple
 func ParseMediaType(mediaType string) E.Either[error, ParsedMediaType] {
 	m, p, err := mime.ParseMediaType(mediaType)
-	return E.TryCatchError(P.MakePair(m, p), err)
+	return E.TryCatchError(T.MakeTuple2(m, p), err)
 }
 
 // Error fulfills the error interface

http/utils_test.go

@@ -39,7 +39,7 @@ func Error[A any](t *testing.T) func(E.Either[error, A]) bool {
 func TestValidateJsonContentTypeString(t *testing.T) {
 
 	res := F.Pipe1(
-		validateJSONContentTypeString(C.JSON),
+		validateJsonContentTypeString(C.Json),
 		NoError[ParsedMediaType](t),
 	)
 
@@ -49,7 +49,7 @@ func TestValidateJsonContentTypeString(t *testing.T) {
 func TestValidateInvalidJsonContentTypeString(t *testing.T) {
 
 	res := F.Pipe1(
-		validateJSONContentTypeString("application/xml"),
+		validateJsonContentTypeString("application/xml"),
 		Error[ParsedMediaType](t),
 	)
 

identity/gen.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2024-02-29 16:19:02.7798504 +0100 CET m=+0.021933401
+// 2023-10-23 08:30:50.5492271 +0200 CEST m=+0.023274501
 
 package identity
 

identity/generic/identity.go

@@ -50,11 +50,7 @@ func MonadChainFirst[GAB ~func(A) B, A, B any](fa A, f GAB) A {
 }
 
 func ChainFirst[GAB ~func(A) B, A, B any](f GAB) func(A) A {
-	return C.ChainFirst(
-		Chain[func(A) A, A, A],
-		Map[func(B) A, B, A],
-		f,
-	)
+	return C.ChainFirst(MonadChain[func(A) A, A, A], MonadMap[func(B) A, B, A], f)
 }
 
 func MonadFlap[GAB ~func(A) B, A, B any](fab GAB, a A) B {
@@ -62,5 +58,5 @@ func MonadFlap[GAB ~func(A) B, A, B any](fab GAB, a A) B {
 }
 
 func Flap[GAB ~func(A) B, B, A any](a A) func(GAB) B {
-	return FC.Flap(Map[func(GAB) B, GAB, B], a)
+	return F.Bind2nd(MonadFlap[GAB, A, B], a)
 }

identity/identity.go

@@ -36,7 +36,7 @@ func Map[A, B any](f func(A) B) func(A) B {
 	return G.Map(f)
 }
 
-func MonadMapTo[A, B any](_ A, b B) B {
+func MonadMapTo[A, B any](fa A, b B) B {
 	return b
 }
 

identity/monad.go

@@ -1,43 +0,0 @@
-// 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 identity
-
-import (
-	"github.com/IBM/fp-go/internal/monad"
-)
-
-type identityMonad[A, B any] struct{}
-
-func (o *identityMonad[A, B]) Of(a A) A {
-	return Of[A](a)
-}
-
-func (o *identityMonad[A, B]) Map(f func(A) B) func(A) B {
-	return Map[A, B](f)
-}
-
-func (o *identityMonad[A, B]) Chain(f func(A) B) func(A) B {
-	return Chain[A, B](f)
-}
-
-func (o *identityMonad[A, B]) Ap(fa A) func(func(A) B) B {
-	return Ap[B, A](fa)
-}
-
-// Monad implements the monadic operations for [Option]
-func Monad[A, B any]() monad.Monad[A, B, A, B, func(A) B] {
-	return &identityMonad[A, B]{}
-}

internal/applicative/testing/law.go

@@ -20,19 +20,13 @@ import (
 
 	E "github.com/IBM/fp-go/eq"
 	F "github.com/IBM/fp-go/function"
-	"github.com/IBM/fp-go/internal/applicative"
-	"github.com/IBM/fp-go/internal/apply"
 	L "github.com/IBM/fp-go/internal/apply/testing"
-	"github.com/IBM/fp-go/internal/functor"
-	"github.com/IBM/fp-go/internal/pointed"
 	"github.com/stretchr/testify/assert"
 )
 
 // Applicative identity law
 //
 // A.ap(A.of(a => a), fa) <-> fa
-//
-// Deprecated: use [ApplicativeAssertIdentity]
 func AssertIdentity[HKTA, HKTAA, A any](t *testing.T,
 	eq E.Eq[HKTA],
 
@@ -40,9 +34,6 @@ func AssertIdentity[HKTA, HKTAA, A any](t *testing.T,
 
 	fap func(HKTAA, HKTA) HKTA,
 ) func(fa HKTA) bool {
-	// mark as test helper
-	t.Helper()
-
 	return func(fa HKTA) bool {
 
 		left := fap(fof(F.Identity[A]), fa)
@@ -52,33 +43,9 @@ func AssertIdentity[HKTA, HKTAA, A any](t *testing.T,
 	}
 }
 
-// Applicative identity law
-//
-// A.ap(A.of(a => a), fa) <-> fa
-func ApplicativeAssertIdentity[HKTA, HKTFAA, A any](t *testing.T,
-	eq E.Eq[HKTA],
-
-	ap applicative.Applicative[A, A, HKTA, HKTA, HKTFAA],
-	paa pointed.Pointed[func(A) A, HKTFAA],
-
-) func(fa HKTA) bool {
-	// mark as test helper
-	t.Helper()
-
-	return func(fa HKTA) bool {
-
-		left := ap.Ap(fa)(paa.Of(F.Identity[A]))
-		right := fa
-
-		return assert.True(t, eq.Equals(left, right), "Applicative identity")
-	}
-}
-
 // Applicative homomorphism law
 //
 // A.ap(A.of(ab), A.of(a)) <-> A.of(ab(a))
-//
-// Deprecated: use [ApplicativeAssertHomomorphism]
 func AssertHomomorphism[HKTA, HKTB, HKTAB, A, B any](t *testing.T,
 	eq E.Eq[HKTB],
 
@@ -90,9 +57,6 @@ func AssertHomomorphism[HKTA, HKTB, HKTAB, A, B any](t *testing.T,
 
 	ab func(A) B,
 ) func(a A) bool {
-	// mark as test helper
-	t.Helper()
-
 	return func(a A) bool {
 
 		left := fap(fofab(ab), fofa(a))
@@ -102,39 +66,14 @@ func AssertHomomorphism[HKTA, HKTB, HKTAB, A, B any](t *testing.T,
 	}
 }
 
-// Applicative homomorphism law
-//
-// A.ap(A.of(ab), A.of(a)) <-> A.of(ab(a))
-func ApplicativeAssertHomomorphism[HKTA, HKTB, HKTFAB, A, B any](t *testing.T,
-	eq E.Eq[HKTB],
-
-	apab applicative.Applicative[A, B, HKTA, HKTB, HKTFAB],
-	pb pointed.Pointed[B, HKTB],
-	pfab pointed.Pointed[func(A) B, HKTFAB],
-
-	ab func(A) B,
-) func(a A) bool {
-	// mark as test helper
-	t.Helper()
-
-	return func(a A) bool {
-
-		left := apab.Ap(apab.Of(a))(pfab.Of(ab))
-		right := pb.Of(ab(a))
-
-		return assert.True(t, eq.Equals(left, right), "Applicative homomorphism")
-	}
-}
-
 // Applicative interchange law
 //
 // A.ap(fab, A.of(a)) <-> A.ap(A.of(ab => ab(a)), fab)
-//
-// Deprecated: use [ApplicativeAssertInterchange]
 func AssertInterchange[HKTA, HKTB, HKTAB, HKTABB, A, B any](t *testing.T,
 	eq E.Eq[HKTB],
 
 	fofa func(A) HKTA,
+	fofb func(B) HKTB,
 	fofab func(func(A) B) HKTAB,
 	fofabb func(func(func(A) B) B) HKTABB,
 
@@ -143,9 +82,6 @@ func AssertInterchange[HKTA, HKTB, HKTAB, HKTABB, A, B any](t *testing.T,
 
 	ab func(A) B,
 ) func(a A) bool {
-	// mark as test helper
-	t.Helper()
-
 	return func(a A) bool {
 
 		fab := fofab(ab)
@@ -159,38 +95,7 @@ func AssertInterchange[HKTA, HKTB, HKTAB, HKTABB, A, B any](t *testing.T,
 	}
 }
 
-// Applicative interchange law
-//
-// A.ap(fab, A.of(a)) <-> A.ap(A.of(ab => ab(a)), fab)
-func ApplicativeAssertInterchange[HKTA, HKTB, HKTFAB, HKTABB, A, B any](t *testing.T,
-	eq E.Eq[HKTB],
-
-	apab applicative.Applicative[A, B, HKTA, HKTB, HKTFAB],
-	apabb applicative.Applicative[func(A) B, B, HKTFAB, HKTB, HKTABB],
-	pabb pointed.Pointed[func(func(A) B) B, HKTABB],
-
-	ab func(A) B,
-) func(a A) bool {
-	// mark as test helper
-	t.Helper()
-
-	return func(a A) bool {
-
-		fab := apabb.Of(ab)
-
-		left := apab.Ap(apab.Of(a))(fab)
-
-		right := apabb.Ap(fab)(pabb.Of(func(ab func(A) B) B {
-			return ab(a)
-		}))
-
-		return assert.True(t, eq.Equals(left, right), "Applicative homomorphism")
-	}
-}
-
 // AssertLaws asserts the apply laws `identity`, `composition`, `associative composition`, 'applicative identity', 'homomorphism', 'interchange'
-//
-// Deprecated: use [ApplicativeAssertLaws] instead
 func AssertLaws[HKTA, HKTB, HKTC, HKTAA, HKTAB, HKTBC, HKTAC, HKTABB, HKTABAC, A, B, C any](t *testing.T,
 	eqa E.Eq[HKTA],
 	eqb E.Eq[HKTB],
@@ -222,62 +127,15 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAA, HKTAB, HKTBC, HKTAC, HKTABB, HKTABAC, A
 	ab func(A) B,
 	bc func(B) C,
 ) func(a A) bool {
-	// mark as test helper
-	t.Helper()
-
 	// apply laws
 	apply := L.AssertLaws(t, eqa, eqc, fofab, fofbc, faa, fab, fac, fbc, fmap, fapab, fapbc, fapac, fapabac, ab, bc)
 	// applicative laws
 	identity := AssertIdentity(t, eqa, fofaa, fapaa)
 	homomorphism := AssertHomomorphism(t, eqb, fofa, fofb, fofab, fapab, ab)
-	interchange := AssertInterchange(t, eqb, fofa, fofab, fofabb, fapab, fapabb, ab)
+	interchange := AssertInterchange(t, eqb, fofa, fofb, fofab, fofabb, fapab, fapabb, ab)
 
 	return func(a A) bool {
 		fa := fofa(a)
 		return apply(fa) && identity(fa) && homomorphism(a) && interchange(a)
 	}
 }
-
-// ApplicativeAssertLaws asserts the apply laws `identity`, `composition`, `associative composition`, 'applicative identity', 'homomorphism', 'interchange'
-func ApplicativeAssertLaws[HKTA, HKTB, HKTC, HKTAA, HKTAB, HKTBC, HKTAC, HKTABB, HKTABAC, A, B, C any](t *testing.T,
-	eqa E.Eq[HKTA],
-	eqb E.Eq[HKTB],
-	eqc E.Eq[HKTC],
-
-	fofb pointed.Pointed[B, HKTB],
-
-	fofaa pointed.Pointed[func(A) A, HKTAA],
-	fofbc pointed.Pointed[func(B) C, HKTBC],
-
-	fofabb pointed.Pointed[func(func(A) B) B, HKTABB],
-
-	faa functor.Functor[A, A, HKTA, HKTA],
-
-	fmap functor.Functor[func(B) C, func(func(A) B) func(A) C, HKTBC, HKTABAC],
-
-	fapaa applicative.Applicative[A, A, HKTA, HKTA, HKTAA],
-	fapab applicative.Applicative[A, B, HKTA, HKTB, HKTAB],
-	fapbc apply.Apply[B, C, HKTB, HKTC, HKTBC],
-	fapac apply.Apply[A, C, HKTA, HKTC, HKTAC],
-
-	fapabb applicative.Applicative[func(A) B, B, HKTAB, HKTB, HKTABB],
-	fapabac applicative.Applicative[func(A) B, func(A) C, HKTAB, HKTAC, HKTABAC],
-
-	ab func(A) B,
-	bc func(B) C,
-) func(a A) bool {
-	// mark as test helper
-	t.Helper()
-
-	// apply laws
-	apply := L.ApplyAssertLaws(t, eqa, eqc, applicative.ToPointed(fapabac), fofbc, faa, fmap, applicative.ToApply(fapab), fapbc, fapac, applicative.ToApply(fapabac), ab, bc)
-	// applicative laws
-	identity := ApplicativeAssertIdentity(t, eqa, fapaa, fofaa)
-	homomorphism := ApplicativeAssertHomomorphism(t, eqb, fapab, fofb, applicative.ToPointed(fapabb), ab)
-	interchange := ApplicativeAssertInterchange(t, eqb, fapab, fapabb, fofabb, ab)
-
-	return func(a A) bool {
-		fa := fapaa.Of(a)
-		return apply(fa) && identity(fa) && homomorphism(a) && interchange(a)
-	}
-}

internal/applicative/types.go

@@ -1,42 +0,0 @@
-// 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 applicative
-
-import (
-	"github.com/IBM/fp-go/internal/apply"
-	"github.com/IBM/fp-go/internal/functor"
-	"github.com/IBM/fp-go/internal/pointed"
-)
-
-type Applicative[A, B, HKTA, HKTB, HKTFAB any] interface {
-	apply.Apply[A, B, HKTA, HKTB, HKTFAB]
-	pointed.Pointed[A, HKTA]
-}
-
-// ToFunctor converts from [Applicative] to [functor.Functor]
-func ToFunctor[A, B, HKTA, HKTB, HKTFAB any](ap Applicative[A, B, HKTA, HKTB, HKTFAB]) functor.Functor[A, B, HKTA, HKTB] {
-	return ap
-}
-
-// ToApply converts from [Applicative] to [apply.Apply]
-func ToApply[A, B, HKTA, HKTB, HKTFAB any](ap Applicative[A, B, HKTA, HKTB, HKTFAB]) apply.Apply[A, B, HKTA, HKTB, HKTFAB] {
-	return ap
-}
-
-// ToPointed converts from [Applicative] to [pointed.Pointed]
-func ToPointed[A, B, HKTA, HKTB, HKTFAB any](ap Applicative[A, B, HKTA, HKTB, HKTFAB]) pointed.Pointed[A, HKTA] {
-	return ap
-}

internal/apply/ap.go

@@ -19,6 +19,13 @@ import (
 	F "github.com/IBM/fp-go/function"
 )
 
+// HKTFGA  = HKT<F, HKT<G, A>>
+// HKTFGB  = HKT<F, HKT<G, B>>
+// HKTFGAB = HKT<F, HKT<G, (a: A) => B>>
+
+// HKTGA   = HKT<G, A>
+// HKTGB   = HKT<G, B>
+// HKTGAB  = HKT<G, (a: A) => B>
 func MonadAp[HKTGA, HKTGB, HKTGAB, HKTFGAB, HKTFGGAB, HKTFGA, HKTFGB any](
 	fap func(HKTFGGAB, HKTFGA) HKTFGB,
 	fmap func(HKTFGAB, func(HKTGAB) func(HKTGA) HKTGB) HKTFGGAB,
@@ -30,19 +37,6 @@ func MonadAp[HKTGA, HKTGB, HKTGAB, HKTFGAB, HKTFGGAB, HKTFGA, HKTFGB any](
 	return fap(fmap(fab, F.Bind1st(F.Bind1st[HKTGAB, HKTGA, HKTGB], gap)), fa)
 }
 
-func Ap[HKTGA, HKTGB, HKTGAB, HKTFGAB, HKTFGGAB, HKTFGA, HKTFGB any](
-	fap func(HKTFGA) func(HKTFGGAB) HKTFGB,
-	fmap func(func(HKTGAB) func(HKTGA) HKTGB) func(HKTFGAB) HKTFGGAB,
-	gap func(HKTGA) func(HKTGAB) HKTGB,
-
-	fa HKTFGA) func(HKTFGAB) HKTFGB {
-
-	return F.Flow2(
-		fmap(F.Flip(gap)),
-		fap(fa),
-	)
-}
-
 // func Ap[HKTGA, HKTGB, HKTGAB, HKTFGAB, HKTFGGAB, HKTFGA, HKTFGB any](
 // 	fap func(HKTFGA) func(HKTFGGAB) HKTFGB,
 // 	fmap func(func(HKTGAB) func(HKTGA) HKTGB) func(HKTFGAB) HKTFGGAB,

internal/apply/doc.go

@@ -15,4 +15,4 @@
 
 package apply
 
-//go:generate go run ../.. apply --count 15 --filename gen.go
+//go:generate go run ../.. apply --count 10 --filename gen.go

internal/apply/testing/laws.go

@@ -19,18 +19,13 @@ import (
 	"testing"
 
 	E "github.com/IBM/fp-go/eq"
-	"github.com/IBM/fp-go/internal/apply"
-	"github.com/IBM/fp-go/internal/functor"
 	FCT "github.com/IBM/fp-go/internal/functor/testing"
-	"github.com/IBM/fp-go/internal/pointed"
 	"github.com/stretchr/testify/assert"
 )
 
 // Apply associative composition law
 //
 // F.ap(F.ap(F.map(fbc, bc => ab => a => bc(ab(a))), fab), fa) <-> F.ap(fbc, F.ap(fab, fa))
-//
-// Deprecated: use [ApplyAssertAssociativeComposition] instead
 func AssertAssociativeComposition[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *testing.T,
 	eq E.Eq[HKTC],
 
@@ -48,7 +43,6 @@ func AssertAssociativeComposition[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC
 	ab func(A) B,
 	bc func(B) C,
 ) func(fa HKTA) bool {
-	t.Helper()
 	return func(fa HKTA) bool {
 
 		fab := fofab(ab)
@@ -68,49 +62,7 @@ func AssertAssociativeComposition[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC
 	}
 }
 
-// Apply associative composition law
-//
-// F.ap(F.ap(F.map(fbc, bc => ab => a => bc(ab(a))), fab), fa) <-> F.ap(fbc, F.ap(fab, fa))
-func ApplyAssertAssociativeComposition[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *testing.T,
-	eq E.Eq[HKTC],
-
-	fofab pointed.Pointed[func(A) B, HKTAB],
-	fofbc pointed.Pointed[func(B) C, HKTBC],
-
-	fmap functor.Functor[func(B) C, func(func(A) B) func(A) C, HKTBC, HKTABAC],
-
-	fapab apply.Apply[A, B, HKTA, HKTB, HKTAB],
-	fapbc apply.Apply[B, C, HKTB, HKTC, HKTBC],
-	fapac apply.Apply[A, C, HKTA, HKTC, HKTAC],
-
-	fapabac apply.Apply[func(A) B, func(A) C, HKTAB, HKTAC, HKTABAC],
-
-	ab func(A) B,
-	bc func(B) C,
-) func(fa HKTA) bool {
-	t.Helper()
-	return func(fa HKTA) bool {
-
-		fab := fofab.Of(ab)
-		fbc := fofbc.Of(bc)
-
-		left := fapac.Ap(fa)(fapabac.Ap(fab)(fmap.Map(func(bc func(B) C) func(func(A) B) func(A) C {
-			return func(ab func(A) B) func(A) C {
-				return func(a A) C {
-					return bc(ab(a))
-				}
-			}
-		})(fbc)))
-
-		right := fapbc.Ap(fapab.Ap(fa)(fab))(fbc)
-
-		return assert.True(t, eq.Equals(left, right), "Apply associative composition")
-	}
-}
-
 // AssertLaws asserts the apply laws `identity`, `composition` and `associative composition`
-//
-// Deprecated: use [ApplyAssertLaws] instead
 func AssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *testing.T,
 	eqa E.Eq[HKTA],
 	eqc E.Eq[HKTC],
@@ -134,8 +86,6 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *
 	ab func(A) B,
 	bc func(B) C,
 ) func(fa HKTA) bool {
-	// mark as test helper
-	t.Helper()
 	// functor laws
 	functor := FCT.AssertLaws(t, eqa, eqc, faa, fab, fac, fbc, ab, bc)
 	// associative composition laws
@@ -145,36 +95,3 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *
 		return functor(fa) && composition(fa)
 	}
 }
-
-// ApplyAssertLaws asserts the apply laws `identity`, `composition` and `associative composition`
-func ApplyAssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *testing.T,
-	eqa E.Eq[HKTA],
-	eqc E.Eq[HKTC],
-
-	fofab pointed.Pointed[func(A) B, HKTAB],
-	fofbc pointed.Pointed[func(B) C, HKTBC],
-
-	faa functor.Functor[A, A, HKTA, HKTA],
-
-	fmap functor.Functor[func(B) C, func(func(A) B) func(A) C, HKTBC, HKTABAC],
-
-	fapab apply.Apply[A, B, HKTA, HKTB, HKTAB],
-	fapbc apply.Apply[B, C, HKTB, HKTC, HKTBC],
-	fapac apply.Apply[A, C, HKTA, HKTC, HKTAC],
-
-	fapabac apply.Apply[func(A) B, func(A) C, HKTAB, HKTAC, HKTABAC],
-
-	ab func(A) B,
-	bc func(B) C,
-) func(fa HKTA) bool {
-	// mark as test helper
-	t.Helper()
-	// functor laws
-	functor := FCT.FunctorAssertLaws(t, eqa, eqc, faa, apply.ToFunctor(fapab), apply.ToFunctor(fapac), apply.ToFunctor(fapbc), ab, bc)
-	// associative composition laws
-	composition := ApplyAssertAssociativeComposition(t, eqc, fofab, fofbc, fmap, fapab, fapbc, fapac, fapabac, ab, bc)
-
-	return func(fa HKTA) bool {
-		return functor(fa) && composition(fa)
-	}
-}

internal/apply/types.go

@@ -1,30 +0,0 @@
-// 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 apply
-
-import (
-	"github.com/IBM/fp-go/internal/functor"
-)
-
-type Apply[A, B, HKTA, HKTB, HKTFAB any] interface {
-	functor.Functor[A, B, HKTA, HKTB]
-	Ap(HKTA) func(HKTFAB) HKTB
-}
-
-// ToFunctor converts from [Apply] to [functor.Functor]
-func ToFunctor[A, B, HKTA, HKTB, HKTFAB any](ap Apply[A, B, HKTA, HKTB, HKTFAB]) functor.Functor[A, B, HKTA, HKTB] {
-	return ap
-}

internal/array/array.go

@@ -17,37 +17,6 @@ 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]
 	}
 }
@@ -137,12 +106,6 @@ func MonadMap[GA ~[]A, GB ~[]B, A, B any](as GA, f func(a A) B) GB {
 	return bs
 }
 
-func Map[GA ~[]A, GB ~[]B, A, B any](f func(a A) B) func(GA) GB {
-	return func(as GA) GB {
-		return MonadMap[GA, GB](as, f)
-	}
-}
-
 func MonadMapWithIndex[GA ~[]A, GB ~[]B, A, B any](as GA, f func(idx int, a A) B) GB {
 	count := len(as)
 	bs := make(GB, count)

internal/bracket/bracket.go

@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package bracket
+package file
 
 import (
 	F "github.com/IBM/fp-go/function"

internal/chain/chain.go

@@ -43,11 +43,11 @@ func MonadChain[A, B, HKTA, HKTB any](
 // HKTA=HKT[A]
 // HKTB=HKT[B]
 func ChainFirst[A, B, HKTA, HKTB any](
-	mchain func(func(A) HKTA) func(HKTA) HKTA,
-	mmap func(func(B) A) func(HKTB) HKTA,
+	mchain func(HKTA, func(A) HKTA) HKTA,
+	mmap func(HKTB, func(B) A) HKTA,
 	f func(A) HKTB) func(HKTA) HKTA {
-	return mchain(func(a A) HKTA {
-		return mmap(F.Constant1[B](a))(f(a))
+	return F.Bind2nd(mchain, func(a A) HKTA {
+		return mmap(f(a), F.Constant1[B](a))
 	})
 }
 

internal/chain/testing/laws.go

@@ -20,22 +20,17 @@ import (
 
 	E "github.com/IBM/fp-go/eq"
 	F "github.com/IBM/fp-go/function"
-	"github.com/IBM/fp-go/internal/apply"
 	L "github.com/IBM/fp-go/internal/apply/testing"
-	"github.com/IBM/fp-go/internal/chain"
-	"github.com/IBM/fp-go/internal/functor"
-	"github.com/IBM/fp-go/internal/pointed"
 	"github.com/stretchr/testify/assert"
 )
 
 // Chain associativity law
 //
 // F.chain(F.chain(fa, afb), bfc) <-> F.chain(fa, a => F.chain(afb(a), bfc))
-//
-// Deprecated: use [ChainAssertAssociativity] instead
 func AssertAssociativity[HKTA, HKTB, HKTC, A, B, C any](t *testing.T,
 	eq E.Eq[HKTC],
 
+	fofa func(A) HKTA,
 	fofb func(B) HKTB,
 	fofc func(C) HKTC,
 
@@ -61,44 +56,12 @@ func AssertAssociativity[HKTA, HKTB, HKTC, A, B, C any](t *testing.T,
 	}
 }
 
-// Chain associativity law
-//
-// F.chain(F.chain(fa, afb), bfc) <-> F.chain(fa, a => F.chain(afb(a), bfc))
-func ChainAssertAssociativity[HKTA, HKTB, HKTC, HKTAB, HKTAC, HKTBC, A, B, C any](t *testing.T,
-	eq E.Eq[HKTC],
-
-	fofb pointed.Pointed[B, HKTB],
-	fofc pointed.Pointed[C, HKTC],
-
-	chainab chain.Chainable[A, B, HKTA, HKTB, HKTAB],
-	chainac chain.Chainable[A, C, HKTA, HKTC, HKTAC],
-	chainbc chain.Chainable[B, C, HKTB, HKTC, HKTBC],
-
-	ab func(A) B,
-	bc func(B) C,
-) func(fa HKTA) bool {
-	return func(fa HKTA) bool {
-
-		afb := F.Flow2(ab, fofb.Of)
-		bfc := F.Flow2(bc, fofc.Of)
-
-		left := chainbc.Chain(bfc)(chainab.Chain(afb)(fa))
-
-		right := chainac.Chain(func(a A) HKTC {
-			return chainbc.Chain(bfc)(afb(a))
-		})(fa)
-
-		return assert.True(t, eq.Equals(left, right), "Chain associativity")
-	}
-}
-
 // AssertLaws asserts the apply laws `identity`, `composition`, `associative composition` and `associativity`
-//
-// Deprecated: use [ChainAssertLaws] instead
 func AssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *testing.T,
 	eqa E.Eq[HKTA],
 	eqc E.Eq[HKTC],
 
+	fofa func(A) HKTA,
 	fofb func(B) HKTB,
 	fofc func(C) HKTC,
 
@@ -128,41 +91,7 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *
 	// apply laws
 	apply := L.AssertLaws(t, eqa, eqc, fofab, fofbc, faa, fab, fac, fbc, fmap, fapab, fapbc, fapac, fapabac, ab, bc)
 	// chain laws
-	associativity := AssertAssociativity(t, eqc, fofb, fofc, chainab, chainac, chainbc, ab, bc)
-
-	return func(fa HKTA) bool {
-		return apply(fa) && associativity(fa)
-	}
-}
-
-// ChainAssertLaws asserts the apply laws `identity`, `composition`, `associative composition` and `associativity`
-func ChainAssertLaws[HKTA, HKTB, HKTC, HKTAB, HKTBC, HKTAC, HKTABAC, A, B, C any](t *testing.T,
-	eqa E.Eq[HKTA],
-	eqc E.Eq[HKTC],
-
-	fofb pointed.Pointed[B, HKTB],
-	fofc pointed.Pointed[C, HKTC],
-
-	fofab pointed.Pointed[func(A) B, HKTAB],
-	fofbc pointed.Pointed[func(B) C, HKTBC],
-
-	faa functor.Functor[A, A, HKTA, HKTA],
-
-	fmap functor.Functor[func(B) C, func(func(A) B) func(A) C, HKTBC, HKTABAC],
-
-	chainab chain.Chainable[A, B, HKTA, HKTB, HKTAB],
-	chainac chain.Chainable[A, C, HKTA, HKTC, HKTAC],
-	chainbc chain.Chainable[B, C, HKTB, HKTC, HKTBC],
-
-	fapabac apply.Apply[func(A) B, func(A) C, HKTAB, HKTAC, HKTABAC],
-
-	ab func(A) B,
-	bc func(B) C,
-) func(fa HKTA) bool {
-	// apply laws
-	apply := L.ApplyAssertLaws(t, eqa, eqc, fofab, fofbc, faa, fmap, chain.ToApply(chainab), chain.ToApply(chainbc), chain.ToApply(chainac), fapabac, ab, bc)
-	// chain laws
-	associativity := ChainAssertAssociativity(t, eqc, fofb, fofc, chainab, chainac, chainbc, ab, bc)
+	associativity := AssertAssociativity(t, eqc, fofa, fofb, fofc, chainab, chainac, chainbc, ab, bc)
 
 	return func(fa HKTA) bool {
 		return apply(fa) && associativity(fa)

internal/chain/types.go

@@ -1,36 +0,0 @@
-// 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 chain
-
-import (
-	"github.com/IBM/fp-go/internal/apply"
-	"github.com/IBM/fp-go/internal/functor"
-)
-
-type Chainable[A, B, HKTA, HKTB, HKTFAB any] interface {
-	apply.Apply[A, B, HKTA, HKTB, HKTFAB]
-	Chain(func(A) HKTB) func(HKTA) HKTB
-}
-
-// ToFunctor converts from [Chainable] to [functor.Functor]
-func ToFunctor[A, B, HKTA, HKTB, HKTFAB any](ap Chainable[A, B, HKTA, HKTB, HKTFAB]) functor.Functor[A, B, HKTA, HKTB] {
-	return ap
-}
-
-// ToApply converts from [Chainable] to [functor.Functor]
-func ToApply[A, B, HKTA, HKTB, HKTFAB any](ap Chainable[A, B, HKTA, HKTB, HKTFAB]) apply.Apply[A, B, HKTA, HKTB, HKTFAB] {
-	return ap
-}

internal/eithert/either.go

@@ -51,14 +51,6 @@ func MonadMap[E, A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(ET.Either[E, A])
 	return FC.MonadMap(fmap, ET.MonadMap[E, A, B], fa, f)
 }
 
-func Map[E, A, B, HKTFA, HKTFB any](
-	fmap func(func(ET.Either[E, A]) ET.Either[E, B]) func(HKTFA) HKTFB,
-	f func(A) B) func(HKTFA) HKTFB {
-	// HKTGA = Either[E, A]
-	// HKTGB = Either[E, B]
-	return FC.Map(fmap, ET.Map[E, A, B], f)
-}
-
 // HKTFA = HKT<F, Either<E, A>>
 // HKTFB = HKT<F, Either<E, B>>
 func MonadBiMap[E1, E2, A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(ET.Either[E1, A]) ET.Either[E2, B]) HKTFB, fa HKTFA, f func(E1) E2, g func(A) B) HKTFB {
@@ -69,12 +61,10 @@ func MonadBiMap[E1, E2, A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(ET.Either[
 
 // HKTFA = HKT<F, Either<E, A>>
 // HKTFB = HKT<F, Either<E, B>>
-func BiMap[E1, E2, A, B, HKTFA, HKTFB any](
-	fmap func(func(ET.Either[E1, A]) ET.Either[E2, B]) func(HKTFA) HKTFB,
-	f func(E1) E2, g func(A) B) func(HKTFA) HKTFB {
+func BiMap[E1, E2, A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(ET.Either[E1, A]) ET.Either[E2, B]) HKTFB, f func(E1) E2, g func(A) B) func(HKTFA) HKTFB {
 	// HKTGA = Either[E, A]
 	// HKTGB = Either[E, B]
-	return fmap(ET.BiMap(f, g))
+	return F.Bind2nd(fmap, ET.BiMap(f, g))
 }
 
 // HKTFA = HKT<F, Either<E, A>>
@@ -88,29 +78,22 @@ func MonadChain[E, A, B, HKTFA, HKTFB any](
 	return fchain(ma, ET.Fold(F.Flow2(ET.Left[B, E], fof), f))
 }
 
-func Chain[E, A, B, HKTFA, HKTFB any](
-	fchain func(func(ET.Either[E, A]) HKTFB) func(HKTFA) HKTFB,
-	fof func(ET.Either[E, B]) HKTFB,
-	f func(A) HKTFB) func(HKTFA) HKTFB {
-	// dispatch to the even more generic implementation
-	return fchain(ET.Fold(F.Flow2(ET.Left[B, E], fof), f))
-}
+// func(fa func(R) T.Task[ET.Either[E, func(A) B]], f func(ET.Either[E, func(A) B]) func(ET.Either[E, A]) ET.Either[E, B]) GEFAB
 
+// HKTFA   = HKT[Either[E, A]]
+// HKTFB   = HKT[Either[E, B]]
+// HKTFAB  = HKT[Either[E, func(A)B]]
 func MonadAp[E, A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
 	fap func(HKTFGAB, HKTFA) HKTFB,
 	fmap func(HKTFAB, func(ET.Either[E, func(A) B]) func(ET.Either[E, A]) ET.Either[E, B]) HKTFGAB,
 	fab HKTFAB,
 	fa HKTFA) HKTFB {
+	// HKTGA  = ET.Either[E, A]
+	// HKTGB  = ET.Either[E, B]
+	// HKTGAB = ET.Either[E, func(a A) B]
 	return apply.MonadAp(fap, fmap, ET.MonadAp[B, E, A], fab, fa)
 }
 
-func Ap[E, A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
-	fap func(HKTFA) func(HKTFGAB) HKTFB,
-	fmap func(func(ET.Either[E, func(A) B]) func(ET.Either[E, A]) ET.Either[E, B]) func(HKTFAB) HKTFGAB,
-	fa HKTFA) func(HKTFAB) HKTFB {
-	return apply.Ap(fap, fmap, ET.Ap[B, E, A], fa)
-}
-
 func Right[E, A, HKTA any](fof func(ET.Either[E, A]) HKTA, a A) HKTA {
 	return F.Pipe2(a, ET.Right[E, A], fof)
 }
@@ -159,7 +142,3 @@ func OrLeft[E1, E2, A, HKTE1A, HKTE2, HKTE2A any](
 func MonadMapLeft[E, A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(ET.Either[E, A]) ET.Either[B, A]) HKTFB, fa HKTFA, f func(E) B) HKTFB {
 	return FC.MonadMap(fmap, ET.MonadMapLeft[E, A, B], fa, f)
 }
-
-func MapLeft[E, A, B, HKTFA, HKTFB any](fmap func(func(ET.Either[E, A]) ET.Either[B, A]) func(HKTFA) HKTFB, f func(E) B) func(HKTFA) HKTFB {
-	return FC.Map(fmap, ET.MapLeft[A, E, B], f)
-}

internal/exec/exec.go

@@ -23,7 +23,7 @@ import (
 
 	EX "github.com/IBM/fp-go/exec"
 
-	P "github.com/IBM/fp-go/pair"
+	T "github.com/IBM/fp-go/tuple"
 )
 
 func Exec(ctx context.Context, name string, args []string, in []byte) (EX.CommandOutput, error) {
@@ -42,5 +42,5 @@ func Exec(ctx context.Context, name string, args []string, in []byte) (EX.Comman
 		err = fmt.Errorf("command execution of [%s][%s] failed, stdout [%s], stderr [%s], cause [%w]", name, args, stdOut.String(), stdErr.String(), err)
 	}
 	// return the outputs
-	return P.MakePair(stdOut.Bytes(), stdErr.Bytes()), err
+	return T.MakeTuple2(stdOut.Bytes(), stdErr.Bytes()), err
 }

internal/foldable/types.go

@@ -1,26 +0,0 @@
-// 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 foldable
-
-import (
-	M "github.com/IBM/fp-go/monoid"
-)
-
-type Foldable[A, B, HKTA any] interface {
-	Reduce(func(B, A) B, B) func(HKTA) B
-	ReduceRight(func(B, A) B, B) func(HKTA) B
-	FoldMap(m M.Monoid[B]) func(func(A) B) func(HKTA) B
-}

internal/fromeither/either.go

@@ -60,13 +60,6 @@ func MonadChainEitherK[A, E, B, HKTEA, HKTEB any](
 	return mchain(ma, F.Flow2(f, fromEither))
 }
 
-func ChainEitherK[A, E, B, HKTEA, HKTEB any](
-	mchain func(func(A) HKTEB) func(HKTEA) HKTEB,
-	fromEither func(ET.Either[E, B]) HKTEB,
-	f func(A) ET.Either[E, B]) func(HKTEA) HKTEB {
-	return mchain(F.Flow2(f, fromEither))
-}
-
 func ChainOptionK[A, E, B, HKTEA, HKTEB any](
 	mchain func(HKTEA, func(A) HKTEB) HKTEB,
 	fromEither func(ET.Either[E, B]) HKTEB,
@@ -85,8 +78,8 @@ func MonadChainFirstEitherK[A, E, B, HKTEA, HKTEB any](
 }
 
 func ChainFirstEitherK[A, E, B, HKTEA, HKTEB any](
-	mchain func(func(A) HKTEA) func(HKTEA) HKTEA,
-	mmap func(func(B) A) func(HKTEB) HKTEA,
+	mchain func(HKTEA, func(A) HKTEA) HKTEA,
+	mmap func(HKTEB, func(B) A) HKTEA,
 	fromEither func(ET.Either[E, B]) HKTEB,
 	f func(A) ET.Either[E, B]) func(HKTEA) HKTEA {
 	return C.ChainFirst(mchain, mmap, F.Flow2(f, fromEither))

internal/fromeither/types.go

@@ -1,24 +0,0 @@
-// 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 fromeither
-
-import (
-	ET "github.com/IBM/fp-go/either"
-)
-
-type FromEither[E, A, HKTA any] interface {
-	FromEither(ET.Either[E, A]) HKTA
-}

internal/fromio/io.go

@@ -30,8 +30,8 @@ func MonadChainFirstIOK[A, B, HKTA, HKTB any, GIOB ~func() B](
 }
 
 func ChainFirstIOK[A, B, HKTA, HKTB any, GIOB ~func() B](
-	mchain func(func(A) HKTA) func(HKTA) HKTA,
-	mmap func(func(B) A) func(HKTB) HKTA,
+	mchain func(HKTA, func(A) HKTA) HKTA,
+	mmap func(HKTB, func(B) A) HKTA,
 	fromio func(GIOB) HKTB,
 	f func(A) GIOB) func(HKTA) HKTA {
 	// chain

internal/fromio/types.go

@@ -1,20 +0,0 @@
-// 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 fromio
-
-type FromIO[A, GA ~func() A, HKTA any] interface {
-	FromIO(GA) HKTA
-}

internal/fromioeither/ioeither.go

@@ -31,8 +31,8 @@ func MonadChainFirstIOEitherK[GIOB ~func() ET.Either[E, B], E, A, B, HKTA, HKTB
 }
 
 func ChainFirstIOEitherK[GIOB ~func() ET.Either[E, B], E, A, B, HKTA, HKTB any](
-	mchain func(func(A) HKTA) func(HKTA) HKTA,
-	mmap func(func(B) A) func(HKTB) HKTA,
+	mchain func(HKTA, func(A) HKTA) HKTA,
+	mmap func(HKTB, func(B) A) HKTA,
 	fromio func(GIOB) HKTB,
 	f func(A) GIOB) func(HKTA) HKTA {
 	// chain

internal/functor/flap.go

@@ -15,24 +15,23 @@
 
 package functor
 
-func flap[FAB ~func(A) B, A, B any](a A) func(FAB) B {
-	return func(f FAB) B {
-		return f(a)
-	}
-}
-
 func MonadFlap[FAB ~func(A) B, A, B, HKTFAB, HKTB any](
 	fmap func(HKTFAB, func(FAB) B) HKTB,
 
 	fab HKTFAB,
 	a A,
 ) HKTB {
-	return fmap(fab, flap[FAB, A, B](a))
+	return fmap(fab, func(f FAB) B {
+		return f(a)
+	})
 }
 
 func Flap[FAB ~func(A) B, A, B, HKTFAB, HKTB any](
-	fmap func(func(FAB) B) func(HKTFAB) HKTB,
+	fmap func(HKTFAB, func(FAB) B) HKTB,
+
 	a A,
 ) func(HKTFAB) HKTB {
-	return fmap(flap[FAB, A, B](a))
+	return func(fab HKTFAB) HKTB {
+		return MonadFlap(fmap, fab, a)
+	}
 }

internal/functor/functor.go

@@ -33,7 +33,11 @@ func Map[A, B, HKTGA, HKTGB, HKTFGA, HKTFGB any](
 	fmap func(func(HKTGA) HKTGB) func(HKTFGA) HKTFGB,
 	gmap func(func(A) B) func(HKTGA) HKTGB,
 	f func(A) B) func(HKTFGA) HKTFGB {
-	return fmap(gmap(f))
+	return F.Pipe2(
+		f,
+		gmap,
+		fmap,
+	)
 }
 
 func MonadLet[S1, S2, B, HKTS1, HKTS2 any](
@@ -62,5 +66,9 @@ func LetTo[S1, S2, B, HKTS1, HKTS2 any](
 	key func(B) func(S1) S2,
 	b B,
 ) func(HKTS1) HKTS2 {
-	return mmap(key(b))
+	return F.Pipe2(
+		b,
+		key,
+		mmap,
+	)
 }

internal/functor/testing/laws.go

@@ -20,44 +20,21 @@ import (
 
 	E "github.com/IBM/fp-go/eq"
 	F "github.com/IBM/fp-go/function"
-	"github.com/IBM/fp-go/internal/functor"
 	"github.com/stretchr/testify/assert"
 )
 
 // Functor identity law
 //
 // F.map(fa, a => a) <-> fa
-//
-// Deprecated: use [FunctorAssertIdentity]
 func AssertIdentity[HKTA, A any](t *testing.T, eq E.Eq[HKTA], fmap func(HKTA, func(A) A) HKTA) func(fa HKTA) bool {
-	t.Helper()
 	return func(fa HKTA) bool {
 		return assert.True(t, eq.Equals(fa, fmap(fa, F.Identity[A])), "Functor identity law")
 	}
 }
 
-// Functor identity law
-//
-// F.map(fa, a => a) <-> fa
-func FunctorAssertIdentity[HKTA, A any](
-	t *testing.T,
-	eq E.Eq[HKTA],
-
-	fca functor.Functor[A, A, HKTA, HKTA],
-) func(fa HKTA) bool {
-
-	t.Helper()
-	return func(fa HKTA) bool {
-
-		return assert.True(t, eq.Equals(fa, fca.Map(F.Identity[A])(fa)), "Functor identity law")
-	}
-}
-
 // Functor composition law
 //
 // F.map(fa, a => bc(ab(a))) <-> F.map(F.map(fa, ab), bc)
-//
-// Deprecated: use [FunctorAssertComposition] instead
 func AssertComposition[HKTA, HKTB, HKTC, A, B, C any](
 	t *testing.T,
 
@@ -69,36 +46,12 @@ func AssertComposition[HKTA, HKTB, HKTC, A, B, C any](
 	ab func(A) B,
 	bc func(B) C,
 ) func(fa HKTA) bool {
-	t.Helper()
 	return func(fa HKTA) bool {
 		return assert.True(t, eq.Equals(fac(fa, F.Flow2(ab, bc)), fbc(fab(fa, ab), bc)), "Functor composition law")
 	}
 }
 
-// Functor composition law
-//
-// F.map(fa, a => bc(ab(a))) <-> F.map(F.map(fa, ab), bc)
-func FunctorAssertComposition[HKTA, HKTB, HKTC, A, B, C any](
-	t *testing.T,
-
-	eq E.Eq[HKTC],
-
-	fab functor.Functor[A, B, HKTA, HKTB],
-	fac functor.Functor[A, C, HKTA, HKTC],
-	fbc functor.Functor[B, C, HKTB, HKTC],
-
-	ab func(A) B,
-	bc func(B) C,
-) func(fa HKTA) bool {
-	t.Helper()
-	return func(fa HKTA) bool {
-		return assert.True(t, eq.Equals(fac.Map(F.Flow2(ab, bc))(fa), fbc.Map(bc)(fab.Map(ab)(fa))), "Functor composition law")
-	}
-}
-
 // AssertLaws asserts the functor laws `identity` and `composition`
-//
-// Deprecated: use [FunctorAssertLaws] instead
 func AssertLaws[HKTA, HKTB, HKTC, A, B, C any](t *testing.T,
 	eqa E.Eq[HKTA],
 	eqc E.Eq[HKTC],
@@ -107,11 +60,9 @@ func AssertLaws[HKTA, HKTB, HKTC, A, B, C any](t *testing.T,
 	fab func(HKTA, func(A) B) HKTB,
 	fac func(HKTA, func(A) C) HKTC,
 	fbc func(HKTB, func(B) C) HKTC,
-
 	ab func(A) B,
 	bc func(B) C,
 ) func(fa HKTA) bool {
-	t.Helper()
 	identity := AssertIdentity(t, eqa, faa)
 	composition := AssertComposition(t, eqc, fab, fac, fbc, ab, bc)
 
@@ -119,25 +70,3 @@ func AssertLaws[HKTA, HKTB, HKTC, A, B, C any](t *testing.T,
 		return identity(fa) && composition(fa)
 	}
 }
-
-// FunctorAssertLaws asserts the functor laws `identity` and `composition`
-func FunctorAssertLaws[HKTA, HKTB, HKTC, A, B, C any](t *testing.T,
-	eqa E.Eq[HKTA],
-	eqc E.Eq[HKTC],
-
-	faa functor.Functor[A, A, HKTA, HKTA],
-	fab functor.Functor[A, B, HKTA, HKTB],
-	fac functor.Functor[A, C, HKTA, HKTC],
-	fbc functor.Functor[B, C, HKTB, HKTC],
-
-	ab func(A) B,
-	bc func(B) C,
-) func(fa HKTA) bool {
-	t.Helper()
-	identity := FunctorAssertIdentity(t, eqa, faa)
-	composition := FunctorAssertComposition(t, eqc, fab, fac, fbc, ab, bc)
-
-	return func(fa HKTA) bool {
-		return identity(fa) && composition(fa)
-	}
-}

internal/functor/types.go

@@ -1,20 +0,0 @@
-// 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 functor
-
-type Functor[A, B, HKTA, HKTB any] interface {
-	Map(func(A) B) func(HKTA) HKTB
-}

internal/monad/monad.go

@@ -1,54 +0,0 @@
-// 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 monad
-
-import (
-	"github.com/IBM/fp-go/internal/applicative"
-	"github.com/IBM/fp-go/internal/apply"
-	"github.com/IBM/fp-go/internal/chain"
-	"github.com/IBM/fp-go/internal/functor"
-	"github.com/IBM/fp-go/internal/pointed"
-)
-
-type Monad[A, B, HKTA, HKTB, HKTFAB any] interface {
-	applicative.Applicative[A, B, HKTA, HKTB, HKTFAB]
-	chain.Chainable[A, B, HKTA, HKTB, HKTFAB]
-}
-
-// ToFunctor converts from [Monad] to [functor.Functor]
-func ToFunctor[A, B, HKTA, HKTB, HKTFAB any](ap Monad[A, B, HKTA, HKTB, HKTFAB]) functor.Functor[A, B, HKTA, HKTB] {
-	return ap
-}
-
-// ToApply converts from [Monad] to [apply.Apply]
-func ToApply[A, B, HKTA, HKTB, HKTFAB any](ap Monad[A, B, HKTA, HKTB, HKTFAB]) apply.Apply[A, B, HKTA, HKTB, HKTFAB] {
-	return ap
-}
-
-// ToPointed converts from [Monad] to [pointed.Pointed]
-func ToPointed[A, B, HKTA, HKTB, HKTFAB any](ap Monad[A, B, HKTA, HKTB, HKTFAB]) pointed.Pointed[A, HKTA] {
-	return ap
-}
-
-// ToApplicative converts from [Monad] to [applicative.Applicative]
-func ToApplicative[A, B, HKTA, HKTB, HKTFAB any](ap Monad[A, B, HKTA, HKTB, HKTFAB]) applicative.Applicative[A, B, HKTA, HKTB, HKTFAB] {
-	return ap
-}
-
-// ToChainable converts from [Monad] to [chain.Chainable]
-func ToChainable[A, B, HKTA, HKTB, HKTFAB any](ap Monad[A, B, HKTA, HKTB, HKTFAB]) chain.Chainable[A, B, HKTA, HKTB, HKTFAB] {
-	return ap
-}

internal/monad/testing/laws.go

@@ -19,21 +19,14 @@ import (
 	"testing"
 
 	E "github.com/IBM/fp-go/eq"
-	"github.com/IBM/fp-go/internal/applicative"
 	LA "github.com/IBM/fp-go/internal/applicative/testing"
-	"github.com/IBM/fp-go/internal/chain"
 	LC "github.com/IBM/fp-go/internal/chain/testing"
-	"github.com/IBM/fp-go/internal/functor"
-	"github.com/IBM/fp-go/internal/monad"
-	"github.com/IBM/fp-go/internal/pointed"
 	"github.com/stretchr/testify/assert"
 )
 
 // Apply monad left identity law
 //
 // M.chain(M.of(a), f) <-> f(a)
-//
-// Deprecated: use [MonadAssertLeftIdentity] instead
 func AssertLeftIdentity[HKTA, HKTB, A, B any](t *testing.T,
 	eq E.Eq[HKTB],
 
@@ -57,36 +50,9 @@ func AssertLeftIdentity[HKTA, HKTB, A, B any](t *testing.T,
 	}
 }
 
-// Apply monad left identity law
-//
-// M.chain(M.of(a), f) <-> f(a)
-func MonadAssertLeftIdentity[HKTA, HKTB, HKTFAB, A, B any](t *testing.T,
-	eq E.Eq[HKTB],
-
-	fofb pointed.Pointed[B, HKTB],
-
-	ma monad.Monad[A, B, HKTA, HKTB, HKTFAB],
-
-	ab func(A) B,
-) func(a A) bool {
-	return func(a A) bool {
-
-		f := func(a A) HKTB {
-			return fofb.Of(ab(a))
-		}
-
-		left := ma.Chain(f)(ma.Of(a))
-		right := f(a)
-
-		return assert.True(t, eq.Equals(left, right), "Monad left identity")
-	}
-}
-
 // Apply monad right identity law
 //
 // M.chain(fa, M.of) <-> fa
-//
-// Deprecated: use [MonadAssertRightIdentity] instead
 func AssertRightIdentity[HKTA, A any](t *testing.T,
 	eq E.Eq[HKTA],
 
@@ -103,27 +69,7 @@ func AssertRightIdentity[HKTA, A any](t *testing.T,
 	}
 }
 
-// Apply monad right identity law
-//
-// M.chain(fa, M.of) <-> fa
-func MonadAssertRightIdentity[HKTA, HKTAA, A any](t *testing.T,
-	eq E.Eq[HKTA],
-
-	ma monad.Monad[A, A, HKTA, HKTA, HKTAA],
-
-) func(fa HKTA) bool {
-	return func(fa HKTA) bool {
-
-		left := ma.Chain(ma.Of)(fa)
-		right := fa
-
-		return assert.True(t, eq.Equals(left, right), "Monad right identity")
-	}
-}
-
 // AssertLaws asserts the apply laws `identity`, `composition`, `associative composition`, 'applicative identity', 'homomorphism', 'interchange', `associativity`, `left identity`, `right identity`
-//
-// Deprecated: use [MonadAssertLaws] instead
 func AssertLaws[HKTA, HKTB, HKTC, HKTAA, HKTAB, HKTBC, HKTAC, HKTABB, HKTABAC, A, B, C any](t *testing.T,
 	eqa E.Eq[HKTA],
 	eqb E.Eq[HKTB],
@@ -164,7 +110,7 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAA, HKTAB, HKTBC, HKTAC, HKTABB, HKTABAC, A
 	// applicative laws
 	applicative := LA.AssertLaws(t, eqa, eqb, eqc, fofa, fofb, fofaa, fofab, fofbc, fofabb, faa, fab, fac, fbc, fmap, fapaa, fapab, fapbc, fapac, fapabb, fapabac, ab, bc)
 	// chain laws
-	chain := LC.AssertLaws(t, eqa, eqc, fofb, fofc, fofab, fofbc, faa, fab, fac, fbc, fmap, chainab, chainac, chainbc, fapab, fapbc, fapac, fapabac, ab, bc)
+	chain := LC.AssertLaws(t, eqa, eqc, fofa, fofb, fofc, fofab, fofbc, faa, fab, fac, fbc, fmap, chainab, chainac, chainbc, fapab, fapbc, fapac, fapabac, ab, bc)
 	// monad laws
 	leftIdentity := AssertLeftIdentity(t, eqb, fofa, fofb, chainab, ab)
 	rightIdentity := AssertRightIdentity(t, eqa, fofa, chainaa)
@@ -174,55 +120,3 @@ func AssertLaws[HKTA, HKTB, HKTC, HKTAA, HKTAB, HKTBC, HKTAC, HKTABB, HKTABAC, A
 		return applicative(a) && chain(fa) && leftIdentity(a) && rightIdentity(fa)
 	}
 }
-
-// MonadAssertLaws asserts the apply laws `identity`, `composition`, `associative composition`, 'applicative identity', 'homomorphism', 'interchange', `associativity`, `left identity`, `right identity`
-func MonadAssertLaws[HKTA, HKTB, HKTC, HKTAA, HKTAB, HKTBC, HKTAC, HKTABB, HKTABAC, A, B, C any](t *testing.T,
-	eqa E.Eq[HKTA],
-	eqb E.Eq[HKTB],
-	eqc E.Eq[HKTC],
-
-	fofc pointed.Pointed[C, HKTC],
-	fofaa pointed.Pointed[func(A) A, HKTAA],
-	fofbc pointed.Pointed[func(B) C, HKTBC],
-	fofabb pointed.Pointed[func(func(A) B) B, HKTABB],
-
-	fmap functor.Functor[func(B) C, func(func(A) B) func(A) C, HKTBC, HKTABAC],
-
-	fapabb applicative.Applicative[func(A) B, B, HKTAB, HKTB, HKTABB],
-	fapabac applicative.Applicative[func(A) B, func(A) C, HKTAB, HKTAC, HKTABAC],
-
-	maa monad.Monad[A, A, HKTA, HKTA, HKTAA],
-	mab monad.Monad[A, B, HKTA, HKTB, HKTAB],
-	mac monad.Monad[A, C, HKTA, HKTC, HKTAC],
-	mbc monad.Monad[B, C, HKTB, HKTC, HKTBC],
-
-	ab func(A) B,
-	bc func(B) C,
-) func(a A) bool {
-	// derivations
-	fofa := monad.ToPointed(maa)
-	fofb := monad.ToPointed(mbc)
-	fofab := applicative.ToPointed(fapabb)
-	fapaa := monad.ToApplicative(maa)
-	fapab := monad.ToApplicative(mab)
-	chainab := monad.ToChainable(mab)
-	chainac := monad.ToChainable(mac)
-	chainbc := monad.ToChainable(mbc)
-	fapbc := chain.ToApply(chainbc)
-	fapac := chain.ToApply(chainac)
-
-	faa := monad.ToFunctor(maa)
-
-	// applicative laws
-	apLaw := LA.ApplicativeAssertLaws(t, eqa, eqb, eqc, fofb, fofaa, fofbc, fofabb, faa, fmap, fapaa, fapab, fapbc, fapac, fapabb, fapabac, ab, bc)
-	// chain laws
-	chainLaw := LC.ChainAssertLaws(t, eqa, eqc, fofb, fofc, fofab, fofbc, faa, fmap, chainab, chainac, chainbc, applicative.ToApply(fapabac), ab, bc)
-	// monad laws
-	leftIdentity := MonadAssertLeftIdentity(t, eqb, fofb, mab, ab)
-	rightIdentity := MonadAssertRightIdentity(t, eqa, maa)
-
-	return func(a A) bool {
-		fa := fofa.Of(a)
-		return apLaw(a) && chainLaw(fa) && leftIdentity(a) && rightIdentity(fa)
-	}
-}

internal/optiont/option.go

@@ -40,12 +40,6 @@ func MonadMap[A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(O.Option[A]) O.Optio
 	return FC.MonadMap(fmap, O.MonadMap[A, B], fa, f)
 }
 
-func Map[A, B, HKTFA, HKTFB any](fmap func(func(O.Option[A]) O.Option[B]) func(HKTFA) HKTFB, f func(A) B) func(HKTFA) HKTFB {
-	// HKTGA = Either[E, A]
-	// HKTGB = Either[E, B]
-	return FC.Map(fmap, O.Map[A, B], f)
-}
-
 func MonadChain[A, B, HKTFA, HKTFB any](
 	fchain func(HKTFA, func(O.Option[A]) HKTFB) HKTFB,
 	fof func(O.Option[B]) HKTFB,
@@ -56,11 +50,13 @@ func MonadChain[A, B, HKTFA, HKTFB any](
 }
 
 func Chain[A, B, HKTFA, HKTFB any](
-	fchain func(func(O.Option[A]) HKTFB) func(HKTFA) HKTFB,
+	fchain func(HKTFA, func(O.Option[A]) HKTFB) HKTFB,
 	fof func(O.Option[B]) HKTFB,
 	f func(A) HKTFB) func(ma HKTFA) HKTFB {
 	// dispatch to the even more generic implementation
-	return fchain(O.Fold(F.Nullary2(O.None[B], fof), f))
+	return func(ma HKTFA) HKTFB {
+		return MonadChain(fchain, fof, ma, f)
+	}
 }
 
 func MonadAp[A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
@@ -71,13 +67,6 @@ func MonadAp[A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
 	return apply.MonadAp(fap, fmap, O.MonadAp[B, A], fab, fa)
 }
 
-func Ap[A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
-	fap func(HKTFA) func(HKTFGAB) HKTFB,
-	fmap func(func(O.Option[func(A) B]) func(O.Option[A]) O.Option[B]) func(HKTFAB) HKTFGAB,
-	fa HKTFA) func(HKTFAB) HKTFB {
-	return apply.Ap(fap, fmap, O.Ap[B, A], fa)
-}
-
 func MatchE[A, HKTEA, HKTB any](mchain func(HKTEA, func(O.Option[A]) HKTB) HKTB, onNone func() HKTB, onSome func(A) HKTB) func(HKTEA) HKTB {
 	return F.Bind2nd(mchain, O.Fold(onNone, onSome))
 }
@@ -97,14 +86,6 @@ func MonadChainOptionK[A, B, HKTA, HKTB any](
 	return MonadChain(fchain, fof, ma, FromOptionK(fof, f))
 }
 
-func ChainOptionK[A, B, HKTA, HKTB any](
-	fchain func(func(O.Option[A]) HKTB) func(HKTA) HKTB,
-	fof func(O.Option[B]) HKTB,
-	f func(A) O.Option[B],
-) func(HKTA) HKTB {
-	return Chain(fchain, fof, FromOptionK(fof, f))
-}
-
 func MonadAlt[LAZY ~func() HKTFA, A, HKTFA any](
 	fof func(O.Option[A]) HKTFA,
 	fchain func(HKTFA, func(O.Option[A]) HKTFA) HKTFA,
@@ -117,9 +98,11 @@ func MonadAlt[LAZY ~func() HKTFA, A, HKTFA any](
 
 func Alt[LAZY ~func() HKTFA, A, HKTFA any](
 	fof func(O.Option[A]) HKTFA,
-	fchain func(func(O.Option[A]) HKTFA) func(HKTFA) HKTFA,
+	fchain func(HKTFA, func(O.Option[A]) HKTFA) HKTFA,
 
 	second LAZY) func(HKTFA) HKTFA {
 
-	return fchain(O.Fold(second, F.Flow2(O.Of[A], fof)))
+	return func(fa HKTFA) HKTFA {
+		return MonadAlt(fof, fchain, fa, second)
+	}
 }

internal/pointed/types.go

@@ -1,21 +0,0 @@
-// 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 pointed
-
-type Pointed[A, HKTA any] interface {
-	// Of lifts a value into its higher kinded type
-	Of(A) HKTA
-}

internal/statet/state.go

@@ -1,198 +0,0 @@
-// 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 state
-
-import (
-	F "github.com/IBM/fp-go/function"
-	P "github.com/IBM/fp-go/pair"
-)
-
-func Of[
-	HKTSA ~func(S) HKTA,
-	HKTA,
-	S, A any,
-](
-	fof func(P.Pair[A, S]) HKTA,
-
-	a A) HKTSA {
-
-	return F.Flow2(
-		F.Bind1st(P.MakePair[A, S], a),
-		fof,
-	)
-}
-
-func MonadMap[
-	HKTSA ~func(S) HKTA,
-	HKTSB ~func(S) HKTB,
-	HKTA,
-	HKTB,
-	S, A, B any,
-](
-	fmap func(HKTA, func(P.Pair[A, S]) P.Pair[B, S]) HKTB,
-
-	fa HKTSA,
-	f func(A) B,
-) HKTSB {
-
-	return F.Flow2(
-		fa,
-		F.Bind2nd(fmap, P.Map[S](f)),
-	)
-}
-
-func Map[
-	HKTSA ~func(S) HKTA,
-	HKTSB ~func(S) HKTB,
-	HKTA,
-	HKTB,
-	S, A, B any,
-](
-	fmap func(func(P.Pair[A, S]) P.Pair[B, S]) func(HKTA) HKTB,
-
-	f func(A) B,
-) func(HKTSA) HKTSB {
-	mp := fmap(P.Map[S](f))
-
-	return func(fa HKTSA) HKTSB {
-		return F.Flow2(
-			fa,
-			mp,
-		)
-	}
-}
-
-func MonadChain[
-	HKTSA ~func(S) HKTA,
-	HKTSB ~func(S) HKTB,
-	HKTA,
-	HKTB,
-	S, A any,
-](
-	fchain func(HKTA, func(P.Pair[A, S]) HKTB) HKTB,
-
-	fa HKTSA,
-	f func(A) HKTSB,
-) HKTSB {
-	return F.Flow2(
-		fa,
-		F.Bind2nd(fchain, func(a P.Pair[A, S]) HKTB {
-			return f(P.Head(a))(P.Tail(a))
-		}),
-	)
-}
-
-func Chain[
-	HKTSA ~func(S) HKTA,
-	HKTSB ~func(S) HKTB,
-	HKTA,
-	HKTB,
-	S, A any,
-](
-	fchain func(func(P.Pair[A, S]) HKTB) func(HKTA) HKTB,
-
-	f func(A) HKTSB,
-) func(HKTSA) HKTSB {
-	mp := fchain(func(a P.Pair[A, S]) HKTB {
-		return f(P.Head(a))(P.Tail(a))
-	})
-
-	return func(fa HKTSA) HKTSB {
-		return F.Flow2(
-			fa,
-			mp,
-		)
-	}
-}
-
-func MonadAp[
-	HKTSA ~func(S) HKTA,
-	HKTSB ~func(S) HKTB,
-	HKTSAB ~func(S) HKTAB,
-	HKTA,
-	HKTB,
-	HKTAB,
-
-	S, A, B any,
-](
-	fmap func(HKTA, func(P.Pair[A, S]) P.Pair[B, S]) HKTB,
-	fchain func(HKTAB, func(P.Pair[func(A) B, S]) HKTB) HKTB,
-
-	fab HKTSAB,
-	fa HKTSA,
-) HKTSB {
-	return func(s S) HKTB {
-		return fchain(fab(s), func(ab P.Pair[func(A) B, S]) HKTB {
-			return fmap(fa(P.Tail(ab)), P.Map[S](P.Head(ab)))
-		})
-	}
-}
-
-func Ap[
-	HKTSA ~func(S) HKTA,
-	HKTSB ~func(S) HKTB,
-	HKTSAB ~func(S) HKTAB,
-	HKTA,
-	HKTB,
-	HKTAB,
-
-	S, A, B any,
-](
-	fmap func(func(P.Pair[A, S]) P.Pair[B, S]) func(HKTA) HKTB,
-	fchain func(func(P.Pair[func(A) B, S]) HKTB) func(HKTAB) HKTB,
-
-	fa HKTSA,
-) func(HKTSAB) HKTSB {
-	return func(fab HKTSAB) HKTSB {
-		return F.Flow2(
-			fab,
-			fchain(func(ab P.Pair[func(A) B, S]) HKTB {
-				return fmap(P.Map[S](P.Head(ab)))(fa(P.Tail(ab)))
-			}),
-		)
-	}
-}
-
-func FromF[
-	HKTSA ~func(S) HKTA,
-	HKTA,
-
-	HKTFA,
-
-	S, A any,
-](
-	fmap func(HKTFA, func(A) P.Pair[A, S]) HKTA,
-	ma HKTFA) HKTSA {
-
-	f1 := F.Bind1st(fmap, ma)
-
-	return func(s S) HKTA {
-		return f1(F.Bind2nd(P.MakePair[A, S], s))
-	}
-}
-
-func FromState[
-	HKTSA ~func(S) HKTA,
-	ST ~func(S) P.Pair[A, S],
-	HKTA,
-
-	S, A any,
-](
-	fof func(P.Pair[A, S]) HKTA,
-	sa ST,
-) HKTSA {
-	return F.Flow2(sa, fof)
-}

internal/testing/sequence.go

@@ -1,183 +0,0 @@
-// 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)))
-		}
-	}
-}

io/eq.go

@@ -24,8 +24,3 @@ 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]]()
-}

io/functor.go

@@ -1,26 +0,0 @@
-// 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]]()
-}

io/gen.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2024-02-29 16:19:10.2607969 +0100 CET m=+0.024787801
+// 2023-10-23 08:30:56.7105551 +0200 CEST m=+0.011255201
 
 package io
 

io/generic/ap.go

@@ -27,11 +27,16 @@ const (
 
 // MonadApSeq implements the applicative on a single thread by first executing mab and the ma
 func MonadApSeq[GA ~func() A, GB ~func() B, GAB ~func() func(A) B, A, B any](mab GAB, ma GA) GB {
-	return MonadChain(mab, F.Bind1st(MonadMap[GA, GB], ma))
+	return MakeIO[GB](func() B {
+		return F.Pipe1(
+			ma(),
+			mab(),
+		)
+	})
 }
 
 // MonadApPar implements the applicative on two threads, the main thread executes mab and the actuall
-// apply operation and the second thread computes ma. Communication between the threads happens via a channel
+// apply operation and the second thred computes ma. Communication between the threads happens via a channel
 func MonadApPar[GA ~func() A, GB ~func() B, GAB ~func() func(A) B, A, B any](mab GAB, ma GA) GB {
 	return MakeIO[GB](func() B {
 		c := make(chan A)

io/generic/eq.go

@@ -33,8 +33,3 @@ 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]())
-}

io/generic/functor.go

@@ -1,31 +0,0 @@
-// 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]{}
-}