doc: add sample for http

Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>
Merge pull request #6 from IBM/cleue-fix-ap
2026-01-15 00:53:10 +02:00 · 2023-07-20 11:48:01 +02:00 · 2023-07-19 17:06:20 +02:00 · 2023-07-19 17:05:50 +02:00 · 2023-07-19 16:21:05 +02:00 · 2023-07-19 16:20:28 +02:00
302 changed files with 5559 additions and 5050 deletions
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -0,0 +1,85 @@
+name: fp-go CI
+
+on:
+  push:
+    branches:
+      - main
+
+  pull_request:
+
+  workflow_dispatch:
+    inputs:
+      dryRun:
+        description: 'Dry-Run'
+        default: 'true'
+        required: false
+
+env:
+  # Currently no way to detect automatically
+  DEFAULT_BRANCH: main
+  GO_VERSION: 1.20.5 # renovate: datasource=golang-version depName=golang
+  NODE_VERSION: 18
+  DRY_RUN: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      # full checkout for semantic-release
+      - uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
+        with:
+          fetch-depth: 0
+      - name: Set up go ${{env.GO_VERSION}}
+        uses: actions/setup-go@v4
+        with:
+          go-version: ${{env.GO_VERSION}}
+      -
+        name: Tests
+        run: |
+          go mod tidy
+          go test -v ./...
+
+  release:
+    needs: [build]
+    if: github.repository == 'IBM/fp-go' && github.event_name != 'pull_request'
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+
+    steps:
+      # full checkout for semantic-release
+      - name: Full checkout
+        uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
+        with:
+          fetch-depth: 0
+
+      - name: Set up Node.js ${{ env.NODE_VERSION }}
+        uses: actions/setup-node@e33196f7422957bea03ed53f6fbb155025ffc7b8 # v3.7.0
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+
+      - name: Set up go ${{env.GO_VERSION}}
+        uses: actions/setup-go@v4
+        with:
+          go-version: ${{env.GO_VERSION}}
+
+      # 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
+              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
+            echo "DRY_RUN=false" >> $GITHUB_ENV
+          fi
+
+      - name: Semantic Release
+        run: |
+          npx -p conventional-changelog-conventionalcommits -p semantic-release semantic-release --dry-run ${{env.DRY_RUN}}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+  
--- a/.releaserc
+++ b/.releaserc
@@ -0,0 +1,67 @@
+{
+  "plugins": [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/release-notes-generator",
+    [
+      "@semantic-release/github",
+      {
+        "releasedLabels": false
+      }
+    ]
+  ],
+  "analyzeCommits": {
+    "releaseRules": [
+      {
+        "type": "build",
+        "release": "patch"
+      }
+    ]
+  },
+  "preset": "conventionalcommits",
+  "presetConfig": {
+    "types": [
+      {
+        "type": "feat",
+        "section": "Features"
+      },
+      {
+        "type": "fix",
+        "section": "Bug Fixes"
+      },
+      {
+        "type": "perf",
+        "section": "Performance Improvements"
+      },
+      {
+        "type": "revert",
+        "section": "Reverts"
+      },
+      {
+        "type": "docs",
+        "section": "Documentation"
+      },
+      {
+        "type": "chore",
+        "section": "Miscellaneous Chores"
+      },
+      {
+        "type": "refactor",
+        "section": "Code Refactoring"
+      },
+      {
+        "type": "test",
+        "section": "Tests"
+      },
+      {
+        "type": "build",
+        "section": "Build System"
+      }
+    ]
+  },
+  "tagFormat": "v${version}",
+  "branches": [
+    {
+      "name": "main"
+    }
+  ]
+}
--- a/README.md
+++ b/README.md
@@ -1,9 +1,19 @@
 # Functional programming library for golang

-**🚧 Work in progress! 🚧**
+**🚧 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)

+This library is strongly influenced by the awesome [fp-ts](https://github.com/gcanti/fp-ts).
+
+## Getting started
+
+```bash
+go get github.com/IBM/fp-go
+```
+
+Refer to the [samples](./samples/). 
+
 ## Design Goal

 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:
@@ -19,7 +29,7 @@ This library aims to provide a set of data types and functions that make it easy

 #### 🧘🏽 Each package fulfils a single purpose

-✔️ Each of the top level packages (e.g. Option, Either, Task, ...) fulfils the purpose of defining the respective data type and implementing the set of common operations for this data type.
+✔️ 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.

 #### 🧘🏽 Handle errors explicitly

@@ -31,7 +41,7 @@ This library aims to provide a set of data types and functions that make it easy

 #### 🧘🏽 Leave concurrency to the caller

-✔️ All operations are synchronous by default, including `Task`. Concurrency must be coded by the consumer of these functions explicitly, but the implementation is ready to deal with concurrent usage.
+✔️ All pure are synchronous by default. The I/O operations are asynchronous per default.

 #### 🧘🏽 Before you launch a goroutine, know when it will stop

@@ -55,7 +65,7 @@ This library aims to provide a set of data types and functions that make it easy

 #### 🧘🏽 Moderation is a virtue

-✔️ The library does not implement its own goroutines and also does not require any expensive synchronization primitives. Coordination of Tasks is implemented via atomic counters without additional primitives. Channels are only used in the `Wait` function of a Task that should be invoked at most once in a complete application.
+✔️ 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

@@ -71,33 +81,57 @@ All monadic operations are implemented via generics, i.e. they offer a type safe

 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
+
+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
+func Map[A, B any](f func(A) B) [R, E any]func(fa ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B]
+```
+
+Note that the parameters `R` and `E` are not needed by the first level of `Map` but only by the resulting higher order function. Instead we need to specify the following:
+
+```go
+func Map[R, E, A, B any](f func(A) B) func(fa ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B]
+```
+
+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
-TaskEither[E, A]
+ReaderIOEither[R, E, A]
 ```

 than

 ```go
-func(func(Either.Either[E, A]))
+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 TaskEither[E, A any] = T.Task[ET.Either[E, A]]
+type ReaderIOEither[R, E, A any] = RD.Reader[R, IOE.IOEither[E, A]]
 ```

 only

 ```go
-type TaskEither[E, A any] T.Task[ET.Either[E, A]]
+type ReaderIOEither[R, E, A any] RD.Reader[R, IOE.IOEither[E, A]]
 ```

-This makes a big difference, because in the second case the type `TaskEither[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.
+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.

 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.

@@ -107,16 +141,16 @@ For that reason there exist sub-packages called `Generic` for all higher level t

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

-The `Map` operation for `Task` is defined as:
+The `Map` operation for `ReaderIOEither` is defined as:

 ```go
-func Map[A, B any](f func(A) B) func(Task[A]) Task[B]
+func Map[R, E, A, B any](f func(A) B) func(fa ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B]
 ```

-and in fact the equivalent operations for all other mondas follow the same pattern, we could try to introduce a new type for `Task` (without a parameter) as a HKT, e.g. like so (made-up syntax, does not work in go):
+and in fact the equivalent operations for all other mondas 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):

 ```go
-func Map[HKT, A, B any](f func(A) B) func(HKT[A]) HKT[B]
+func Map[HKT, R, E, A, B any](f func(A) B) func(HKT[R, E, A]) HKT[R, E, B]
 ```

 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.
--- a/array/array.go
+++ b/array/array.go
@@ -1,12 +1,12 @@
 package array

 import (
-	G "github.com/ibm/fp-go/array/generic"
-	F "github.com/ibm/fp-go/function"
-	"github.com/ibm/fp-go/internal/array"
-	M "github.com/ibm/fp-go/monoid"
-	O "github.com/ibm/fp-go/option"
-	"github.com/ibm/fp-go/tuple"
+	G "github.com/IBM/fp-go/array/generic"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/array"
+	M "github.com/IBM/fp-go/monoid"
+	O "github.com/IBM/fp-go/option"
+	"github.com/IBM/fp-go/tuple"
 )

 // From constructs an array from a set of variadic arguments
--- a/array/array_test.go
+++ b/array/array_test.go
@@ -4,11 +4,11 @@ import (
 	"strings"
 	"testing"

-	F "github.com/ibm/fp-go/function"
-	"github.com/ibm/fp-go/internal/utils"
-	O "github.com/ibm/fp-go/option"
-	S "github.com/ibm/fp-go/string"
-	T "github.com/ibm/fp-go/tuple"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/utils"
+	O "github.com/IBM/fp-go/option"
+	S "github.com/IBM/fp-go/string"
+	T "github.com/IBM/fp-go/tuple"
 	"github.com/stretchr/testify/assert"
 )

--- a/array/eq.go
+++ b/array/eq.go
@@ -1,7 +1,7 @@
 package array

 import (
-	E "github.com/ibm/fp-go/eq"
+	E "github.com/IBM/fp-go/eq"
 )

 func equals[T any](left []T, right []T, eq func(T, T) bool) bool {
--- a/array/generic/array.go
+++ b/array/generic/array.go
@@ -1,10 +1,10 @@
 package generic

 import (
-	F "github.com/ibm/fp-go/function"
-	"github.com/ibm/fp-go/internal/array"
-	O "github.com/ibm/fp-go/option"
-	"github.com/ibm/fp-go/tuple"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/array"
+	O "github.com/IBM/fp-go/option"
+	"github.com/IBM/fp-go/tuple"
 )

 // Of constructs a single element array
--- a/array/generic/sort.go
+++ b/array/generic/sort.go
@@ -3,7 +3,7 @@ package generic
 import (
 	"sort"

-	O "github.com/ibm/fp-go/ord"
+	O "github.com/IBM/fp-go/ord"
 )

 // Sort implements a stable sort on the array given the provided ordering
--- a/array/magma.go
+++ b/array/magma.go
@@ -1,8 +1,8 @@
 package array

 import (
-	F "github.com/ibm/fp-go/function"
-	M "github.com/ibm/fp-go/magma"
+	F "github.com/IBM/fp-go/function"
+	M "github.com/IBM/fp-go/magma"
 )

 func ConcatAll[A any](m M.Magma[A]) func(A) func([]A) A {
--- a/array/magma_test.go
+++ b/array/magma_test.go
@@ -5,7 +5,7 @@ import (

 	"github.com/stretchr/testify/assert"

-	M "github.com/ibm/fp-go/magma"
+	M "github.com/IBM/fp-go/magma"
 )

 var subInt = M.MakeMagma(func(first int, second int) int {
--- a/array/monoid.go
+++ b/array/monoid.go
@@ -1,8 +1,8 @@
 package array

 import (
-	"github.com/ibm/fp-go/internal/array"
-	M "github.com/ibm/fp-go/monoid"
+	"github.com/IBM/fp-go/internal/array"
+	M "github.com/IBM/fp-go/monoid"
 )

 func concat[T any](left, right []T) []T {
--- a/array/monoid_test.go
+++ b/array/monoid_test.go
@@ -3,7 +3,7 @@ package array
 import (
 	"testing"

-	M "github.com/ibm/fp-go/monoid/testing"
+	M "github.com/IBM/fp-go/monoid/testing"
 )

 func TestMonoid(t *testing.T) {
--- a/array/sequence.go
+++ b/array/sequence.go
@@ -1,8 +1,8 @@
 package array

 import (
-	F "github.com/ibm/fp-go/function"
-	O "github.com/ibm/fp-go/option"
+	F "github.com/IBM/fp-go/function"
+	O "github.com/IBM/fp-go/option"
 )

 // 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
--- a/array/sequence_test.go
+++ b/array/sequence_test.go
@@ -5,7 +5,7 @@ import (

 	"github.com/stretchr/testify/assert"

-	O "github.com/ibm/fp-go/option"
+	O "github.com/IBM/fp-go/option"
 )

 func TestSequenceOption(t *testing.T) {
--- a/array/sort.go
+++ b/array/sort.go
@@ -1,8 +1,8 @@
 package array

 import (
-	G "github.com/ibm/fp-go/array/generic"
-	O "github.com/ibm/fp-go/ord"
+	G "github.com/IBM/fp-go/array/generic"
+	O "github.com/IBM/fp-go/ord"
 )

 // Sort implements a stable sort on the array given the provided ordering
--- a/array/sort_test.go
+++ b/array/sort_test.go
@@ -3,7 +3,7 @@ package array
 import (
 	"testing"

-	O "github.com/ibm/fp-go/ord"
+	O "github.com/IBM/fp-go/ord"
 	"github.com/stretchr/testify/assert"
 )

--- a/array/traverse.go
+++ b/array/traverse.go
@@ -1,6 +1,6 @@
 package array

-import "github.com/ibm/fp-go/internal/array"
+import "github.com/IBM/fp-go/internal/array"

 func Traverse[A, B, HKTB, HKTAB, HKTRB any](
 	fof func([]B) HKTRB,
--- a/array/traverse_test.go
+++ b/array/traverse_test.go
@@ -3,7 +3,7 @@ package array
 import (
 	"testing"

-	O "github.com/ibm/fp-go/option"
+	O "github.com/IBM/fp-go/option"
 	"github.com/stretchr/testify/assert"
 )

--- a/bytes/monoid.go
+++ b/bytes/monoid.go
@@ -3,8 +3,8 @@ package bytes
 import (
 	"bytes"

-	A "github.com/ibm/fp-go/array"
-	O "github.com/ibm/fp-go/ord"
+	A "github.com/IBM/fp-go/array"
+	O "github.com/IBM/fp-go/ord"
 )

 var (
--- a/bytes/monoid_test.go
+++ b/bytes/monoid_test.go
@@ -3,7 +3,7 @@ package bytes
 import (
 	"testing"

-	M "github.com/ibm/fp-go/monoid/testing"
+	M "github.com/IBM/fp-go/monoid/testing"
 )

 func TestMonoid(t *testing.T) {
--- a/cli/apply.go
+++ b/cli/apply.go
@@ -380,8 +380,8 @@ func generateApplyHelpers(filename string, count int) error {
 	// print out some helpers
 	fmt.Fprintf(f, `
 import (
-	F "github.com/ibm/fp-go/function"
-	T "github.com/ibm/fp-go/tuple"
+	F "github.com/IBM/fp-go/function"
+	T "github.com/IBM/fp-go/tuple"
 )
 `)

--- a/cli/contextreaderioeither.go
+++ b/cli/contextreaderioeither.go
@@ -5,7 +5,6 @@ import (
 	"log"
 	"os"
 	"path/filepath"
-	"time"

 	C "github.com/urfave/cli/v2"
 )
@@ -84,34 +83,24 @@ func generateContextReaderIOEitherHelpers(filename string, count int) error {
 	// log
 	log.Printf("Generating code in [%s] for package [%s] with [%d] repetitions ...", filename, pkg, count)

-	// some header
-	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
-	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
-
-	fmt.Fprintf(f, "package %s\n\n", pkg)
+	writePackage(f, pkg)

 	fmt.Fprintf(f, `
 import (
 	"context"

-	G "github.com/ibm/fp-go/context/%s/generic"
+	G "github.com/IBM/fp-go/context/%s/generic"
 )
 `, pkg)

-	// some header
-	fmt.Fprintln(fg, "// Code generated by go generate; DO NOT EDIT.")
-	fmt.Fprintln(fg, "// This file was generated by robots at")
-	fmt.Fprintf(fg, "// %s\n", time.Now())
-
-	fmt.Fprintf(fg, "package generic\n\n")
+	writePackage(fg, "generic")

 	fmt.Fprintf(fg, `
 import (
 	"context"

-	E "github.com/ibm/fp-go/either"
-	RE "github.com/ibm/fp-go/readerioeither/generic"
+	E "github.com/IBM/fp-go/either"
+	RE "github.com/IBM/fp-go/readerioeither/generic"
 )
 `)

--- a/cli/either.go
+++ b/cli/either.go
@@ -141,8 +141,8 @@ func generateEitherHelpers(filename string, count int) error {

 	fmt.Fprintf(f, `
 import (
-	A "github.com/ibm/fp-go/internal/apply"
-	T "github.com/ibm/fp-go/tuple"
+	A "github.com/IBM/fp-go/internal/apply"
+	T "github.com/IBM/fp-go/tuple"
 )
 `)

--- a/cli/header.go
+++ b/cli/header.go
@@ -0,0 +1,16 @@
+package cli
+
+import (
+	"fmt"
+	"os"
+	"time"
+)
+
+func writePackage(f *os.File, pkg string) {
+	// print package
+	fmt.Fprintf(f, "package %s\n\n", pkg)
+	// some header
+	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
+	fmt.Fprintln(f, "// This file was generated by robots at")
+	fmt.Fprintf(f, "// %s\n", time.Now())
+}
--- a/cli/identity.go
+++ b/cli/identity.go
@@ -53,8 +53,8 @@ func generateIdentityHelpers(filename string, count int) error {

 	fmt.Fprintf(f, `
 import (
-	A "github.com/ibm/fp-go/internal/apply"
-	T "github.com/ibm/fp-go/tuple"
+	A "github.com/IBM/fp-go/internal/apply"
+	T "github.com/IBM/fp-go/tuple"
 )
 `)

--- a/cli/option.go
+++ b/cli/option.go
@@ -139,8 +139,8 @@ func generateOptionHelpers(filename string, count int) error {

 	fmt.Fprintf(f, `
 import (
-	A "github.com/ibm/fp-go/internal/apply"
-	T "github.com/ibm/fp-go/tuple"
+	A "github.com/IBM/fp-go/internal/apply"
+	T "github.com/IBM/fp-go/tuple"
 )
 `)

--- a/cli/reader.go
+++ b/cli/reader.go
@@ -123,7 +123,7 @@ func generateReaderHelpers(filename string, count int) error {

 	fmt.Fprintf(f, `
 import (
-	G "github.com/ibm/fp-go/%s/generic"	
+	G "github.com/IBM/fp-go/%s/generic"	
 )
 `, pkg)

--- a/cli/readerioeither.go
+++ b/cli/readerioeither.go
@@ -160,7 +160,7 @@ func generateReaderIOEitherHelpers(filename string, count int) error {

 	fmt.Fprintf(f, `
 import (
-	G "github.com/ibm/fp-go/%s/generic"	
+	G "github.com/IBM/fp-go/%s/generic"	
 )
 `, pkg)

@@ -173,8 +173,8 @@ import (

 	fmt.Fprintf(fg, `
 import (
-	E "github.com/ibm/fp-go/either"
-	RD "github.com/ibm/fp-go/reader/generic"
+	E "github.com/IBM/fp-go/either"
+	RD "github.com/IBM/fp-go/reader/generic"
 )
 `)

--- a/cli/tuple.go
+++ b/cli/tuple.go
@@ -346,8 +346,8 @@ func generateTupleHelpers(filename string, count int) error {

 	fmt.Fprintf(f, `
 import (
-	M "github.com/ibm/fp-go/monoid"
-	O "github.com/ibm/fp-go/ord"
+	M "github.com/IBM/fp-go/monoid"
+	O "github.com/IBM/fp-go/ord"
 )
 `)

--- a/context/doc.go
+++ b/context/doc.go
@@ -12,4 +12,6 @@
 // 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 context contains versions of monads that work with a golang [context.Context]
 package context
--- a/context/ioeither/generic/ioeither.go
+++ b/context/ioeither/generic/ioeither.go
@@ -3,9 +3,9 @@ package generic
 import (
 	"context"

-	E "github.com/ibm/fp-go/either"
-	ET "github.com/ibm/fp-go/either"
-	IOE "github.com/ibm/fp-go/ioeither/generic"
+	E "github.com/IBM/fp-go/either"
+	ET "github.com/IBM/fp-go/either"
+	IOE "github.com/IBM/fp-go/ioeither/generic"
 )

 // withContext wraps an existing IOEither and performs a context check for cancellation before delegating
--- a/context/ioeither/ioeither.go
+++ b/context/ioeither/ioeither.go
@@ -3,8 +3,8 @@ package ioeither
 import (
 	"context"

-	G "github.com/ibm/fp-go/context/ioeither/generic"
-	IOE "github.com/ibm/fp-go/ioeither"
+	G "github.com/IBM/fp-go/context/ioeither/generic"
+	IOE "github.com/IBM/fp-go/ioeither"
 )

 // withContext wraps an existing IOEither and performs a context check for cancellation before delegating
--- a/context/reader/array.go
+++ b/context/reader/array.go
@@ -16,7 +16,7 @@
 package reader

 import (
-	R "github.com/ibm/fp-go/reader/generic"
+	R "github.com/IBM/fp-go/reader/generic"
 )

 // TraverseArray transforms an array
--- a/context/reader/curry.go
+++ b/context/reader/curry.go
@@ -18,7 +18,7 @@ package reader
 import (
 	"context"

-	R "github.com/ibm/fp-go/reader/generic"
+	R "github.com/IBM/fp-go/reader/generic"
 )

 // these functions curry a golang function with the context as the firsr parameter into a either reader with the context as the last parameter
--- a/context/reader/from.go
+++ b/context/reader/from.go
@@ -3,7 +3,7 @@ package reader
 import (
 	"context"

-	R "github.com/ibm/fp-go/reader/generic"
+	R "github.com/IBM/fp-go/reader/generic"
 )

 // these functions curry a golang function with the context as the firsr parameter into a either reader with the context as the last parameter
--- a/context/reader/reader.go
+++ b/context/reader/reader.go
@@ -3,7 +3,7 @@ package reader
 import (
 	"context"

-	R "github.com/ibm/fp-go/reader/generic"
+	R "github.com/IBM/fp-go/reader/generic"
 )

 func MonadMap[A, B any](fa Reader[A], f func(A) B) Reader[B] {
--- a/context/reader/reader_test.go
+++ b/context/reader/reader_test.go
@@ -6,8 +6,8 @@ import (
 	"strings"
 	"testing"

-	F "github.com/ibm/fp-go/function"
-	T "github.com/ibm/fp-go/tuple"
+	F "github.com/IBM/fp-go/function"
+	T "github.com/IBM/fp-go/tuple"
 	"github.com/stretchr/testify/assert"
 )

--- a/context/reader/sequence.go
+++ b/context/reader/sequence.go
@@ -1,8 +1,8 @@
 package reader

 import (
-	R "github.com/ibm/fp-go/reader/generic"
-	T "github.com/ibm/fp-go/tuple"
+	R "github.com/IBM/fp-go/reader/generic"
+	T "github.com/IBM/fp-go/tuple"
 )

 // SequenceT converts n inputs of higher kinded types into a higher kinded types of n strongly typed values, represented as a tuple
--- a/context/reader/type.go
+++ b/context/reader/type.go
@@ -4,7 +4,7 @@ package reader
 import (
 	"context"

-	R "github.com/ibm/fp-go/reader"
+	R "github.com/IBM/fp-go/reader"
 )

 // Reader is a specialization of the Reader monad assuming a golang context as the context of the monad
--- a/context/readereither/array.go
+++ b/context/readereither/array.go
@@ -1,7 +1,7 @@
 package readereither

 import (
-	RE "github.com/ibm/fp-go/readereither/generic"
+	RE "github.com/IBM/fp-go/readereither/generic"
 )

 // TraverseArray transforms an array
--- a/context/readereither/cancel.go
+++ b/context/readereither/cancel.go
@@ -3,7 +3,7 @@ package readereither
 import (
 	"context"

-	E "github.com/ibm/fp-go/either"
+	E "github.com/IBM/fp-go/either"
 )

 // withContext wraps an existing ReaderEither and performs a context check for cancellation before deletating
--- a/context/readereither/curry.go
+++ b/context/readereither/curry.go
@@ -3,7 +3,7 @@ package readereither
 import (
 	"context"

-	RE "github.com/ibm/fp-go/readereither/generic"
+	RE "github.com/IBM/fp-go/readereither/generic"
 )

 // these functions curry a golang function with the context as the firsr parameter into a either reader with the context as the last parameter
--- a/context/readereither/exec/exec.go
+++ b/context/readereither/exec/exec.go
@@ -3,11 +3,11 @@ package exec
 import (
 	"context"

-	RE "github.com/ibm/fp-go/context/readereither"
-	E "github.com/ibm/fp-go/either"
-	"github.com/ibm/fp-go/exec"
-	F "github.com/ibm/fp-go/function"
-	GE "github.com/ibm/fp-go/internal/exec"
+	RE "github.com/IBM/fp-go/context/readereither"
+	E "github.com/IBM/fp-go/either"
+	"github.com/IBM/fp-go/exec"
+	F "github.com/IBM/fp-go/function"
+	GE "github.com/IBM/fp-go/internal/exec"
 )

 var (
--- a/context/readereither/from.go
+++ b/context/readereither/from.go
@@ -3,7 +3,7 @@ package readereither
 import (
 	"context"

-	RE "github.com/ibm/fp-go/readereither/generic"
+	RE "github.com/IBM/fp-go/readereither/generic"
 )

 // these functions curry a golang function with the context as the firsr parameter into a either reader with the context as the last parameter
--- a/context/readereither/reader.go
+++ b/context/readereither/reader.go
@@ -3,10 +3,10 @@ package readereither
 import (
 	"context"

-	R "github.com/ibm/fp-go/context/reader"
-	ET "github.com/ibm/fp-go/either"
-	O "github.com/ibm/fp-go/option"
-	RE "github.com/ibm/fp-go/readereither/generic"
+	R "github.com/IBM/fp-go/context/reader"
+	ET "github.com/IBM/fp-go/either"
+	O "github.com/IBM/fp-go/option"
+	RE "github.com/IBM/fp-go/readereither/generic"
 )

 func MakeReaderEither[A any](f func(context.Context) ET.Either[error, A]) ReaderEither[A] {
--- a/context/readereither/sequence.go
+++ b/context/readereither/sequence.go
@@ -1,8 +1,8 @@
 package readereither

 import (
-	RE "github.com/ibm/fp-go/readereither/generic"
-	T "github.com/ibm/fp-go/tuple"
+	RE "github.com/IBM/fp-go/readereither/generic"
+	T "github.com/IBM/fp-go/tuple"
 )

 // SequenceT converts n inputs of higher kinded types into a higher kinded types of n strongly typed values, represented as a tuple
--- a/context/readereither/type.go
+++ b/context/readereither/type.go
@@ -4,7 +4,7 @@ package readereither
 import (
 	"context"

-	RE "github.com/ibm/fp-go/readereither"
+	RE "github.com/IBM/fp-go/readereither"
 )

 // ReaderEither is a specialization of the Reader monad for the typical golang scenario
--- a/context/readerio/array.go
+++ b/context/readerio/array.go
@@ -1,8 +1,8 @@
 package readerio

 import (
-	IO "github.com/ibm/fp-go/io"
-	R "github.com/ibm/fp-go/readerio/generic"
+	IO "github.com/IBM/fp-go/io"
+	R "github.com/IBM/fp-go/readerio/generic"
 )

 // TraverseArray transforms an array
--- a/context/readerio/from.go
+++ b/context/readerio/from.go
@@ -3,8 +3,8 @@ package readerio
 import (
 	"context"

-	IO "github.com/ibm/fp-go/io"
-	R "github.com/ibm/fp-go/readerio/generic"
+	IO "github.com/IBM/fp-go/io"
+	R "github.com/IBM/fp-go/readerio/generic"
 )

 // these functions curry a golang function with the context as the firsr parameter into a either reader with the context as the last parameter
--- a/context/readerio/reader.go
+++ b/context/readerio/reader.go
@@ -3,7 +3,7 @@ package readerio
 import (
 	"context"

-	R "github.com/ibm/fp-go/readerio/generic"
+	R "github.com/IBM/fp-go/readerio/generic"
 )

 func MonadMap[A, B any](fa ReaderIO[A], f func(A) B) ReaderIO[B] {
--- a/context/readerio/reader_test.go
+++ b/context/readerio/reader_test.go
@@ -6,9 +6,9 @@ import (
 	"strings"
 	"testing"

-	F "github.com/ibm/fp-go/function"
-	IO "github.com/ibm/fp-go/io"
-	T "github.com/ibm/fp-go/tuple"
+	F "github.com/IBM/fp-go/function"
+	IO "github.com/IBM/fp-go/io"
+	T "github.com/IBM/fp-go/tuple"
 	"github.com/stretchr/testify/assert"
 )

--- a/context/readerio/sequence.go
+++ b/context/readerio/sequence.go
@@ -1,8 +1,8 @@
 package readerio

 import (
-	R "github.com/ibm/fp-go/readerio/generic"
-	T "github.com/ibm/fp-go/tuple"
+	R "github.com/IBM/fp-go/readerio/generic"
+	T "github.com/IBM/fp-go/tuple"
 )

 // SequenceT converts n inputs of higher kinded types into a higher kinded types of n strongly typed values, represented as a tuple
--- a/context/readerio/type.go
+++ b/context/readerio/type.go
@@ -4,7 +4,7 @@ package readerio
 import (
 	"context"

-	R "github.com/ibm/fp-go/readerio"
+	R "github.com/IBM/fp-go/readerio"
 )

 // ReaderIO is a specialization of the ReaderIO monad assuming a golang context as the context of the monad
--- a/context/readerioeither/cancel.go
+++ b/context/readerioeither/cancel.go
@@ -1,7 +1,7 @@
 package readerioeither

 import (
-	G "github.com/ibm/fp-go/context/readerioeither/generic"
+	G "github.com/IBM/fp-go/context/readerioeither/generic"
 )

 // WithContext wraps an existing ReaderIOEither and performs a context check for cancellation before delegating
--- a/context/readerioeither/doc.go
+++ b/context/readerioeither/doc.go
@@ -1,3 +1,4 @@
+// Package readerioeither contains a version of [ReaderIOEither] that takes a golang [context.Context] as its context
 package readerioeither

 //go:generate go run ../.. contextreaderioeither --count 10 --filename gen.go
--- a/context/readerioeither/eq.go
+++ b/context/readerioeither/eq.go
@@ -3,9 +3,9 @@ package readerioeither
 import (
 	"context"

-	G "github.com/ibm/fp-go/context/readerioeither/generic"
-	ET "github.com/ibm/fp-go/either"
-	EQ "github.com/ibm/fp-go/eq"
+	G "github.com/IBM/fp-go/context/readerioeither/generic"
+	ET "github.com/IBM/fp-go/either"
+	EQ "github.com/IBM/fp-go/eq"
 )

 // Eq implements the equals predicate for values contained in the IOEither monad
--- a/context/readerioeither/exec/exec.go
+++ b/context/readerioeither/exec/exec.go
@@ -3,11 +3,11 @@ package exec
 import (
 	"context"

-	RIOE "github.com/ibm/fp-go/context/readerioeither"
-	"github.com/ibm/fp-go/exec"
-	F "github.com/ibm/fp-go/function"
-	GE "github.com/ibm/fp-go/internal/exec"
-	IOE "github.com/ibm/fp-go/ioeither"
+	RIOE "github.com/IBM/fp-go/context/readerioeither"
+	"github.com/IBM/fp-go/exec"
+	F "github.com/IBM/fp-go/function"
+	GE "github.com/IBM/fp-go/internal/exec"
+	IOE "github.com/IBM/fp-go/ioeither"
 )

 var (
--- a/context/readerioeither/file/file.go
+++ b/context/readerioeither/file/file.go
@@ -5,11 +5,11 @@ import (
 	"io"
 	"os"

-	RIOE "github.com/ibm/fp-go/context/readerioeither"
-	ET "github.com/ibm/fp-go/either"
-	F "github.com/ibm/fp-go/function"
-	"github.com/ibm/fp-go/internal/file"
-	IOE "github.com/ibm/fp-go/ioeither"
+	RIOE "github.com/IBM/fp-go/context/readerioeither"
+	ET "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/file"
+	IOE "github.com/IBM/fp-go/ioeither"
 )

 var (
--- a/context/readerioeither/gen.go
+++ b/context/readerioeither/gen.go
@@ -1,77 +1,77 @@
-// Code generated by go generate; DO NOT EDIT.
-// This file was generated by robots at
-// 2023-07-18 15:21:14.8906482 +0200 CEST m=+0.127356001
 package readerioeither

+// Code generated by go generate; DO NOT EDIT.
+// This file was generated by robots at
+// 2023-07-19 16:18:34.1521763 +0200 CEST m=+0.011558001

 import (
 	"context"

-	G "github.com/ibm/fp-go/context/readerioeither/generic"
+	G "github.com/IBM/fp-go/context/readerioeither/generic"
 )

 // Eitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize0]
 func Eitherize0[F ~func(context.Context) (R, error), R any](f F) func() ReaderIOEither[R] {
-  return G.Eitherize0[ReaderIOEither[R]](f)
+	return G.Eitherize0[ReaderIOEither[R]](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)
+	return G.Eitherize1[ReaderIOEither[R]](f)
 }

 // Eitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize2]
 func Eitherize2[F ~func(context.Context, T0, T1) (R, error), T0, T1, R any](f F) func(T0, T1) ReaderIOEither[R] {
-  return G.Eitherize2[ReaderIOEither[R]](f)
+	return G.Eitherize2[ReaderIOEither[R]](f)
 }

 // Eitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize3]
 func Eitherize3[F ~func(context.Context, T0, T1, T2) (R, error), T0, T1, T2, R any](f F) func(T0, T1, T2) ReaderIOEither[R] {
-  return G.Eitherize3[ReaderIOEither[R]](f)
+	return G.Eitherize3[ReaderIOEither[R]](f)
 }

 // Eitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize4]
 func Eitherize4[F ~func(context.Context, T0, T1, T2, T3) (R, error), T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) ReaderIOEither[R] {
-  return G.Eitherize4[ReaderIOEither[R]](f)
+	return G.Eitherize4[ReaderIOEither[R]](f)
 }

 // Eitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize5]
 func Eitherize5[F ~func(context.Context, T0, T1, T2, T3, T4) (R, error), T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) ReaderIOEither[R] {
-  return G.Eitherize5[ReaderIOEither[R]](f)
+	return G.Eitherize5[ReaderIOEither[R]](f)
 }

 // Eitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize6]
 func Eitherize6[F ~func(context.Context, T0, T1, T2, T3, T4, T5) (R, error), T0, T1, T2, T3, T4, T5, R any](f F) func(T0, T1, T2, T3, T4, T5) ReaderIOEither[R] {
-  return G.Eitherize6[ReaderIOEither[R]](f)
+	return G.Eitherize6[ReaderIOEither[R]](f)
 }

 // Eitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize7]
 func Eitherize7[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error), T0, T1, T2, T3, T4, T5, T6, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) ReaderIOEither[R] {
-  return G.Eitherize7[ReaderIOEither[R]](f)
+	return G.Eitherize7[ReaderIOEither[R]](f)
 }

 // Eitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize8]
 func Eitherize8[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) ReaderIOEither[R] {
-  return G.Eitherize8[ReaderIOEither[R]](f)
+	return G.Eitherize8[ReaderIOEither[R]](f)
 }

 // Eitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize9]
 func Eitherize9[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) ReaderIOEither[R] {
-  return G.Eitherize9[ReaderIOEither[R]](f)
+	return G.Eitherize9[ReaderIOEither[R]](f)
 }

 // Eitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize10]
 func Eitherize10[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[R] {
-  return G.Eitherize10[ReaderIOEither[R]](f)
+	return G.Eitherize10[ReaderIOEither[R]](f)
 }
--- a/context/readerioeither/generic/cancel.go
+++ b/context/readerioeither/generic/cancel.go
@@ -3,9 +3,9 @@ package generic
 import (
 	"context"

-	CIOE "github.com/ibm/fp-go/context/ioeither/generic"
-	E "github.com/ibm/fp-go/either"
-	IOE "github.com/ibm/fp-go/ioeither/generic"
+	CIOE "github.com/IBM/fp-go/context/ioeither/generic"
+	E "github.com/IBM/fp-go/either"
+	IOE "github.com/IBM/fp-go/ioeither/generic"
 )

 // withContext wraps an existing ReaderIOEither and performs a context check for cancellation before delegating
--- a/context/readerioeither/generic/eq.go
+++ b/context/readerioeither/generic/eq.go
@@ -3,13 +3,12 @@ package generic
 import (
 	"context"

-	E "github.com/ibm/fp-go/either"
-	ET "github.com/ibm/fp-go/either"
-	EQ "github.com/ibm/fp-go/eq"
-	G "github.com/ibm/fp-go/readerioeither/generic"
+	E "github.com/IBM/fp-go/either"
+	EQ "github.com/IBM/fp-go/eq"
+	G "github.com/IBM/fp-go/readerioeither/generic"
 )

 // Eq implements the equals predicate for values contained in the IOEither monad
-func Eq[GRA ~func(context.Context) GIOA, GIOA ~func() E.Either[error, A], A any](eq EQ.Eq[ET.Either[error, A]]) func(context.Context) EQ.Eq[GRA] {
+func Eq[GRA ~func(context.Context) GIOA, GIOA ~func() E.Either[error, A], A any](eq EQ.Eq[E.Either[error, A]]) func(context.Context) EQ.Eq[GRA] {
 	return G.Eq[GRA](eq)
 }
--- a/context/readerioeither/generic/gen.go
+++ b/context/readerioeither/generic/gen.go
@@ -1,78 +1,78 @@
-// Code generated by go generate; DO NOT EDIT.
-// This file was generated by robots at
-// 2023-07-18 15:21:14.8906482 +0200 CEST m=+0.127356001
 package generic

+// Code generated by go generate; DO NOT EDIT.
+// This file was generated by robots at
+// 2023-07-19 16:18:34.1526819 +0200 CEST m=+0.012063601

 import (
 	"context"

-	E "github.com/ibm/fp-go/either"
-	RE "github.com/ibm/fp-go/readerioeither/generic"
+	E "github.com/IBM/fp-go/either"
+	RE "github.com/IBM/fp-go/readerioeither/generic"
 )

 // Eitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [GRA]
 // The inverse function is [Uneitherize0]
 func Eitherize0[GRA ~func(context.Context) GIOA, F ~func(context.Context) (R, error), GIOA ~func() E.Either[error, R], R any](f F) func() GRA {
-  return RE.Eitherize0[GRA](f)
+	return RE.Eitherize0[GRA](f)
 }

 // 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)
+	return RE.Eitherize1[GRA](f)
 }

 // Eitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning a [GRA]
 // The inverse function is [Uneitherize2]
 func Eitherize2[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1) (R, error), GIOA ~func() E.Either[error, R], T0, T1, R any](f F) func(T0, T1) GRA {
-  return RE.Eitherize2[GRA](f)
+	return RE.Eitherize2[GRA](f)
 }

 // Eitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning a [GRA]
 // The inverse function is [Uneitherize3]
 func Eitherize3[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 F) func(T0, T1, T2) GRA {
-  return RE.Eitherize3[GRA](f)
+	return RE.Eitherize3[GRA](f)
 }

 // Eitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning a [GRA]
 // The inverse function is [Uneitherize4]
 func Eitherize4[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 F) func(T0, T1, T2, T3) GRA {
-  return RE.Eitherize4[GRA](f)
+	return RE.Eitherize4[GRA](f)
 }

 // Eitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning a [GRA]
 // The inverse function is [Uneitherize5]
 func Eitherize5[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 F) func(T0, T1, T2, T3, T4) GRA {
-  return RE.Eitherize5[GRA](f)
+	return RE.Eitherize5[GRA](f)
 }

 // Eitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning a [GRA]
 // The inverse function is [Uneitherize6]
 func Eitherize6[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 F) func(T0, T1, T2, T3, T4, T5) GRA {
-  return RE.Eitherize6[GRA](f)
+	return RE.Eitherize6[GRA](f)
 }

 // Eitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning a [GRA]
 // The inverse function is [Uneitherize7]
 func Eitherize7[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 F) func(T0, T1, T2, T3, T4, T5, T6) GRA {
-  return RE.Eitherize7[GRA](f)
+	return RE.Eitherize7[GRA](f)
 }

 // Eitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning a [GRA]
 // The inverse function is [Uneitherize8]
 func Eitherize8[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 F) func(T0, T1, T2, T3, T4, T5, T6, T7) GRA {
-  return RE.Eitherize8[GRA](f)
+	return RE.Eitherize8[GRA](f)
 }

 // Eitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning a [GRA]
 // The inverse function is [Uneitherize9]
 func Eitherize9[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 F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA {
-  return RE.Eitherize9[GRA](f)
+	return RE.Eitherize9[GRA](f)
 }

 // Eitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning a [GRA]
 // The inverse function is [Uneitherize10]
 func Eitherize10[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 F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA {
-  return RE.Eitherize10[GRA](f)
+	return RE.Eitherize10[GRA](f)
 }
--- a/context/readerioeither/generic/reader.go
+++ b/context/readerioeither/generic/reader.go
@@ -4,13 +4,13 @@ import (
 	"context"
 	"time"

-	E "github.com/ibm/fp-go/either"
-	ER "github.com/ibm/fp-go/errors"
-	F "github.com/ibm/fp-go/function"
-	IO "github.com/ibm/fp-go/io/generic"
-	IOE "github.com/ibm/fp-go/ioeither/generic"
-	O "github.com/ibm/fp-go/option"
-	RIE "github.com/ibm/fp-go/readerioeither/generic"
+	E "github.com/IBM/fp-go/either"
+	ER "github.com/IBM/fp-go/errors"
+	F "github.com/IBM/fp-go/function"
+	IO "github.com/IBM/fp-go/io/generic"
+	IOE "github.com/IBM/fp-go/ioeither/generic"
+	O "github.com/IBM/fp-go/option"
+	RIE "github.com/IBM/fp-go/readerioeither/generic"
 )

 func FromEither[
@@ -194,9 +194,9 @@ func Ap[
 	GRAB ~func(context.Context) GIOAB,
 	GRA ~func(context.Context) GIOA,

-	GIOA ~func() E.Either[error, A],
 	GIOB ~func() E.Either[error, B],
 	GIOAB ~func() E.Either[error, func(A) B],
+	GIOA ~func() E.Either[error, A],

 	A, B any](fa GRA) func(GRAB) GRB {
 	return F.Bind2nd(MonadAp[GRB, GRA, GRAB], fa)
--- a/context/readerioeither/generic/resource.go
+++ b/context/readerioeither/generic/resource.go
@@ -3,9 +3,9 @@ package generic
 import (
 	"context"

-	E "github.com/ibm/fp-go/either"
-	F "github.com/ibm/fp-go/function"
-	RIE "github.com/ibm/fp-go/readerioeither/generic"
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	RIE "github.com/IBM/fp-go/readerioeither/generic"
 )

 // WithResource constructs a function that creates a resource, then operates on it and then releases the resource
--- a/context/readerioeither/generic/sequence.go
+++ b/context/readerioeither/generic/sequence.go
@@ -3,9 +3,9 @@ package generic
 import (
 	"context"

-	E "github.com/ibm/fp-go/either"
-	RE "github.com/ibm/fp-go/readerioeither/generic"
-	T "github.com/ibm/fp-go/tuple"
+	E "github.com/IBM/fp-go/either"
+	RE "github.com/IBM/fp-go/readerioeither/generic"
+	T "github.com/IBM/fp-go/tuple"
 )

 // SequenceT converts n inputs of higher kinded types into a higher kinded types of n strongly typed values, represented as a tuple
--- a/context/readerioeither/generic/traverse.go
+++ b/context/readerioeither/generic/traverse.go
@@ -3,10 +3,31 @@ package generic
 import (
 	"context"

-	E "github.com/ibm/fp-go/either"
-	RE "github.com/ibm/fp-go/readerioeither/generic"
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	RA "github.com/IBM/fp-go/internal/array"
+	RR "github.com/IBM/fp-go/internal/record"
 )

+// MonadTraverseArray transforms an array
+func MonadTraverseArray[
+	AS ~[]A,
+	GRBS ~func(context.Context) GIOBS,
+	GRB ~func(context.Context) GIOB,
+	GIOBS ~func() E.Either[error, BS],
+	GIOB ~func() E.Either[error, B],
+	BS ~[]B,
+	A, B any](as AS, f func(A) GRB) GRBS {
+
+	return RA.MonadTraverse[AS](
+		Of[GRBS, GIOBS, BS],
+		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
+		Ap[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		as, f,
+	)
+}
+
 // TraverseArray transforms an array
 func TraverseArray[
 	AS ~[]A,
@@ -16,7 +37,14 @@ func TraverseArray[
 	GIOB ~func() E.Either[error, B],
 	BS ~[]B,
 	A, B any](f func(A) GRB) func(AS) GRBS {
-	return RE.TraverseArray[GRB, GRBS, GIOB, GIOBS, AS](f)
+
+	return RA.Traverse[AS](
+		Of[GRBS, GIOBS, BS],
+		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
+		Ap[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		f,
+	)
 }

 // SequenceArray converts a homogeneous sequence of either into an either of sequence
@@ -28,7 +56,28 @@ func SequenceArray[
 	GIOAS ~func() E.Either[error, AS],
 	GIOA ~func() E.Either[error, A],
 	A any](ma GAS) GRAS {
-	return RE.SequenceArray[GRA, GRAS](ma)
+
+	return MonadTraverseArray[GAS, GRAS](ma, F.Identity[GRA])
+}
+
+// MonadTraverseRecord transforms a record
+func MonadTraverseRecord[K comparable,
+	AS ~map[K]A,
+	GRBS ~func(context.Context) GIOBS,
+	GRB ~func(context.Context) GIOB,
+	GIOBS ~func() E.Either[error, BS],
+	GIOB ~func() E.Either[error, B],
+	BS ~map[K]B,
+
+	A, B any](ma AS, f func(A) GRB) GRBS {
+
+	return RR.MonadTraverse[AS](
+		Of[GRBS, GIOBS, BS],
+		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
+		Ap[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		ma, f,
+	)
 }

 // TraverseRecord transforms a record
@@ -41,7 +90,14 @@ func TraverseRecord[K comparable,
 	BS ~map[K]B,

 	A, B any](f func(A) GRB) func(AS) GRBS {
-	return RE.TraverseRecord[GRB, GRBS, GIOB, GIOBS, AS](f)
+
+	return RR.Traverse[AS](
+		Of[GRBS, GIOBS, BS],
+		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
+		Ap[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
+
+		f,
+	)
 }

 // SequenceRecord converts a homogeneous sequence of either into an either of sequence
@@ -53,5 +109,6 @@ func SequenceRecord[K comparable,
 	GIOAS ~func() E.Either[error, AS],
 	GIOA ~func() E.Either[error, A],
 	A any](ma GAS) GRAS {
-	return RE.SequenceRecord[GRA, GRAS](ma)
+
+	return MonadTraverseRecord[K, GAS, GRAS](ma, F.Identity[GRA])
 }
--- a/context/readerioeither/http/request.go
+++ b/context/readerioeither/http/request.go
@@ -4,14 +4,14 @@ import (
 	"io"
 	"net/http"

-	B "github.com/ibm/fp-go/bytes"
-	RIOE "github.com/ibm/fp-go/context/readerioeither"
-	F "github.com/ibm/fp-go/function"
-	H "github.com/ibm/fp-go/http"
-	IOE "github.com/ibm/fp-go/ioeither"
-	IOEF "github.com/ibm/fp-go/ioeither/file"
-	J "github.com/ibm/fp-go/json"
-	T "github.com/ibm/fp-go/tuple"
+	B "github.com/IBM/fp-go/bytes"
+	RIOE "github.com/IBM/fp-go/context/readerioeither"
+	F "github.com/IBM/fp-go/function"
+	H "github.com/IBM/fp-go/http"
+	IOE "github.com/IBM/fp-go/ioeither"
+	IOEF "github.com/IBM/fp-go/ioeither/file"
+	J "github.com/IBM/fp-go/json"
+	T "github.com/IBM/fp-go/tuple"
 )

 type (
--- a/context/readerioeither/reader.go
+++ b/context/readerioeither/reader.go
@@ -4,13 +4,13 @@ import (
 	"context"
 	"time"

-	R "github.com/ibm/fp-go/context/reader"
-	RIO "github.com/ibm/fp-go/context/readerio"
-	G "github.com/ibm/fp-go/context/readerioeither/generic"
-	ET "github.com/ibm/fp-go/either"
-	IO "github.com/ibm/fp-go/io"
-	IOE "github.com/ibm/fp-go/ioeither"
-	O "github.com/ibm/fp-go/option"
+	R "github.com/IBM/fp-go/context/reader"
+	RIO "github.com/IBM/fp-go/context/readerio"
+	G "github.com/IBM/fp-go/context/readerioeither/generic"
+	ET "github.com/IBM/fp-go/either"
+	IO "github.com/IBM/fp-go/io"
+	IOE "github.com/IBM/fp-go/ioeither"
+	O "github.com/IBM/fp-go/option"
 )

 func FromEither[A any](e ET.Either[error, A]) ReaderIOEither[A] {
--- a/context/readerioeither/reader_test.go
+++ b/context/readerioeither/reader_test.go
@@ -6,9 +6,9 @@ import (
 	"testing"
 	"time"

-	E "github.com/ibm/fp-go/either"
-	F "github.com/ibm/fp-go/function"
-	"github.com/ibm/fp-go/internal/utils"
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/utils"
 	"github.com/stretchr/testify/assert"
 )

--- a/context/readerioeither/resource.go
+++ b/context/readerioeither/resource.go
@@ -1,7 +1,7 @@
 package readerioeither

 import (
-	G "github.com/ibm/fp-go/context/readerioeither/generic"
+	G "github.com/IBM/fp-go/context/readerioeither/generic"
 )

 // WithResource constructs a function that creates a resource, then operates on it and then releases the resource
--- a/context/readerioeither/sequence.go
+++ b/context/readerioeither/sequence.go
@@ -1,8 +1,8 @@
 package readerioeither

 import (
-	G "github.com/ibm/fp-go/context/readerioeither/generic"
-	T "github.com/ibm/fp-go/tuple"
+	G "github.com/IBM/fp-go/context/readerioeither/generic"
+	T "github.com/IBM/fp-go/tuple"
 )

 // SequenceT converts n inputs of higher kinded types into a higher kinded types of n strongly typed values, represented as a tuple
--- a/context/readerioeither/traverse.go
+++ b/context/readerioeither/traverse.go
@@ -1,10 +1,10 @@
 package readerioeither

 import (
-	G "github.com/ibm/fp-go/context/readerioeither/generic"
+	G "github.com/IBM/fp-go/context/readerioeither/generic"
 )

-// TraverseArray transforms an array
+// TraverseArray uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
 func TraverseArray[A, B any](f func(A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] {
 	return G.TraverseArray[[]A, ReaderIOEither[[]B]](f)
 }
@@ -14,7 +14,7 @@ func SequenceArray[A any](ma []ReaderIOEither[A]) ReaderIOEither[[]A] {
 	return G.SequenceArray[[]A, []ReaderIOEither[A], ReaderIOEither[[]A]](ma)
 }

-// TraverseRecord transforms a record
+// TraverseRecord uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
 func TraverseRecord[K comparable, A, B any](f func(A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] {
 	return G.TraverseRecord[K, map[K]A, ReaderIOEither[map[K]B]](f)
 }
--- a/context/readerioeither/type.go
+++ b/context/readerioeither/type.go
@@ -4,7 +4,7 @@ package readerioeither
 import (
 	"context"

-	RE "github.com/ibm/fp-go/readerioeither"
+	RE "github.com/IBM/fp-go/readerioeither"
 )

 // ReaderIOEither is a specialization of the Reader monad for the typical golang scenario
--- a/either/apply.go
+++ b/either/apply.go
@@ -1,8 +1,8 @@
 package either

 import (
-	M "github.com/ibm/fp-go/monoid"
-	S "github.com/ibm/fp-go/semigroup"
+	M "github.com/IBM/fp-go/monoid"
+	S "github.com/IBM/fp-go/semigroup"
 )

 func ApplySemigroup[E, A any](s S.Semigroup[A]) S.Semigroup[Either[E, A]] {
--- a/either/apply_test.go
+++ b/either/apply_test.go
@@ -3,8 +3,8 @@ package either
 import (
 	"testing"

-	M "github.com/ibm/fp-go/monoid/testing"
-	N "github.com/ibm/fp-go/number"
+	M "github.com/IBM/fp-go/monoid/testing"
+	N "github.com/IBM/fp-go/number"
 	"github.com/stretchr/testify/assert"
 )

--- a/either/curry.go
+++ b/either/curry.go
@@ -1,7 +1,7 @@
 package either

 import (
-	F "github.com/ibm/fp-go/function"
+	F "github.com/IBM/fp-go/function"
 )

 // these function curry a golang function that returns an error into its curried version that returns an either
--- a/either/either.go
+++ b/either/either.go
@@ -5,9 +5,9 @@
 package either

 import (
-	E "github.com/ibm/fp-go/errors"
-	F "github.com/ibm/fp-go/function"
-	O "github.com/ibm/fp-go/option"
+	E "github.com/IBM/fp-go/errors"
+	F "github.com/IBM/fp-go/function"
+	O "github.com/IBM/fp-go/option"
 )

 // Of is equivalent to [Right]
--- a/either/either_test.go
+++ b/either/either_test.go
@@ -4,10 +4,10 @@ import (
 	"errors"
 	"testing"

-	F "github.com/ibm/fp-go/function"
-	"github.com/ibm/fp-go/internal/utils"
-	O "github.com/ibm/fp-go/option"
-	S "github.com/ibm/fp-go/string"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/utils"
+	O "github.com/IBM/fp-go/option"
+	S "github.com/IBM/fp-go/string"
 	"github.com/stretchr/testify/assert"
 )

--- a/either/eq.go
+++ b/either/eq.go
@@ -1,8 +1,8 @@
 package either

 import (
-	EQ "github.com/ibm/fp-go/eq"
-	F "github.com/ibm/fp-go/function"
+	EQ "github.com/IBM/fp-go/eq"
+	F "github.com/IBM/fp-go/function"
 )

 // Constructs an equal predicate for an `Either`
--- a/either/exec/exec.go
+++ b/either/exec/exec.go
@@ -3,10 +3,10 @@ package exec
 import (
 	"context"

-	E "github.com/ibm/fp-go/either"
-	"github.com/ibm/fp-go/exec"
-	F "github.com/ibm/fp-go/function"
-	GE "github.com/ibm/fp-go/internal/exec"
+	E "github.com/IBM/fp-go/either"
+	"github.com/IBM/fp-go/exec"
+	F "github.com/IBM/fp-go/function"
+	GE "github.com/IBM/fp-go/internal/exec"
 )

 var (
--- a/either/gen.go
+++ b/either/gen.go
--- a/either/http/request.go
+++ b/either/http/request.go
@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"net/http"

-	E "github.com/ibm/fp-go/either"
+	E "github.com/IBM/fp-go/either"
 )

 var (
--- a/either/logger.go
+++ b/either/logger.go
@@ -3,8 +3,8 @@ package either
 import (
 	"log"

-	F "github.com/ibm/fp-go/function"
-	L "github.com/ibm/fp-go/logging"
+	F "github.com/IBM/fp-go/function"
+	L "github.com/IBM/fp-go/logging"
 )

 func _log[E, A any](left func(string, ...any), right func(string, ...any), prefix string) func(Either[E, A]) Either[E, A] {
--- a/either/logger_test.go
+++ b/either/logger_test.go
@@ -3,7 +3,7 @@ package either
 import (
 	"testing"

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

--- a/either/record.go
+++ b/either/record.go
@@ -1,8 +1,8 @@
 package either

 import (
-	F "github.com/ibm/fp-go/function"
-	RR "github.com/ibm/fp-go/internal/record"
+	F "github.com/IBM/fp-go/function"
+	RR "github.com/IBM/fp-go/internal/record"
 )

 // TraverseRecord transforms a record of options into an option of a record
--- a/either/resource.go
+++ b/either/resource.go
@@ -1,7 +1,7 @@
 package either

 import (
-	F "github.com/ibm/fp-go/function"
+	F "github.com/IBM/fp-go/function"
 )

 // constructs a function that creates a resource, then operates on it and then releases the resource
--- a/either/resource_test.go
+++ b/either/resource_test.go
@@ -4,7 +4,7 @@ import (
 	"os"
 	"testing"

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

--- a/either/testing/laws.go
+++ b/either/testing/laws.go
@@ -3,9 +3,9 @@ package testing
 import (
 	"testing"

-	ET "github.com/ibm/fp-go/either"
-	EQ "github.com/ibm/fp-go/eq"
-	L "github.com/ibm/fp-go/internal/monad/testing"
+	ET "github.com/IBM/fp-go/either"
+	EQ "github.com/IBM/fp-go/eq"
+	L "github.com/IBM/fp-go/internal/monad/testing"
 )

 // AssertLaws asserts the apply monad laws for the `Either` monad
--- a/either/testing/laws_test.go
+++ b/either/testing/laws_test.go
@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"testing"

-	EQ "github.com/ibm/fp-go/eq"
+	EQ "github.com/IBM/fp-go/eq"
 	"github.com/stretchr/testify/assert"
 )

--- a/either/traverse.go
+++ b/either/traverse.go
@@ -1,7 +1,7 @@
 package either

 import (
-	F "github.com/ibm/fp-go/function"
+	F "github.com/IBM/fp-go/function"
 )

 /*
--- a/either/traverse_test.go
+++ b/either/traverse_test.go
@@ -3,8 +3,8 @@ package either
 import (
 	"testing"

-	F "github.com/ibm/fp-go/function"
-	O "github.com/ibm/fp-go/option"
+	F "github.com/IBM/fp-go/function"
+	O "github.com/IBM/fp-go/option"
 	"github.com/stretchr/testify/assert"
 )

--- a/eq/eq.go
+++ b/eq/eq.go
@@ -1,7 +1,7 @@
 package eq

 import (
-	F "github.com/ibm/fp-go/function"
+	F "github.com/IBM/fp-go/function"
 )

 type Eq[T any] interface {
--- a/eq/monoid.go
+++ b/eq/monoid.go
@@ -1,8 +1,8 @@
 package eq

 import (
-	M "github.com/ibm/fp-go/monoid"
-	S "github.com/ibm/fp-go/semigroup"
+	M "github.com/IBM/fp-go/monoid"
+	S "github.com/IBM/fp-go/semigroup"
 )

 func Semigroup[A any]() S.Semigroup[Eq[A]] {
--- a/eq/testing/eq.go
+++ b/eq/testing/eq.go
@@ -1,7 +1,7 @@
 package testing

 import (
-	EQ "github.com/ibm/fp-go/eq"
+	EQ "github.com/IBM/fp-go/eq"
 	"github.com/stretchr/testify/assert"
 )

--- a/errors/conv.go
+++ b/errors/conv.go
@@ -3,7 +3,7 @@ package errors
 import (
 	"errors"

-	O "github.com/ibm/fp-go/option"
+	O "github.com/IBM/fp-go/option"
 )

 // As tries to extract the error of desired type from the given error
--- a/errors/conv_test.go
+++ b/errors/conv_test.go
@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"testing"

-	F "github.com/ibm/fp-go/function"
-	O "github.com/ibm/fp-go/option"
+	F "github.com/IBM/fp-go/function"
+	O "github.com/IBM/fp-go/option"
 	"github.com/stretchr/testify/assert"
 )

--- a/errors/identity.go
+++ b/errors/identity.go
@@ -1,7 +1,7 @@
 package errors

 import (
-	F "github.com/ibm/fp-go/function"
+	F "github.com/IBM/fp-go/function"
 )

 var IdentityError = F.Identity[error]
--- a/errors/messages.go
+++ b/errors/messages.go
@@ -3,7 +3,7 @@ package errors
 import (
 	"fmt"

-	A "github.com/ibm/fp-go/array"
+	A "github.com/IBM/fp-go/array"
 )

 // OnNone generates a nullary function that produces a formatted error
--- a/exec/exec.go
+++ b/exec/exec.go
@@ -1,7 +1,7 @@
 package exec

 import (
-	T "github.com/ibm/fp-go/tuple"
+	T "github.com/IBM/fp-go/tuple"
 )

 type (
--- a/function/binds.go
+++ b/function/binds.go
@@ -1,450 +1,454 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-18 15:21:26.5345454 +0200 CEST m=+0.141115301
+// 2023-07-19 16:18:40.5224382 +0200 CEST m=+0.122863501
 package function
+
 // Combinations for a total of 1 arguments

 // Bind1of1 takes a function with 1 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
 // The return value of is a function with the remaining 0 parameters at positions [] of the original function.
 func Bind1of1[F ~func(T1) R, T1, R any](f F) func(T1) func() R {
-  return func(t1 T1) func() R {
-    return func() R {
-      return f(t1)
-    }
-  }
+	return func(t1 T1) func() R {
+		return func() R {
+			return f(t1)
+		}
+	}
 }

 // Ignore1of1 takes a function with 0 parameters and returns a new function with 1 parameters that will ignore the values at positions [1] and pass the remaining 0 parameters to the original function
 func Ignore1of1[T1 any, F ~func() R, R any](f F) func(T1) R {
-  return func(t1 T1) R {
-      return f()
-  }
+	return func(t1 T1) R {
+		return f()
+	}
 }
+
 // Combinations for a total of 2 arguments

 // Bind1of2 takes a function with 2 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [2] of the original function.
 func Bind1of2[F ~func(T1, T2) R, T1, T2, R any](f F) func(T1) func(T2) R {
-  return func(t1 T1) func(T2) R {
-    return func(t2 T2) R {
-      return f(t1, t2)
-    }
-  }
+	return func(t1 T1) func(T2) R {
+		return func(t2 T2) R {
+			return f(t1, t2)
+		}
+	}
 }

 // Ignore1of2 takes a function with 1 parameters and returns a new function with 2 parameters that will ignore the values at positions [1] and pass the remaining 1 parameters to the original function
 func Ignore1of2[T1 any, F ~func(T2) R, T2, R any](f F) func(T1, T2) R {
-  return func(t1 T1, t2 T2) R {
-      return f(t2)
-  }
+	return func(t1 T1, t2 T2) R {
+		return f(t2)
+	}
 }

 // Bind2of2 takes a function with 2 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [2] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [1] of the original function.
 func Bind2of2[F ~func(T1, T2) R, T1, T2, R any](f F) func(T2) func(T1) R {
-  return func(t2 T2) func(T1) R {
-    return func(t1 T1) R {
-      return f(t1, t2)
-    }
-  }
+	return func(t2 T2) func(T1) R {
+		return func(t1 T1) R {
+			return f(t1, t2)
+		}
+	}
 }

 // Ignore2of2 takes a function with 1 parameters and returns a new function with 2 parameters that will ignore the values at positions [2] and pass the remaining 1 parameters to the original function
 func Ignore2of2[T2 any, F ~func(T1) R, T1, R any](f F) func(T1, T2) R {
-  return func(t1 T1, t2 T2) R {
-      return f(t1)
-  }
+	return func(t1 T1, t2 T2) R {
+		return f(t1)
+	}
 }

 // Bind12of2 takes a function with 2 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 2] of the original function.
 // The return value of is a function with the remaining 0 parameters at positions [] of the original function.
 func Bind12of2[F ~func(T1, T2) R, T1, T2, R any](f F) func(T1, T2) func() R {
-  return func(t1 T1, t2 T2) func() R {
-    return func() R {
-      return f(t1, t2)
-    }
-  }
+	return func(t1 T1, t2 T2) func() R {
+		return func() R {
+			return f(t1, t2)
+		}
+	}
 }

 // Ignore12of2 takes a function with 0 parameters and returns a new function with 2 parameters that will ignore the values at positions [1, 2] and pass the remaining 0 parameters to the original function
 func Ignore12of2[T1, T2 any, F ~func() R, R any](f F) func(T1, T2) R {
-  return func(t1 T1, t2 T2) R {
-      return f()
-  }
+	return func(t1 T1, t2 T2) R {
+		return f()
+	}
 }
+
 // Combinations for a total of 3 arguments

 // Bind1of3 takes a function with 3 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [2, 3] of the original function.
 func Bind1of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T1) func(T2, T3) R {
-  return func(t1 T1) func(T2, T3) R {
-    return func(t2 T2, t3 T3) R {
-      return f(t1, t2, t3)
-    }
-  }
+	return func(t1 T1) func(T2, T3) R {
+		return func(t2 T2, t3 T3) R {
+			return f(t1, t2, t3)
+		}
+	}
 }

 // Ignore1of3 takes a function with 2 parameters and returns a new function with 3 parameters that will ignore the values at positions [1] and pass the remaining 2 parameters to the original function
 func Ignore1of3[T1 any, F ~func(T2, T3) R, T2, T3, R any](f F) func(T1, T2, T3) R {
-  return func(t1 T1, t2 T2, t3 T3) R {
-      return f(t2, t3)
-  }
+	return func(t1 T1, t2 T2, t3 T3) R {
+		return f(t2, t3)
+	}
 }

 // Bind2of3 takes a function with 3 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [2] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [1, 3] of the original function.
 func Bind2of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T2) func(T1, T3) R {
-  return func(t2 T2) func(T1, T3) R {
-    return func(t1 T1, t3 T3) R {
-      return f(t1, t2, t3)
-    }
-  }
+	return func(t2 T2) func(T1, T3) R {
+		return func(t1 T1, t3 T3) R {
+			return f(t1, t2, t3)
+		}
+	}
 }

 // Ignore2of3 takes a function with 2 parameters and returns a new function with 3 parameters that will ignore the values at positions [2] and pass the remaining 2 parameters to the original function
 func Ignore2of3[T2 any, F ~func(T1, T3) R, T1, T3, R any](f F) func(T1, T2, T3) R {
-  return func(t1 T1, t2 T2, t3 T3) R {
-      return f(t1, t3)
-  }
+	return func(t1 T1, t2 T2, t3 T3) R {
+		return f(t1, t3)
+	}
 }

 // Bind3of3 takes a function with 3 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [3] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [1, 2] of the original function.
 func Bind3of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T3) func(T1, T2) R {
-  return func(t3 T3) func(T1, T2) R {
-    return func(t1 T1, t2 T2) R {
-      return f(t1, t2, t3)
-    }
-  }
+	return func(t3 T3) func(T1, T2) R {
+		return func(t1 T1, t2 T2) R {
+			return f(t1, t2, t3)
+		}
+	}
 }

 // Ignore3of3 takes a function with 2 parameters and returns a new function with 3 parameters that will ignore the values at positions [3] and pass the remaining 2 parameters to the original function
 func Ignore3of3[T3 any, F ~func(T1, T2) R, T1, T2, R any](f F) func(T1, T2, T3) R {
-  return func(t1 T1, t2 T2, t3 T3) R {
-      return f(t1, t2)
-  }
+	return func(t1 T1, t2 T2, t3 T3) R {
+		return f(t1, t2)
+	}
 }

 // Bind12of3 takes a function with 3 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 2] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [3] of the original function.
 func Bind12of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T1, T2) func(T3) R {
-  return func(t1 T1, t2 T2) func(T3) R {
-    return func(t3 T3) R {
-      return f(t1, t2, t3)
-    }
-  }
+	return func(t1 T1, t2 T2) func(T3) R {
+		return func(t3 T3) R {
+			return f(t1, t2, t3)
+		}
+	}
 }

 // Ignore12of3 takes a function with 1 parameters and returns a new function with 3 parameters that will ignore the values at positions [1, 2] and pass the remaining 1 parameters to the original function
 func Ignore12of3[T1, T2 any, F ~func(T3) R, T3, R any](f F) func(T1, T2, T3) R {
-  return func(t1 T1, t2 T2, t3 T3) R {
-      return f(t3)
-  }
+	return func(t1 T1, t2 T2, t3 T3) R {
+		return f(t3)
+	}
 }

 // Bind13of3 takes a function with 3 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 3] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [2] of the original function.
 func Bind13of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T1, T3) func(T2) R {
-  return func(t1 T1, t3 T3) func(T2) R {
-    return func(t2 T2) R {
-      return f(t1, t2, t3)
-    }
-  }
+	return func(t1 T1, t3 T3) func(T2) R {
+		return func(t2 T2) R {
+			return f(t1, t2, t3)
+		}
+	}
 }

 // Ignore13of3 takes a function with 1 parameters and returns a new function with 3 parameters that will ignore the values at positions [1, 3] and pass the remaining 1 parameters to the original function
 func Ignore13of3[T1, T3 any, F ~func(T2) R, T2, R any](f F) func(T1, T2, T3) R {
-  return func(t1 T1, t2 T2, t3 T3) R {
-      return f(t2)
-  }
+	return func(t1 T1, t2 T2, t3 T3) R {
+		return f(t2)
+	}
 }

 // Bind23of3 takes a function with 3 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [2, 3] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [1] of the original function.
 func Bind23of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T2, T3) func(T1) R {
-  return func(t2 T2, t3 T3) func(T1) R {
-    return func(t1 T1) R {
-      return f(t1, t2, t3)
-    }
-  }
+	return func(t2 T2, t3 T3) func(T1) R {
+		return func(t1 T1) R {
+			return f(t1, t2, t3)
+		}
+	}
 }

 // Ignore23of3 takes a function with 1 parameters and returns a new function with 3 parameters that will ignore the values at positions [2, 3] and pass the remaining 1 parameters to the original function
 func Ignore23of3[T2, T3 any, F ~func(T1) R, T1, R any](f F) func(T1, T2, T3) R {
-  return func(t1 T1, t2 T2, t3 T3) R {
-      return f(t1)
-  }
+	return func(t1 T1, t2 T2, t3 T3) R {
+		return f(t1)
+	}
 }

 // Bind123of3 takes a function with 3 parameters and returns a new function with 3 parameters that will bind these parameters to the positions [1, 2, 3] of the original function.
 // The return value of is a function with the remaining 0 parameters at positions [] of the original function.
 func Bind123of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T1, T2, T3) func() R {
-  return func(t1 T1, t2 T2, t3 T3) func() R {
-    return func() R {
-      return f(t1, t2, t3)
-    }
-  }
+	return func(t1 T1, t2 T2, t3 T3) func() R {
+		return func() R {
+			return f(t1, t2, t3)
+		}
+	}
 }

 // Ignore123of3 takes a function with 0 parameters and returns a new function with 3 parameters that will ignore the values at positions [1, 2, 3] and pass the remaining 0 parameters to the original function
 func Ignore123of3[T1, T2, T3 any, F ~func() R, R any](f F) func(T1, T2, T3) R {
-  return func(t1 T1, t2 T2, t3 T3) R {
-      return f()
-  }
+	return func(t1 T1, t2 T2, t3 T3) R {
+		return f()
+	}
 }
+
 // Combinations for a total of 4 arguments

 // Bind1of4 takes a function with 4 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
 // The return value of is a function with the remaining 3 parameters at positions [2, 3, 4] of the original function.
 func Bind1of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1) func(T2, T3, T4) R {
-  return func(t1 T1) func(T2, T3, T4) R {
-    return func(t2 T2, t3 T3, t4 T4) R {
-      return f(t1, t2, t3, t4)
-    }
-  }
+	return func(t1 T1) func(T2, T3, T4) R {
+		return func(t2 T2, t3 T3, t4 T4) R {
+			return f(t1, t2, t3, t4)
+		}
+	}
 }

 // Ignore1of4 takes a function with 3 parameters and returns a new function with 4 parameters that will ignore the values at positions [1] and pass the remaining 3 parameters to the original function
 func Ignore1of4[T1 any, F ~func(T2, T3, T4) R, T2, T3, T4, R any](f F) func(T1, T2, T3, T4) R {
-  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-      return f(t2, t3, t4)
-  }
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+		return f(t2, t3, t4)
+	}
 }

 // Bind2of4 takes a function with 4 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [2] of the original function.
 // The return value of is a function with the remaining 3 parameters at positions [1, 3, 4] of the original function.
 func Bind2of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T2) func(T1, T3, T4) R {
-  return func(t2 T2) func(T1, T3, T4) R {
-    return func(t1 T1, t3 T3, t4 T4) R {
-      return f(t1, t2, t3, t4)
-    }
-  }
+	return func(t2 T2) func(T1, T3, T4) R {
+		return func(t1 T1, t3 T3, t4 T4) R {
+			return f(t1, t2, t3, t4)
+		}
+	}
 }

 // Ignore2of4 takes a function with 3 parameters and returns a new function with 4 parameters that will ignore the values at positions [2] and pass the remaining 3 parameters to the original function
 func Ignore2of4[T2 any, F ~func(T1, T3, T4) R, T1, T3, T4, R any](f F) func(T1, T2, T3, T4) R {
-  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-      return f(t1, t3, t4)
-  }
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+		return f(t1, t3, t4)
+	}
 }

 // Bind3of4 takes a function with 4 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [3] of the original function.
 // The return value of is a function with the remaining 3 parameters at positions [1, 2, 4] of the original function.
 func Bind3of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T3) func(T1, T2, T4) R {
-  return func(t3 T3) func(T1, T2, T4) R {
-    return func(t1 T1, t2 T2, t4 T4) R {
-      return f(t1, t2, t3, t4)
-    }
-  }
+	return func(t3 T3) func(T1, T2, T4) R {
+		return func(t1 T1, t2 T2, t4 T4) R {
+			return f(t1, t2, t3, t4)
+		}
+	}
 }

 // Ignore3of4 takes a function with 3 parameters and returns a new function with 4 parameters that will ignore the values at positions [3] and pass the remaining 3 parameters to the original function
 func Ignore3of4[T3 any, F ~func(T1, T2, T4) R, T1, T2, T4, R any](f F) func(T1, T2, T3, T4) R {
-  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-      return f(t1, t2, t4)
-  }
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+		return f(t1, t2, t4)
+	}
 }

 // Bind4of4 takes a function with 4 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [4] of the original function.
 // The return value of is a function with the remaining 3 parameters at positions [1, 2, 3] of the original function.
 func Bind4of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T4) func(T1, T2, T3) R {
-  return func(t4 T4) func(T1, T2, T3) R {
-    return func(t1 T1, t2 T2, t3 T3) R {
-      return f(t1, t2, t3, t4)
-    }
-  }
+	return func(t4 T4) func(T1, T2, T3) R {
+		return func(t1 T1, t2 T2, t3 T3) R {
+			return f(t1, t2, t3, t4)
+		}
+	}
 }

 // Ignore4of4 takes a function with 3 parameters and returns a new function with 4 parameters that will ignore the values at positions [4] and pass the remaining 3 parameters to the original function
 func Ignore4of4[T4 any, F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T1, T2, T3, T4) R {
-  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-      return f(t1, t2, t3)
-  }
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+		return f(t1, t2, t3)
+	}
 }

 // Bind12of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 2] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [3, 4] of the original function.
 func Bind12of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T2) func(T3, T4) R {
-  return func(t1 T1, t2 T2) func(T3, T4) R {
-    return func(t3 T3, t4 T4) R {
-      return f(t1, t2, t3, t4)
-    }
-  }
+	return func(t1 T1, t2 T2) func(T3, T4) R {
+		return func(t3 T3, t4 T4) R {
+			return f(t1, t2, t3, t4)
+		}
+	}
 }

 // Ignore12of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 2] and pass the remaining 2 parameters to the original function
 func Ignore12of4[T1, T2 any, F ~func(T3, T4) R, T3, T4, R any](f F) func(T1, T2, T3, T4) R {
-  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-      return f(t3, t4)
-  }
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+		return f(t3, t4)
+	}
 }

 // Bind13of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 3] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [2, 4] of the original function.
 func Bind13of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T3) func(T2, T4) R {
-  return func(t1 T1, t3 T3) func(T2, T4) R {
-    return func(t2 T2, t4 T4) R {
-      return f(t1, t2, t3, t4)
-    }
-  }
+	return func(t1 T1, t3 T3) func(T2, T4) R {
+		return func(t2 T2, t4 T4) R {
+			return f(t1, t2, t3, t4)
+		}
+	}
 }

 // Ignore13of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 3] and pass the remaining 2 parameters to the original function
 func Ignore13of4[T1, T3 any, F ~func(T2, T4) R, T2, T4, R any](f F) func(T1, T2, T3, T4) R {
-  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-      return f(t2, t4)
-  }
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+		return f(t2, t4)
+	}
 }

 // Bind14of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 4] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [2, 3] of the original function.
 func Bind14of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T4) func(T2, T3) R {
-  return func(t1 T1, t4 T4) func(T2, T3) R {
-    return func(t2 T2, t3 T3) R {
-      return f(t1, t2, t3, t4)
-    }
-  }
+	return func(t1 T1, t4 T4) func(T2, T3) R {
+		return func(t2 T2, t3 T3) R {
+			return f(t1, t2, t3, t4)
+		}
+	}
 }

 // Ignore14of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 4] and pass the remaining 2 parameters to the original function
 func Ignore14of4[T1, T4 any, F ~func(T2, T3) R, T2, T3, R any](f F) func(T1, T2, T3, T4) R {
-  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-      return f(t2, t3)
-  }
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+		return f(t2, t3)
+	}
 }

 // Bind23of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [2, 3] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [1, 4] of the original function.
 func Bind23of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T2, T3) func(T1, T4) R {
-  return func(t2 T2, t3 T3) func(T1, T4) R {
-    return func(t1 T1, t4 T4) R {
-      return f(t1, t2, t3, t4)
-    }
-  }
+	return func(t2 T2, t3 T3) func(T1, T4) R {
+		return func(t1 T1, t4 T4) R {
+			return f(t1, t2, t3, t4)
+		}
+	}
 }

 // Ignore23of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [2, 3] and pass the remaining 2 parameters to the original function
 func Ignore23of4[T2, T3 any, F ~func(T1, T4) R, T1, T4, R any](f F) func(T1, T2, T3, T4) R {
-  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-      return f(t1, t4)
-  }
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+		return f(t1, t4)
+	}
 }

 // Bind24of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [2, 4] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [1, 3] of the original function.
 func Bind24of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T2, T4) func(T1, T3) R {
-  return func(t2 T2, t4 T4) func(T1, T3) R {
-    return func(t1 T1, t3 T3) R {
-      return f(t1, t2, t3, t4)
-    }
-  }
+	return func(t2 T2, t4 T4) func(T1, T3) R {
+		return func(t1 T1, t3 T3) R {
+			return f(t1, t2, t3, t4)
+		}
+	}
 }

 // Ignore24of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [2, 4] and pass the remaining 2 parameters to the original function
 func Ignore24of4[T2, T4 any, F ~func(T1, T3) R, T1, T3, R any](f F) func(T1, T2, T3, T4) R {
-  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-      return f(t1, t3)
-  }
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+		return f(t1, t3)
+	}
 }

 // Bind34of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [3, 4] of the original function.
 // The return value of is a function with the remaining 2 parameters at positions [1, 2] of the original function.
 func Bind34of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T3, T4) func(T1, T2) R {
-  return func(t3 T3, t4 T4) func(T1, T2) R {
-    return func(t1 T1, t2 T2) R {
-      return f(t1, t2, t3, t4)
-    }
-  }
+	return func(t3 T3, t4 T4) func(T1, T2) R {
+		return func(t1 T1, t2 T2) R {
+			return f(t1, t2, t3, t4)
+		}
+	}
 }

 // Ignore34of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [3, 4] and pass the remaining 2 parameters to the original function
 func Ignore34of4[T3, T4 any, F ~func(T1, T2) R, T1, T2, R any](f F) func(T1, T2, T3, T4) R {
-  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-      return f(t1, t2)
-  }
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+		return f(t1, t2)
+	}
 }

 // Bind123of4 takes a function with 4 parameters and returns a new function with 3 parameters that will bind these parameters to the positions [1, 2, 3] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [4] of the original function.
 func Bind123of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T2, T3) func(T4) R {
-  return func(t1 T1, t2 T2, t3 T3) func(T4) R {
-    return func(t4 T4) R {
-      return f(t1, t2, t3, t4)
-    }
-  }
+	return func(t1 T1, t2 T2, t3 T3) func(T4) R {
+		return func(t4 T4) R {
+			return f(t1, t2, t3, t4)
+		}
+	}
 }

 // Ignore123of4 takes a function with 1 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 2, 3] and pass the remaining 1 parameters to the original function
 func Ignore123of4[T1, T2, T3 any, F ~func(T4) R, T4, R any](f F) func(T1, T2, T3, T4) R {
-  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-      return f(t4)
-  }
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+		return f(t4)
+	}
 }

 // Bind124of4 takes a function with 4 parameters and returns a new function with 3 parameters that will bind these parameters to the positions [1, 2, 4] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [3] of the original function.
 func Bind124of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T2, T4) func(T3) R {
-  return func(t1 T1, t2 T2, t4 T4) func(T3) R {
-    return func(t3 T3) R {
-      return f(t1, t2, t3, t4)
-    }
-  }
+	return func(t1 T1, t2 T2, t4 T4) func(T3) R {
+		return func(t3 T3) R {
+			return f(t1, t2, t3, t4)
+		}
+	}
 }

 // Ignore124of4 takes a function with 1 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 2, 4] and pass the remaining 1 parameters to the original function
 func Ignore124of4[T1, T2, T4 any, F ~func(T3) R, T3, R any](f F) func(T1, T2, T3, T4) R {
-  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-      return f(t3)
-  }
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+		return f(t3)
+	}
 }

 // Bind134of4 takes a function with 4 parameters and returns a new function with 3 parameters that will bind these parameters to the positions [1, 3, 4] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [2] of the original function.
 func Bind134of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T3, T4) func(T2) R {
-  return func(t1 T1, t3 T3, t4 T4) func(T2) R {
-    return func(t2 T2) R {
-      return f(t1, t2, t3, t4)
-    }
-  }
+	return func(t1 T1, t3 T3, t4 T4) func(T2) R {
+		return func(t2 T2) R {
+			return f(t1, t2, t3, t4)
+		}
+	}
 }

 // Ignore134of4 takes a function with 1 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 3, 4] and pass the remaining 1 parameters to the original function
 func Ignore134of4[T1, T3, T4 any, F ~func(T2) R, T2, R any](f F) func(T1, T2, T3, T4) R {
-  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-      return f(t2)
-  }
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+		return f(t2)
+	}
 }

 // Bind234of4 takes a function with 4 parameters and returns a new function with 3 parameters that will bind these parameters to the positions [2, 3, 4] of the original function.
 // The return value of is a function with the remaining 1 parameters at positions [1] of the original function.
 func Bind234of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T2, T3, T4) func(T1) R {
-  return func(t2 T2, t3 T3, t4 T4) func(T1) R {
-    return func(t1 T1) R {
-      return f(t1, t2, t3, t4)
-    }
-  }
+	return func(t2 T2, t3 T3, t4 T4) func(T1) R {
+		return func(t1 T1) R {
+			return f(t1, t2, t3, t4)
+		}
+	}
 }

 // Ignore234of4 takes a function with 1 parameters and returns a new function with 4 parameters that will ignore the values at positions [2, 3, 4] and pass the remaining 1 parameters to the original function
 func Ignore234of4[T2, T3, T4 any, F ~func(T1) R, T1, R any](f F) func(T1, T2, T3, T4) R {
-  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-      return f(t1)
-  }
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+		return f(t1)
+	}
 }

 // Bind1234of4 takes a function with 4 parameters and returns a new function with 4 parameters that will bind these parameters to the positions [1, 2, 3, 4] of the original function.
 // The return value of is a function with the remaining 0 parameters at positions [] of the original function.
 func Bind1234of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T2, T3, T4) func() R {
-  return func(t1 T1, t2 T2, t3 T3, t4 T4) func() R {
-    return func() R {
-      return f(t1, t2, t3, t4)
-    }
-  }
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) func() R {
+		return func() R {
+			return f(t1, t2, t3, t4)
+		}
+	}
 }

 // Ignore1234of4 takes a function with 0 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 2, 3, 4] and pass the remaining 0 parameters to the original function
 func Ignore1234of4[T1, T2, T3, T4 any, F ~func() R, R any](f F) func(T1, T2, T3, T4) R {
-  return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
-      return f()
-  }
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
+		return f()
+	}
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Dr. Carsten Leue	cb2875bf1e	doc: add sample for http Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2023-07-20 11:48:01 +02:00
Carsten Leue	78a84374dd	Merge pull request #6 from IBM/cleue-fix-ap fix: implementation of traversal for ReaderIOEither	2023-07-19 17:06:20 +02:00
Dr. Carsten Leue	b87cfcf941	fix: implementation of traversal for ReaderIOEither Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2023-07-19 17:05:50 +02:00
Carsten Leue	19bdaad7ae	Merge pull request #5 from IBM/cleue-check-ap fix: doc and parameter order	2023-07-19 16:21:05 +02:00
Dr. Carsten Leue	79834541bf	fix: doc and parameter order Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2023-07-19 16:20:28 +02:00
Carsten Leue	34bf3635b9	Merge pull request #4 from IBM/cleue-getting-started-docs doc: some docs	2023-07-18 16:52:49 +02:00
Dr. Carsten Leue	b7280ca862	fix: some docs Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2023-07-18 16:27:05 +02:00
Oliver Rau	058026302b	build: Make sure semantic release is installed Signed-off-by: Oliver Rau <oliver.rau@de.ibm.com>	2023-07-18 16:10:05 +02:00
Oliver Rau	302a57820b	build: Fix build.yml location Signed-off-by: Oliver Rau <oliver.rau@de.ibm.com>	2023-07-18 16:06:29 +02:00
Carsten Leue	694a507fdd	Merge pull request #2 from IBM/olira/feat/build build: Add build scripts	2023-07-18 16:03:07 +02:00
Carsten Leue	980bbf40c5	Merge pull request #3 from IBM/cleue-add-doc Cleue add doc	2023-07-18 15:58:24 +02:00
Dr. Carsten Leue	b25de3c7c3	doc: fix case Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2023-07-18 15:57:54 +02:00
Oliver Rau	7d9dedb80f	build: Add build scripts Signed-off-by: Oliver Rau <oliver.rau@de.ibm.com>	2023-07-18 15:57:29 +02:00
Dr. Carsten Leue	308fe48718	doc: try package doc Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>	2023-07-18 15:45:02 +02:00
Carsten Leue	aa0f043b95	Merge pull request #1 from IBM/cleue-initial-checkin Cleue initial checkin	2023-07-18 15:25:39 +02:00