fix: add DI

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

.github/workflows/build.yml

@@ -33,7 +33,7 @@ jobs:
         with:
           fetch-depth: 0
       - name: Set up go ${{ matrix.go-version }}
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v4
         with:
           go-version: ${{ matrix.go-version }}
       -
@@ -60,12 +60,12 @@ jobs:
           fetch-depth: 0
 
       - name: Set up Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@b39b52d1213e96004bfcb1c61a8a6fa8ab84f3e8 # v4.0.1
+        uses: actions/setup-node@8f152de45cc393bb48ce5d89d36b731f54556e65 # v4.0.0
         with:
           node-version: ${{ env.NODE_VERSION }}
 
       - name: Set up go ${{env.GO_VERSION}}
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v4
         with:
           go-version: ${{env.GO_VERSION}}
 

array/array.go

@@ -308,16 +308,10 @@ func SliceRight[A any](start int) func([]A) []A {
 	return G.SliceRight[[]A](start)
 }
 
-// Copy creates a shallow copy of the array
 func Copy[A any](b []A) []A {
 	return G.Copy(b)
 }
 
-// Clone creates a deep copy of the array using the provided endomorphism to clone the values
-func Clone[A any](f func(A) A) func(as []A) []A {
-	return G.Clone[[]A](f)
-}
-
 // FoldMap maps and folds an array. Map the Array passing each value to the iterating function. Then fold the results using the provided Monoid.
 func FoldMap[A, B any](m M.Monoid[B]) func(func(A) B) func([]A) B {
 	return G.FoldMap[[]A](m)

array/generic/array.go

@@ -304,11 +304,6 @@ func Copy[AS ~[]A, A any](b AS) AS {
 	return buf
 }
 
-func Clone[AS ~[]A, A any](f func(A) A) func(as AS) AS {
-	// implementation assumes that map does not optimize for the empty array
-	return Map[AS, AS](f)
-}
-
 func FoldMap[AS ~[]A, A, B any](m M.Monoid[B]) func(func(A) B) func(AS) B {
 	return func(f func(A) B) func(AS) B {
 		return func(as AS) B {

array/generic/uniq.go

@@ -1,32 +0,0 @@
-package generic
-
-import F "github.com/IBM/fp-go/function"
-
-// StrictUniq converts an array of arbitrary items into an array or unique items
-// where uniqueness is determined by the built-in uniqueness constraint
-func StrictUniq[AS ~[]A, A comparable](as AS) AS {
-	return Uniq[AS](F.Identity[A])(as)
-}
-
-// uniquePredUnsafe returns a predicate on a map for uniqueness
-func uniquePredUnsafe[PRED ~func(A) K, A any, K comparable](f PRED) func(int, A) bool {
-	lookup := make(map[K]bool)
-	return func(_ int, a A) bool {
-		k := f(a)
-		_, has := lookup[k]
-		if has {
-			return false
-		}
-		lookup[k] = true
-		return true
-	}
-}
-
-// Uniq converts an array of arbitrary items into an array or unique items
-// where uniqueness is determined based on a key extractor function
-func Uniq[AS ~[]A, PRED ~func(A) K, A any, K comparable](f PRED) func(as AS) AS {
-	return func(as AS) AS {
-		// we need to create a new predicate for each iteration
-		return filterWithIndex(as, uniquePredUnsafe(f))
-	}
-}

array/uniq.go

@@ -1,17 +0,0 @@
-package array
-
-import (
-	G "github.com/IBM/fp-go/array/generic"
-)
-
-// StrictUniq converts an array of arbitrary items into an array or unique items
-// where uniqueness is determined by the built-in uniqueness constraint
-func StrictUniq[A comparable](as []A) []A {
-	return G.StrictUniq[[]A](as)
-}
-
-// Uniq converts an array of arbitrary items into an array or unique items
-// where uniqueness is determined based on a key extractor function
-func Uniq[A any, K comparable](f func(A) K) func(as []A) []A {
-	return G.Uniq[[]A](f)
-}

array/uniq_test.go

@@ -1,14 +0,0 @@
-package array
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestUniq(t *testing.T) {
-	data := From(1, 2, 3, 2, 4, 1)
-
-	uniq := StrictUniq(data)
-	assert.Equal(t, From(1, 2, 3, 4), uniq)
-}

cli/commands.go

@@ -34,6 +34,5 @@ func Commands() []*C.Command {
 		IOEitherCommand(),
 		IOCommand(),
 		IOOptionCommand(),
-		DICommand(),
 	}
 }

cli/di.go

@@ -1,231 +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 cli
-
-import (
-	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"time"
-
-	C "github.com/urfave/cli/v2"
-)
-
-func generateMakeProvider(f *os.File, i int) {
-	// non generic version
-	fmt.Fprintf(f, "\n// MakeProvider%d creates a [DIE.Provider] for an [InjectionToken] from a function with %d dependencies\n", i, i)
-	fmt.Fprintf(f, "func MakeProvider%d[", i)
-	for j := 0; j < i; j++ {
-		if j > 0 {
-			fmt.Fprintf(f, ", ")
-		}
-		fmt.Fprintf(f, "T%d", j+1)
-	}
-	fmt.Fprintf(f, " any, R any](\n")
-	fmt.Fprintf(f, "  token InjectionToken[R],\n")
-	for j := 0; j < i; j++ {
-		fmt.Fprintf(f, "  d%d Dependency[T%d],\n", j+1, j+1)
-	}
-	fmt.Fprintf(f, "  f func(")
-	for j := 0; j < i; j++ {
-		if j > 0 {
-			fmt.Fprintf(f, ", ")
-		}
-		fmt.Fprintf(f, "T%d", j+1)
-	}
-	fmt.Fprintf(f, ") IOE.IOEither[error, R],\n")
-	fmt.Fprintf(f, ") DIE.Provider {\n")
-	fmt.Fprint(f, "  return DIE.MakeProvider(\n")
-	fmt.Fprint(f, "    token,\n")
-	fmt.Fprintf(f, "    MakeProviderFactory%d(\n", i)
-	for j := 0; j < i; j++ {
-		fmt.Fprintf(f, "      d%d,\n", j+1)
-	}
-	fmt.Fprint(f, "      f,\n")
-	fmt.Fprint(f, "  ))\n")
-	fmt.Fprintf(f, "}\n")
-}
-
-func generateMakeTokenWithDefault(f *os.File, i int) {
-	// non generic version
-	fmt.Fprintf(f, "\n// MakeTokenWithDefault%d creates an [InjectionToken] with a default implementation with %d dependencies\n", i, i)
-	fmt.Fprintf(f, "func MakeTokenWithDefault%d[", i)
-	for j := 0; j < i; j++ {
-		if j > 0 {
-			fmt.Fprintf(f, ", ")
-		}
-		fmt.Fprintf(f, "T%d", j+1)
-	}
-	fmt.Fprintf(f, " any, R any](\n")
-	fmt.Fprintf(f, "  name string,\n")
-	for j := 0; j < i; j++ {
-		fmt.Fprintf(f, "  d%d Dependency[T%d],\n", j+1, j+1)
-	}
-	fmt.Fprintf(f, "  f func(")
-	for j := 0; j < i; j++ {
-		if j > 0 {
-			fmt.Fprintf(f, ", ")
-		}
-		fmt.Fprintf(f, "T%d", j+1)
-	}
-	fmt.Fprintf(f, ") IOE.IOEither[error, R],\n")
-	fmt.Fprintf(f, ") InjectionToken[R] {\n")
-	fmt.Fprintf(f, "  return MakeTokenWithDefault[R](name, MakeProviderFactory%d(\n", i)
-	for j := 0; j < i; j++ {
-		fmt.Fprintf(f, "    d%d,\n", j+1)
-	}
-	fmt.Fprint(f, "    f,\n")
-	fmt.Fprint(f, "  ))\n")
-	fmt.Fprintf(f, "}\n")
-}
-
-func generateMakeProviderFactory(f *os.File, i int) {
-	// non generic version
-	fmt.Fprintf(f, "\n// MakeProviderFactory%d creates a [DIE.ProviderFactory] from a function with %d arguments and %d dependencies\n", i, i, i)
-	fmt.Fprintf(f, "func MakeProviderFactory%d[", i)
-	for j := 0; j < i; j++ {
-		if j > 0 {
-			fmt.Fprintf(f, ", ")
-		}
-		fmt.Fprintf(f, "T%d", j+1)
-	}
-	fmt.Fprintf(f, " any, R any](\n")
-	for j := 0; j < i; j++ {
-		fmt.Fprintf(f, "  d%d Dependency[T%d],\n", j+1, j+1)
-	}
-	fmt.Fprintf(f, "  f func(")
-	for j := 0; j < i; j++ {
-		if j > 0 {
-			fmt.Fprintf(f, ", ")
-		}
-		fmt.Fprintf(f, "T%d", j+1)
-	}
-	fmt.Fprintf(f, ") IOE.IOEither[error, R],\n")
-	fmt.Fprintf(f, ") DIE.ProviderFactory {\n")
-	fmt.Fprint(f, "  return DIE.MakeProviderFactory(\n")
-	fmt.Fprint(f, "    A.From[DIE.Dependency](\n")
-	for j := 0; j < i; j++ {
-		fmt.Fprintf(f, "      d%d,\n", j+1)
-	}
-	fmt.Fprint(f, "    ),\n")
-	fmt.Fprintf(f, "    eraseProviderFactory%d(\n", i)
-	for j := 0; j < i; j++ {
-		fmt.Fprintf(f, "      d%d,\n", j+1)
-	}
-	fmt.Fprint(f, "      f,\n")
-	fmt.Fprint(f, "    ),\n")
-	fmt.Fprint(f, "  )\n")
-	fmt.Fprintf(f, "}\n")
-}
-
-func generateEraseProviderFactory(f *os.File, i int) {
-	// non generic version
-	fmt.Fprintf(f, "\n// eraseProviderFactory%d creates a function that takes a variadic number of untyped arguments and from a function of %d strongly typed arguments and %d dependencies\n", i, i, i)
-	fmt.Fprintf(f, "func eraseProviderFactory%d[", i)
-	for j := 0; j < i; j++ {
-		if j > 0 {
-			fmt.Fprintf(f, ", ")
-		}
-		fmt.Fprintf(f, "T%d", j+1)
-	}
-	fmt.Fprintf(f, " any, R any](\n")
-	for j := 0; j < i; j++ {
-		fmt.Fprintf(f, "  d%d Dependency[T%d],\n", j+1, j+1)
-	}
-	fmt.Fprintf(f, "  f func(")
-	for j := 0; j < i; j++ {
-		if j > 0 {
-			fmt.Fprintf(f, ", ")
-		}
-		fmt.Fprintf(f, "T%d", j+1)
-	}
-	fmt.Fprintf(f, ") IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {\n")
-	fmt.Fprintf(f, "  ft := eraseTuple(T.Tupled%d(f))\n", i)
-	for j := 0; j < i; j++ {
-		fmt.Fprintf(f, "  t%d := lookupAt[T%d](%d, d%d)\n", j+1, j+1, j, j+1)
-	}
-	fmt.Fprint(f, "  return func(params ...any) IOE.IOEither[error, any] {\n")
-	fmt.Fprintf(f, "    return ft(E.SequenceT%d(\n", i)
-	for j := 0; j < i; j++ {
-		fmt.Fprintf(f, "      t%d(params),\n", j+1)
-	}
-	fmt.Fprint(f, "    ))\n")
-	fmt.Fprint(f, "  }\n")
-	fmt.Fprintf(f, "}\n")
-}
-
-func generateDIHelpers(filename string, count int) error {
-	dir, err := os.Getwd()
-	if err != nil {
-		return err
-	}
-	absDir, err := filepath.Abs(dir)
-	if err != nil {
-		return err
-	}
-	pkg := filepath.Base(absDir)
-	f, err := os.Create(filepath.Clean(filename))
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-	// 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\n", time.Now())
-
-	fmt.Fprintf(f, "package %s\n\n", pkg)
-
-	fmt.Fprint(f, `
-import (
-	E "github.com/IBM/fp-go/either"
-	IOE "github.com/IBM/fp-go/ioeither"
-	T "github.com/IBM/fp-go/tuple"
-	A "github.com/IBM/fp-go/array"
-	DIE "github.com/IBM/fp-go/di/erasure"
-)
-`)
-
-	for i := 1; i <= count; i++ {
-		generateEraseProviderFactory(f, i)
-		generateMakeProviderFactory(f, i)
-		generateMakeTokenWithDefault(f, i)
-		generateMakeProvider(f, i)
-	}
-
-	return nil
-}
-
-func DICommand() *C.Command {
-	return &C.Command{
-		Name:  "di",
-		Usage: "generate code for the dependency injection package",
-		Flags: []C.Flag{
-			flagCount,
-			flagFilename,
-		},
-		Action: func(ctx *C.Context) error {
-			return generateDIHelpers(
-				ctx.String(keyFilename),
-				ctx.Int(keyCount),
-			)
-		},
-	}
-}

cli/pipe.go

@@ -295,16 +295,15 @@ func recurseCurry(f *os.File, indent string, total, count int) {
 func generateCurry(f *os.File, i int) {
 	// Create the curry version
 	fmt.Fprintf(f, "\n// Curry%d takes a function with %d parameters and returns a cascade of functions each taking only one parameter.\n// The inverse function is [Uncurry%d]\n", i, i, i)
-	fmt.Fprintf(f, "func Curry%d[FCT ~func(T0", i)
-	for j := 1; j < i; j++ {
+	fmt.Fprintf(f, "func Curry%d[T0", i)
+	for j := 1; j <= i; j++ {
 		fmt.Fprintf(f, ", T%d", j)
 	}
-	fmt.Fprintf(f, ") T%d", i)
-	// type arguments
-	for j := 0; j <= i; j++ {
-		fmt.Fprintf(f, ", T%d", j)
+	fmt.Fprintf(f, " any](f func(T0")
+	for j := 2; j <= i; j++ {
+		fmt.Fprintf(f, ", T%d", j-1)
 	}
-	fmt.Fprintf(f, " any](f FCT) func(T0)")
+	fmt.Fprintf(f, ") T%d) func(T0)", i)
 	for j := 2; j <= i; j++ {
 		fmt.Fprintf(f, " func(T%d)", j-1)
 	}
@@ -316,16 +315,15 @@ func generateCurry(f *os.File, i int) {
 func generateUncurry(f *os.File, i int) {
 	// Create the uncurry version
 	fmt.Fprintf(f, "\n// Uncurry%d takes a cascade of %d functions each taking only one parameter and returns a function with %d parameters .\n// The inverse function is [Curry%d]\n", i, i, i, i)
-	fmt.Fprintf(f, "func Uncurry%d[FCT ~func(T0)", i)
-	for j := 1; j < i; j++ {
-		fmt.Fprintf(f, " func(T%d)", j)
-	}
-	fmt.Fprintf(f, " T%d", i)
-	// the type parameters
-	for j := 0; j <= i; j++ {
+	fmt.Fprintf(f, "func Uncurry%d[T0", i)
+	for j := 1; j <= i; j++ {
 		fmt.Fprintf(f, ", T%d", j)
 	}
-	fmt.Fprintf(f, " any](f FCT) func(")
+	fmt.Fprintf(f, " any](f")
+	for j := 1; j <= i; j++ {
+		fmt.Fprintf(f, " func(T%d)", j-1)
+	}
+	fmt.Fprintf(f, " T%d) func(", i)
 	for j := 1; j <= i; j++ {
 		if j > 1 {
 			fmt.Fprintf(f, ", ")

context/readerioeither/generic/traverse.go

@@ -166,289 +166,3 @@ func SequenceRecord[K comparable,
 
 	return MonadTraverseRecord[K, GAS, GRAS](ma, F.Identity[GRA])
 }
-
-// MonadTraverseArraySeq transforms an array
-func MonadTraverseArraySeq[
-	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],
-		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		as, f,
-	)
-}
-
-// TraverseArraySeq transforms an array
-func TraverseArraySeq[
-	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](f func(A) GRB) func(AS) GRBS {
-
-	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],
-		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		f,
-	)
-}
-
-// TraverseArrayWithIndexSeq transforms an array
-func TraverseArrayWithIndexSeq[
-	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](f func(int, A) GRB) func(AS) GRBS {
-
-	return RA.TraverseWithIndex[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],
-		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		f,
-	)
-}
-
-// SequenceArraySeq converts a homogeneous sequence of either into an either of sequence
-func SequenceArraySeq[
-	AS ~[]A,
-	GAS ~[]GRA,
-	GRAS ~func(context.Context) GIOAS,
-	GRA ~func(context.Context) GIOA,
-	GIOAS ~func() E.Either[error, AS],
-	GIOA ~func() E.Either[error, A],
-	A any](ma GAS) GRAS {
-
-	return MonadTraverseArraySeq[GAS, GRAS](ma, F.Identity[GRA])
-}
-
-// MonadTraverseRecordSeq transforms a record
-func MonadTraverseRecordSeq[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],
-		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		ma, f,
-	)
-}
-
-// TraverseRecordSeq transforms a record
-func TraverseRecordSeq[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](f func(A) GRB) func(AS) GRBS {
-
-	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],
-		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		f,
-	)
-}
-
-// TraverseRecordWithIndexSeq transforms a record
-func TraverseRecordWithIndexSeq[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](f func(K, A) GRB) func(AS) GRBS {
-
-	return RR.TraverseWithIndex[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],
-		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		f,
-	)
-}
-
-// SequenceRecordSeq converts a homogeneous sequence of either into an either of sequence
-func SequenceRecordSeq[K comparable,
-	AS ~map[K]A,
-	GAS ~map[K]GRA,
-	GRAS ~func(context.Context) GIOAS,
-	GRA ~func(context.Context) GIOA,
-	GIOAS ~func() E.Either[error, AS],
-	GIOA ~func() E.Either[error, A],
-	A any](ma GAS) GRAS {
-
-	return MonadTraverseRecordSeq[K, GAS, GRAS](ma, F.Identity[GRA])
-}
-
-// MonadTraverseArrayPar transforms an array
-func MonadTraverseArrayPar[
-	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],
-		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		as, f,
-	)
-}
-
-// TraverseArrayPar transforms an array
-func TraverseArrayPar[
-	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](f func(A) GRB) func(AS) GRBS {
-
-	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],
-		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		f,
-	)
-}
-
-// TraverseArrayWithIndexPar transforms an array
-func TraverseArrayWithIndexPar[
-	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](f func(int, A) GRB) func(AS) GRBS {
-
-	return RA.TraverseWithIndex[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],
-		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		f,
-	)
-}
-
-// SequenceArrayPar converts a homogeneous sequence of either into an either of sequence
-func SequenceArrayPar[
-	AS ~[]A,
-	GAS ~[]GRA,
-	GRAS ~func(context.Context) GIOAS,
-	GRA ~func(context.Context) GIOA,
-	GIOAS ~func() E.Either[error, AS],
-	GIOA ~func() E.Either[error, A],
-	A any](ma GAS) GRAS {
-
-	return MonadTraverseArrayPar[GAS, GRAS](ma, F.Identity[GRA])
-}
-
-// MonadTraverseRecordPar transforms a record
-func MonadTraverseRecordPar[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],
-		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		ma, f,
-	)
-}
-
-// TraverseRecordPar transforms a record
-func TraverseRecordPar[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](f func(A) GRB) func(AS) GRBS {
-
-	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],
-		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		f,
-	)
-}
-
-// TraverseRecordWithIndexPar transforms a record
-func TraverseRecordWithIndexPar[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](f func(K, A) GRB) func(AS) GRBS {
-
-	return RR.TraverseWithIndex[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],
-		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		f,
-	)
-}
-
-// SequenceRecordPar converts a homogeneous sequence of either into an either of sequence
-func SequenceRecordPar[K comparable,
-	AS ~map[K]A,
-	GAS ~map[K]GRA,
-	GRAS ~func(context.Context) GIOAS,
-	GRA ~func(context.Context) GIOA,
-	GIOAS ~func() E.Either[error, AS],
-	GIOA ~func() E.Either[error, A],
-	A any](ma GAS) GRAS {
-
-	return MonadTraverseRecordPar[K, GAS, GRAS](ma, F.Identity[GRA])
-}

context/readerioeither/traverse.go

@@ -48,63 +48,3 @@ func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) ReaderIOEither
 func SequenceRecord[K comparable, A any](ma map[K]ReaderIOEither[A]) ReaderIOEither[map[K]A] {
 	return G.SequenceRecord[K, map[K]A, map[K]ReaderIOEither[A], ReaderIOEither[map[K]A]](ma)
 }
-
-// TraverseArraySeq uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
-func TraverseArraySeq[A, B any](f func(A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] {
-	return G.TraverseArraySeq[[]A, ReaderIOEither[[]B]](f)
-}
-
-// TraverseArrayWithIndexSeq uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
-func TraverseArrayWithIndexSeq[A, B any](f func(int, A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] {
-	return G.TraverseArrayWithIndexSeq[[]A, ReaderIOEither[[]B]](f)
-}
-
-// SequenceArraySeq converts a homogeneous sequence of either into an either of sequence
-func SequenceArraySeq[A any](ma []ReaderIOEither[A]) ReaderIOEither[[]A] {
-	return G.SequenceArraySeq[[]A, []ReaderIOEither[A], ReaderIOEither[[]A]](ma)
-}
-
-// TraverseRecordSeq uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
-func TraverseRecordSeq[K comparable, A, B any](f func(A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] {
-	return G.TraverseRecordSeq[K, map[K]A, ReaderIOEither[map[K]B]](f)
-}
-
-// TraverseRecordWithIndexSeq uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
-func TraverseRecordWithIndexSeq[K comparable, A, B any](f func(K, A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] {
-	return G.TraverseRecordWithIndexSeq[K, map[K]A, ReaderIOEither[map[K]B]](f)
-}
-
-// SequenceRecordSeq converts a homogeneous sequence of either into an either of sequence
-func SequenceRecordSeq[K comparable, A any](ma map[K]ReaderIOEither[A]) ReaderIOEither[map[K]A] {
-	return G.SequenceRecordSeq[K, map[K]A, map[K]ReaderIOEither[A], ReaderIOEither[map[K]A]](ma)
-}
-
-// TraverseArrayPar uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
-func TraverseArrayPar[A, B any](f func(A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] {
-	return G.TraverseArrayPar[[]A, ReaderIOEither[[]B]](f)
-}
-
-// TraverseArrayWithIndexPar uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
-func TraverseArrayWithIndexPar[A, B any](f func(int, A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] {
-	return G.TraverseArrayWithIndexPar[[]A, ReaderIOEither[[]B]](f)
-}
-
-// SequenceArrayPar converts a homogeneous sequence of either into an either of sequence
-func SequenceArrayPar[A any](ma []ReaderIOEither[A]) ReaderIOEither[[]A] {
-	return G.SequenceArrayPar[[]A, []ReaderIOEither[A], ReaderIOEither[[]A]](ma)
-}
-
-// TraverseRecordPar uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
-func TraverseRecordPar[K comparable, A, B any](f func(A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] {
-	return G.TraverseRecordPar[K, map[K]A, ReaderIOEither[map[K]B]](f)
-}
-
-// TraverseRecordWithIndexPar uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
-func TraverseRecordWithIndexPar[K comparable, A, B any](f func(K, A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] {
-	return G.TraverseRecordWithIndexPar[K, map[K]A, ReaderIOEither[map[K]B]](f)
-}
-
-// SequenceRecordPar converts a homogeneous sequence of either into an either of sequence
-func SequenceRecordPar[K comparable, A any](ma map[K]ReaderIOEither[A]) ReaderIOEither[map[K]A] {
-	return G.SequenceRecordPar[K, map[K]A, map[K]ReaderIOEither[A], ReaderIOEither[map[K]A]](ma)
-}

di/app.go

@@ -1,38 +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 di
-
-import (
-	DIE "github.com/IBM/fp-go/di/erasure"
-	F "github.com/IBM/fp-go/function"
-	IO "github.com/IBM/fp-go/io"
-	IOE "github.com/IBM/fp-go/ioeither"
-)
-
-var (
-	// InjMain is the [InjectionToken] for the main application
-	InjMain = MakeToken[any]("APP")
-
-	// Main is the resolver for the main application
-	Main = Resolve(InjMain)
-)
-
-// RunMain runs the main application from a set of [DIE.Provider]s
-var RunMain = F.Flow3(
-	DIE.MakeInjector,
-	Main,
-	IOE.Fold(IO.Of[error], F.Constant1[any](IO.Of[error](nil))),
-)

di/doc.go

@@ -1,43 +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 di implements functions and data types supporting dependency injection patterns
-//
-// The fundamental building block is the concept of a [Dependency]. This describes the abstract concept of a function, service or value together with its type.
-// Examples for dependencies can be as simple as configuration values such as the API URL for a service, the current username, a [Dependency] could be the map
-// of the configuration environment, an http client or as complex as a service interface. Important is that a [Dependency] only defines the concept but
-// not the implementation.
-//
-// The implementation of a [Dependency] is called a [Provider], the dependency of an `API URL` could e.g. be realized by a provider that consults the environment to read the information
-// or a config file or simply hardcode it.
-// In many cases the implementation of a [Provider] depends in turn on other [Dependency] (but never directly on other [Provider]s), a provider for an `API URL` that reads
-// the information from the environment would e.g. depend on a [Dependency] that represents this environment.
-//
-// It is the resposibility of the [InjectableFactory] to create an instance of a [Dependency]. All instances are considered singletons. Create an [InjectableFactory] via the [MakeInjector] method. Use [Resolve] to create a strongly typed
-// factory for a particular [InjectionToken].
-//
-// In most cases it is not required to use [InjectableFactory] directly, instead you would create a [Provider] via the [MakeProvider2] method (suffix indicates the number of dependencies). In this call
-// you give a number of (strongly typed) [Dependency] identifiers and a (strongly typed) factory function for the implementation. The dependency injection framework makes
-// sure to resolve the dependencies before calling the factory method.
-//
-// For convenience purposes it can be helpful to attach a default implementation of a [Dependency]. In this case use the [MakeTokenWithDefault2] method (suffix indicates the number of dependencies)
-// to define the [InjectionToken].
-//
-// [Provider]: [github.com/IBM/fp-go/di/erasure.Provider]
-// [InjectableFactory]: [github.com/IBM/fp-go/di/erasure.InjectableFactory]
-// [MakeInjector]: [github.com/IBM/fp-go/di/erasure.MakeInjector]
-package di
-
-//go:generate go run .. di --count 10 --filename gen.go

di/erasure/injector.go

@@ -7,6 +7,7 @@
 //
 // 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.
@@ -114,9 +115,6 @@ func itemProviderFactory(fcts []ProviderFactory) ProviderFactory {
 }
 
 // MakeInjector creates an [InjectableFactory] based on a set of [Provider]s
-//
-// The resulting [InjectableFactory] can then be used to retrieve service instances given their [Dependency]. The implementation
-// makes sure to transitively resolve the required dependencies.
 func MakeInjector(providers []Provider) InjectableFactory {
 
 	type Result = IOE.IOEither[error, any]

di/erasure/provider.go

@@ -31,29 +31,25 @@ import (
 	R "github.com/IBM/fp-go/record"
 )
 
-type (
-	// InjectableFactory is a factory function that can create an untyped instance of a service based on its [Dependency] identifier
-	InjectableFactory = func(Dependency) IOE.IOEither[error, any]
-	ProviderFactory   = func(InjectableFactory) IOE.IOEither[error, any]
+type InjectableFactory = func(Dependency) IOE.IOEither[error, any]
+type ProviderFactory = func(InjectableFactory) IOE.IOEither[error, any]
 
-	paramIndex = map[int]int
-	paramValue = map[int]any
-	handler    = func(paramIndex) func([]IOE.IOEither[error, any]) IOE.IOEither[error, paramValue]
-	mapping    = map[int]paramIndex
+type paramIndex = map[int]int
+type paramValue = map[int]any
+type handler = func(paramIndex) func([]IOE.IOEither[error, any]) IOE.IOEither[error, paramValue]
 
-	Provider interface {
-		fmt.Stringer
-		// Provides returns the [Dependency] implemented by this provider
-		Provides() Dependency
-		// Factory returns s function that can create an instance of the dependency based on an [InjectableFactory]
-		Factory() ProviderFactory
-	}
+type Provider interface {
+	fmt.Stringer
+	// Provides returns the [Dependency] implemented by this provider
+	Provides() Dependency
+	// Factory returns s function that can create an instance of the dependency based on an [InjectableFactory]
+	Factory() ProviderFactory
+}
 
-	provider struct {
-		provides Dependency
-		factory  ProviderFactory
-	}
-)
+type provider struct {
+	provides Dependency
+	factory  ProviderFactory
+}
 
 func (p *provider) Provides() Dependency {
 	return p.provides
@@ -76,16 +72,11 @@ func mapFromToken(idx int, token Dependency) map[int]paramIndex {
 }
 
 var (
-	// Empty is the empty array of providers
-	Empty = A.Empty[Provider]()
-
 	mergeTokenMaps = R.UnionMonoid[int](R.UnionLastSemigroup[int, int]())
 	foldDeps       = A.FoldMapWithIndex[Dependency](mergeTokenMaps)(mapFromToken)
 	mergeMaps      = R.UnionLastMonoid[int, any]()
 	collectParams  = R.CollectOrd[any, any](Int.Ord)(F.SK[int, any])
 
-	mapDeps = F.Curry2(A.MonadMap[Dependency, IOE.IOEither[error, any]])
-
 	handlers = map[int]handler{
 		Identity: func(mp paramIndex) func([]IOE.IOEither[error, any]) IOE.IOEither[error, paramValue] {
 			return func(res []IOE.IOEither[error, any]) IOE.IOEither[error, paramValue] {
@@ -126,7 +117,7 @@ var (
 					mp,
 					R.Map[int](F.Flow3(
 						getAt(res),
-						IOE.ToIOOption[error, any],
+						IOO.FromIOEither[error, any],
 						F.ToAny[IOO.IOOption[any]],
 					)),
 					IOE.Of[error, paramValue],
@@ -136,13 +127,15 @@ var (
 	}
 )
 
+type Mapping = map[int]paramIndex
+
 func getAt[T any](ar []T) func(idx int) T {
 	return func(idx int) T {
 		return ar[idx]
 	}
 }
 
-func handleMapping(mp mapping) func(res []IOE.IOEither[error, any]) IOE.IOEither[error, []any] {
+func handleMapping(mp Mapping) func(res []IOE.IOEither[error, any]) IOE.IOEither[error, []any] {
 	preFct := F.Pipe1(
 		mp,
 		R.Collect(func(idx int, p paramIndex) func([]IOE.IOEither[error, any]) IOE.IOEither[error, paramValue] {
@@ -174,7 +167,7 @@ func MakeProviderFactory(
 	fct func(param ...any) IOE.IOEither[error, any]) ProviderFactory {
 
 	return F.Flow3(
-		mapDeps(deps),
+		F.Curry2(A.MonadMap[Dependency, IOE.IOEither[error, any]])(deps),
 		handleMapping(foldDeps(deps)),
 		IOE.Chain(F.Unvariadic0(fct)),
 	)

di/injector.go

@@ -7,6 +7,7 @@
 //
 // 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.

di/provider.go

@@ -12,7 +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 di
 
 import (
@@ -22,6 +21,7 @@ import (
 	"github.com/IBM/fp-go/errors"
 	F "github.com/IBM/fp-go/function"
 	IOE "github.com/IBM/fp-go/ioeither"
+	T "github.com/IBM/fp-go/tuple"
 )
 
 func lookupAt[T any](idx int, token Dependency[T]) func(params []any) E.Either[error, T] {
@@ -32,25 +32,49 @@ func lookupAt[T any](idx int, token Dependency[T]) func(params []any) E.Either[e
 	)
 }
 
-func eraseTuple[A, R any](f func(A) IOE.IOEither[error, R]) func(E.Either[error, A]) IOE.IOEither[error, any] {
-	return F.Flow3(
-		IOE.FromEither[error, A],
-		IOE.Chain(f),
-		IOE.Map[error](F.ToAny[R]),
-	)
-}
-
-func eraseProviderFactory0[R any](f IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {
+func eraseProviderFactory0[R any](f func() IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {
 	return func(params ...any) IOE.IOEither[error, any] {
 		return F.Pipe1(
-			f,
+			f(),
+			IOE.Map[error](F.ToAny[R]),
+		)
+	}
+}
+
+func eraseProviderFactory1[T1 any, R any](
+	d1 Dependency[T1],
+	f func(T1) IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {
+	ft := T.Tupled1(f)
+	t1 := lookupAt[T1](0, d1)
+	return func(params ...any) IOE.IOEither[error, any] {
+		return F.Pipe3(
+			E.SequenceT1(t1(params)),
+			IOE.FromEither[error, T.Tuple1[T1]],
+			IOE.Chain(ft),
+			IOE.Map[error](F.ToAny[R]),
+		)
+	}
+}
+
+func eraseProviderFactory2[T1, T2 any, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	f func(T1, T2) IOE.IOEither[error, R]) func(params ...any) IOE.IOEither[error, any] {
+	ft := T.Tupled2(f)
+	t1 := lookupAt[T1](0, d1)
+	t2 := lookupAt[T2](1, d2)
+	return func(params ...any) IOE.IOEither[error, any] {
+		return F.Pipe3(
+			E.SequenceT2(t1(params), t2(params)),
+			IOE.FromEither[error, T.Tuple2[T1, T2]],
+			IOE.Chain(ft),
 			IOE.Map[error](F.ToAny[R]),
 		)
 	}
 }
 
 func MakeProviderFactory0[R any](
-	fct IOE.IOEither[error, R],
+	fct func() IOE.IOEither[error, R],
 ) DIE.ProviderFactory {
 	return DIE.MakeProviderFactory(
 		A.Empty[DIE.Dependency](),
@@ -58,14 +82,14 @@ func MakeProviderFactory0[R any](
 	)
 }
 
-// MakeTokenWithDefault0 creates a unique [InjectionToken] for a specific type with an attached default [DIE.Provider]
-func MakeTokenWithDefault0[R any](name string, fct IOE.IOEither[error, R]) InjectionToken[R] {
+// MakeTokenWithDefault0 create a unique `InjectionToken` for a specific type with an attached default provider
+func MakeTokenWithDefault0[R any](name string, fct func() IOE.IOEither[error, R]) InjectionToken[R] {
 	return MakeTokenWithDefault[R](name, MakeProviderFactory0(fct))
 }
 
 func MakeProvider0[R any](
 	token InjectionToken[R],
-	fct IOE.IOEither[error, R],
+	fct func() IOE.IOEither[error, R],
 ) DIE.Provider {
 	return DIE.MakeProvider(
 		token,
@@ -73,7 +97,70 @@ func MakeProvider0[R any](
 	)
 }
 
+func MakeProviderFactory1[T1, R any](
+	d1 Dependency[T1],
+	fct func(T1) IOE.IOEither[error, R],
+) DIE.ProviderFactory {
+
+	return DIE.MakeProviderFactory(
+		A.From[DIE.Dependency](d1),
+		eraseProviderFactory1(d1, fct),
+	)
+}
+
+// MakeTokenWithDefault1 create a unique `InjectionToken` for a specific type with an attached default provider
+func MakeTokenWithDefault1[T1, R any](name string,
+	d1 Dependency[T1],
+	fct func(T1) IOE.IOEither[error, R]) InjectionToken[R] {
+	return MakeTokenWithDefault[R](name, MakeProviderFactory1(d1, fct))
+}
+
+func MakeProvider1[T1, R any](
+	token InjectionToken[R],
+	d1 Dependency[T1],
+	fct func(T1) IOE.IOEither[error, R],
+) DIE.Provider {
+
+	return DIE.MakeProvider(
+		token,
+		MakeProviderFactory1(d1, fct),
+	)
+}
+
+func MakeProviderFactory2[T1, T2, R any](
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	fct func(T1, T2) IOE.IOEither[error, R],
+) DIE.ProviderFactory {
+
+	return DIE.MakeProviderFactory(
+		A.From[DIE.Dependency](d1, d2),
+		eraseProviderFactory2(d1, d2, fct),
+	)
+}
+
+// MakeTokenWithDefault2 create a unique `InjectionToken` for a specific type with an attached default provider
+func MakeTokenWithDefault2[T1, T2, R any](name string,
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	fct func(T1, T2) IOE.IOEither[error, R]) InjectionToken[R] {
+	return MakeTokenWithDefault[R](name, MakeProviderFactory2(d1, d2, fct))
+}
+
+func MakeProvider2[T1, T2, R any](
+	token InjectionToken[R],
+	d1 Dependency[T1],
+	d2 Dependency[T2],
+	fct func(T1, T2) IOE.IOEither[error, R],
+) DIE.Provider {
+
+	return DIE.MakeProvider(
+		token,
+		MakeProviderFactory2(d1, d2, fct),
+	)
+}
+
 // ConstProvider simple implementation for a provider with a constant value
 func ConstProvider[R any](token InjectionToken[R], value R) DIE.Provider {
-	return MakeProvider0[R](token, IOE.Of[error](value))
+	return MakeProvider0[R](token, F.Constant(IOE.Of[error](value)))
 }

di/provider_test.go

@@ -12,7 +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 di
 
 import (
@@ -39,10 +38,12 @@ func TestSimpleProvider(t *testing.T) {
 
 	var staticCount int
 
-	staticValue := func(value string) IOE.IOEither[error, string] {
-		return func() E.Either[error, string] {
-			staticCount++
-			return E.Of[error](fmt.Sprintf("Static based on [%s], at [%s]", value, time.Now()))
+	staticValue := func(value string) func() IOE.IOEither[error, string] {
+		return func() IOE.IOEither[error, string] {
+			return func() E.Either[error, string] {
+				staticCount++
+				return E.Of[error](fmt.Sprintf("Static based on [%s], at [%s]", value, time.Now()))
+			}
 		}
 	}
 
@@ -81,10 +82,12 @@ func TestOptionalProvider(t *testing.T) {
 
 	var staticCount int
 
-	staticValue := func(value string) IOE.IOEither[error, string] {
-		return func() E.Either[error, string] {
-			staticCount++
-			return E.Of[error](fmt.Sprintf("Static based on [%s], at [%s]", value, time.Now()))
+	staticValue := func(value string) func() IOE.IOEither[error, string] {
+		return func() IOE.IOEither[error, string] {
+			return func() E.Either[error, string] {
+				staticCount++
+				return E.Of[error](fmt.Sprintf("Static based on [%s], at [%s]", value, time.Now()))
+			}
 		}
 	}
 
@@ -179,10 +182,12 @@ func TestEagerAndLazyProvider(t *testing.T) {
 
 	var staticCount int
 
-	staticValue := func(value string) IOE.IOEither[error, string] {
-		return func() E.Either[error, string] {
-			staticCount++
-			return E.Of[error](fmt.Sprintf("Static based on [%s], at [%s]", value, time.Now()))
+	staticValue := func(value string) func() IOE.IOEither[error, string] {
+		return func() IOE.IOEither[error, string] {
+			return func() E.Either[error, string] {
+				staticCount++
+				return E.Of[error](fmt.Sprintf("Static based on [%s], at [%s]", value, time.Now()))
+			}
 		}
 	}
 
@@ -302,7 +307,7 @@ func TestTokenWithDefaultProvider(t *testing.T) {
 	// token without a default
 	injToken1 := MakeToken[string]("Token1")
 	// token with a default
-	injToken2 := MakeTokenWithDefault0("Token2", IOE.Of[error]("Carsten"))
+	injToken2 := MakeTokenWithDefault0("Token2", F.Constant(IOE.Of[error]("Carsten")))
 	// dependency
 	injToken3 := MakeToken[string]("Token3")
 
@@ -325,7 +330,7 @@ func TestTokenWithDefaultProvider(t *testing.T) {
 
 func TestTokenWithDefaultProviderAndOverride(t *testing.T) {
 	// token with a default
-	injToken2 := MakeTokenWithDefault0("Token2", IOE.Of[error]("Carsten"))
+	injToken2 := MakeTokenWithDefault0("Token2", F.Constant(IOE.Of[error]("Carsten")))
 	// dependency
 	injToken3 := MakeToken[string]("Token3")
 

di/token.go

@@ -42,21 +42,20 @@ type InjectionToken[T any] interface {
 	// Identity idenifies this dependency as a mandatory, required dependency, it will be resolved eagerly and injected as `T`.
 	// If the dependency cannot be resolved, the resolution process fails
 	Identity() Dependency[T]
-	// Option identifies this dependency as optional, it will be resolved eagerly and injected as [O.Option[T]].
-	// If the dependency cannot be resolved, the resolution process continues and the dependency is represented as [O.None[T]]
+	// Option identifies this dependency as optional, it will be resolved eagerly and injected as `O.Option[T]`.
+	// If the dependency cannot be resolved, the resolution process continues and the dependency is represented as `O.None[T]`
 	Option() Dependency[O.Option[T]]
-	// IOEither identifies this dependency as mandatory but it will be resolved lazily as a [IOE.IOEither[error, T]]. This
+	// IOEither identifies this dependency as mandatory but it will be resolved lazily as a `IOE.IOEither[error, T]`. This
 	// value is memoized to make sure the dependency is a singleton.
 	// If the dependency cannot be resolved, the resolution process fails
 	IOEither() Dependency[IOE.IOEither[error, T]]
-	// IOOption identifies this dependency as optional but it will be resolved lazily as a [IOO.IOOption[T]]. This
+	// IOOption identifies this dependency as optional but it will be resolved lazily as a `IOO.IOOption[T]`. This
 	// value is memoized to make sure the dependency is a singleton.
 	// If the dependency cannot be resolved, the resolution process continues and the dependency is represented as the none value.
 	IOOption() Dependency[IOO.IOOption[T]]
 }
 
-// MultiInjectionToken uniquely identifies a dependency by giving it an Id, Type and name that can have multiple implementations.
-// Implementations are provided via the [MultiInjectionToken.Item] injection token.
+// MultiInjectionToken uniquely identifies a dependency by giving it an Id, Type and name.
 type MultiInjectionToken[T any] interface {
 	// Container returns the injection token used to request an array of all provided items
 	Container() InjectionToken[[]T]
@@ -147,7 +146,7 @@ func (m *multiInjectionToken[T]) Item() InjectionToken[T] {
 	return m.item
 }
 
-// makeToken create a unique [InjectionToken] for a specific type
+// makeToken create a unique `InjectionToken` for a specific type
 func makeInjectionToken[T any](name string, providerFactory O.Option[DIE.ProviderFactory]) InjectionToken[T] {
 	id := genId()
 	toIdentity := toType[T]()
@@ -159,12 +158,12 @@ func makeInjectionToken[T any](name string, providerFactory O.Option[DIE.Provide
 	}
 }
 
-// MakeToken create a unique [InjectionToken] for a specific type
+// MakeToken create a unique `InjectionToken` for a specific type
 func MakeToken[T any](name string) InjectionToken[T] {
 	return makeInjectionToken[T](name, O.None[DIE.ProviderFactory]())
 }
 
-// MakeToken create a unique [InjectionToken] for a specific type
+// MakeToken create a unique `InjectionToken` for a specific type
 func MakeTokenWithDefault[T any](name string, providerFactory DIE.ProviderFactory) InjectionToken[T] {
 	return makeInjectionToken[T](name, O.Of(providerFactory))
 }

di/utils.go

@@ -12,7 +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 di
 
 import (

di/utils_test.go

@@ -12,7 +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 di
 
 import (

either/array.go

@@ -61,14 +61,14 @@ func SequenceArray[E, A any](ma []Either[E, A]) Either[E, []A] {
 	return SequenceArrayG[[]A](ma)
 }
 
-// CompactArrayG discards the none values and keeps the right values
+// CompactArrayG discards the none values and keeps the some values
 func CompactArrayG[A1 ~[]Either[E, A], A2 ~[]A, E, A any](fa A1) A2 {
 	return RA.Reduce(fa, func(out A2, value Either[E, A]) A2 {
 		return MonadFold(value, F.Constant1[E](out), F.Bind1st(RA.Append[A2, A], out))
-	}, make(A2, 0, len(fa)))
+	}, make(A2, len(fa)))
 }
 
-// CompactArray discards the none values and keeps the right values
+// CompactArray discards the none values and keeps the some values
 func CompactArray[E, A any](fa []Either[E, A]) []A {
 	return CompactArrayG[[]Either[E, A], []A](fa)
 }

either/array_test.go

@@ -1,18 +0,0 @@
-package either
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestCompactArray(t *testing.T) {
-	ar := []Either[string, string]{
-		Of[string]("ok"),
-		Left[string]("err"),
-		Of[string]("ok"),
-	}
-
-	res := CompactArray(ar)
-	assert.Equal(t, 2, len(res))
-}

either/either.go

@@ -89,7 +89,7 @@ func MonadChainFirst[E, A, B any](ma Either[E, A], f func(a A) Either[E, B]) Eit
 	})
 }
 
-func MonadChainTo[A, E, B any](ma Either[E, A], mb Either[E, B]) Either[E, B] {
+func MonadChainTo[E, A, B any](ma Either[E, A], mb Either[E, B]) Either[E, B] {
 	return mb
 }
 
@@ -104,8 +104,8 @@ 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.Bind2nd(MonadChainTo[A, E, B], mb)
+func ChainTo[E, A, B any](mb Either[E, B]) func(Either[E, A]) Either[E, B] {
+	return F.Bind2nd(MonadChainTo[E, A, B], mb)
 }
 
 func Chain[E, A, B any](f func(a A) Either[E, B]) func(Either[E, A]) Either[E, B] {

either/logger.go

@@ -41,7 +41,7 @@ func Logger[E, A any](loggers ...*log.Logger) func(string) func(Either[E, A]) Ei
 		return func(ma Either[E, A]) Either[E, A] {
 			return F.Pipe1(
 				delegate(ma),
-				ChainTo[A](ma),
+				ChainTo[E, A](ma),
 			)
 		}
 	}

endomorphism/curry.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 endomorphism
-
-import (
-	G "github.com/IBM/fp-go/endomorphism/generic"
-)
-
-// Curry2 curries a binary function
-func Curry2[FCT ~func(T0, T1) T1, T0, T1 any](f FCT) func(T0) Endomorphism[T1] {
-	return G.Curry2[Endomorphism[T1]](f)
-}
-
-// Curry3 curries a ternary function
-func Curry3[FCT ~func(T0, T1, T2) T2, T0, T1, T2 any](f FCT) func(T0) func(T1) Endomorphism[T2] {
-	return G.Curry3[Endomorphism[T2]](f)
-}

endomorphism/endo.go

@@ -1,60 +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 endomorphism
-
-import (
-	G "github.com/IBM/fp-go/endomorphism/generic"
-)
-
-func MonadAp[A any](fab Endomorphism[A], fa A) A {
-	return G.MonadAp[Endomorphism[A]](fab, fa)
-}
-
-func Ap[A any](fa A) func(Endomorphism[A]) A {
-	return G.Ap[Endomorphism[A]](fa)
-}
-
-func MonadFlap[A any](fab Endomorphism[A], a A) A {
-	return G.MonadFlap[Endomorphism[A]](fab, a)
-}
-
-func Flap[A any](a A) func(Endomorphism[A]) A {
-	return G.Flap[Endomorphism[A]](a)
-}
-
-func MonadMap[A any](fa A, f Endomorphism[A]) A {
-	return G.MonadMap[Endomorphism[A]](fa, f)
-}
-
-func Map[A any](f Endomorphism[A]) Endomorphism[A] {
-	return G.Map[Endomorphism[A]](f)
-}
-
-func MonadChain[A any](ma A, f Endomorphism[A]) A {
-	return G.MonadChain[Endomorphism[A]](ma, f)
-}
-
-func Chain[A any](f Endomorphism[A]) Endomorphism[A] {
-	return G.Chain[Endomorphism[A], A](f)
-}
-
-func MonadChainFirst[A any](fa A, f Endomorphism[A]) A {
-	return G.MonadChainFirst[Endomorphism[A]](fa, f)
-}
-
-func ChainFirst[A any](f Endomorphism[A]) Endomorphism[A] {
-	return G.ChainFirst[Endomorphism[A]](f)
-}

endomorphism/generic/curry.go

@@ -1,36 +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 generic
-
-// Curry2 is a duplicate of [F.Curry2] but because of the type system it's not compatible otherwise
-func Curry2[GT1 ~func(T1) T1, FCT ~func(T0, T1) T1, T0, T1 any](f FCT) func(T0) GT1 {
-	return func(t0 T0) GT1 {
-		return func(t1 T1) T1 {
-			return f(t0, t1)
-		}
-	}
-}
-
-// Curry2 is a duplicate of [F.Curry2] but because of the type system it's not compatible otherwise
-func Curry3[GT2 ~func(T2) T2, FCT ~func(T0, T1, T2) T2, T0, T1, T2 any](f FCT) func(T0) func(T1) GT2 {
-	return func(t0 T0) func(T1) GT2 {
-		return func(t1 T1) GT2 {
-			return func(t2 T2) T2 {
-				return f(t0, t1, t2)
-			}
-		}
-	}
-}

endomorphism/generic/endo.go

@@ -1,60 +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 generic
-
-import (
-	I "github.com/IBM/fp-go/identity/generic"
-)
-
-func MonadAp[GA ~func(A) A, A any](fab GA, fa A) A {
-	return I.MonadAp[GA, A, A](fab, fa)
-}
-
-func Ap[GA ~func(A) A, A any](fa A) func(GA) A {
-	return I.Ap[GA, A, A](fa)
-}
-
-func MonadFlap[GA ~func(A) A, A any](fab GA, a A) A {
-	return I.MonadFlap[GA, A, A](fab, a)
-}
-
-func Flap[GA ~func(A) A, A any](a A) func(GA) A {
-	return I.Flap[GA, A, A](a)
-}
-
-func MonadMap[GA ~func(A) A, A any](fa A, f GA) A {
-	return I.MonadMap[GA, A, A](fa, f)
-}
-
-func Map[GA ~func(A) A, A any](f GA) GA {
-	return I.Map[GA, A, A](f)
-}
-
-func MonadChain[GA ~func(A) A, A any](ma A, f GA) A {
-	return I.MonadChain[GA, A, A](ma, f)
-}
-
-func Chain[GA ~func(A) A, A any](f GA) GA {
-	return I.Chain[GA, A](f)
-}
-
-func MonadChainFirst[GA ~func(A) A, A any](fa A, f GA) A {
-	return I.MonadChainFirst[GA, A, A](fa, f)
-}
-
-func ChainFirst[GA ~func(A) A, A any](f GA) GA {
-	return I.ChainFirst[GA, A, A](f)
-}

endomorphism/generic/monoid.go

@@ -1,47 +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 generic
-
-import (
-	F "github.com/IBM/fp-go/function"
-	M "github.com/IBM/fp-go/monoid"
-	S "github.com/IBM/fp-go/semigroup"
-)
-
-// Of converts any function to an [Endomorphism]
-func Of[ENDO ~func(A) A, F ~func(A) A, A any](f F) ENDO {
-	return func(a A) A {
-		return f(a)
-	}
-}
-
-func Identity[ENDO ~func(A) A, A any]() ENDO {
-	return Of[ENDO](F.Identity[A])
-}
-
-func Compose[ENDO ~func(A) A, A any](f1, f2 ENDO) ENDO {
-	return Of[ENDO](F.Flow2(f1, f2))
-}
-
-// Semigroup for the Endomorphism where the `concat` operation is the usual function composition.
-func Semigroup[ENDO ~func(A) A, A any]() S.Semigroup[ENDO] {
-	return S.MakeSemigroup(Compose[ENDO])
-}
-
-// Monoid for the Endomorphism where the `concat` operation is the usual function composition.
-func Monoid[ENDO ~func(A) A, A any]() M.Monoid[ENDO] {
-	return M.MakeMonoid(Compose[ENDO], Identity[ENDO]())
-}

endomorphism/monoid.go

@@ -16,30 +16,17 @@
 package endomorphism
 
 import (
-	G "github.com/IBM/fp-go/endomorphism/generic"
+	F "github.com/IBM/fp-go/function"
 	M "github.com/IBM/fp-go/monoid"
 	S "github.com/IBM/fp-go/semigroup"
 )
 
-// Endomorphism is a function  that
-type Endomorphism[A any] func(A) A
-
-// Of converts any function to an [Endomorphism]
-func Of[F ~func(A) A, A any](f F) Endomorphism[A] {
-	return G.Of[Endomorphism[A]](f)
-}
-
-// Identity returns the identity [Endomorphism]
-func Identity[A any]() Endomorphism[A] {
-	return G.Identity[Endomorphism[A]]()
-}
-
 // Semigroup for the Endomorphism where the `concat` operation is the usual function composition.
-func Semigroup[A any]() S.Semigroup[Endomorphism[A]] {
-	return G.Semigroup[Endomorphism[A]]()
+func Semigroup[A any]() S.Semigroup[func(A) A] {
+	return S.MakeSemigroup(F.Flow2[func(A) A, func(A) A])
 }
 
 // Monoid for the Endomorphism where the `concat` operation is the usual function composition.
-func Monoid[A any]() M.Monoid[Endomorphism[A]] {
-	return G.Monoid[Endomorphism[A]]()
+func Monoid[A any]() M.Monoid[func(A) A] {
+	return M.MakeMonoid(F.Flow2[func(A) A, func(A) A], F.Identity[A])
 }

file/getters.go

@@ -15,10 +15,7 @@
 
 package file
 
-import (
-	"io"
-	"path/filepath"
-)
+import "path/filepath"
 
 // Join appends a filename to a root path
 func Join(name string) func(root string) string {
@@ -26,13 +23,3 @@ func Join(name string) func(root string) string {
 		return filepath.Join(root, name)
 	}
 }
-
-// ToReader converts a [io.Reader]
-func ToReader[R io.Reader](r R) io.Reader {
-	return r
-}
-
-// 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
-// 2023-12-18 09:38:59.1616876 +0100 CET m=+0.008641801
+// 2023-10-23 08:30:44.6474482 +0200 CEST m=+0.150851901
 
 package function
 

function/flip.go

@@ -1,25 +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 function
-
-// Flip reverses the order of parameters of a curried function
-func Flip[T1, T2, R any](f func(T1) func(T2) R) func(T2) func(T1) R {
-	return func(t2 T2) func(T1) R {
-		return func(t1 T1) R {
-			return f(t1)(t2)
-		}
-	}
-}

function/flip_test.go

@@ -1,36 +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 function
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestFlip(t *testing.T) {
-
-	x := Curry2(func(a, b string) string {
-		return fmt.Sprintf("%s:%s", a, b)
-	})
-
-	assert.Equal(t, "a:b", x("a")("b"))
-
-	y := Flip(x)
-
-	assert.Equal(t, "b:a", y("a")("b"))
-}

function/gen.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-12-18 09:38:51.4946446 +0100 CET m=+0.008838401
+// 2023-10-23 08:30:41.7972101 +0200 CEST m=+0.008029101
 
 package function
 
@@ -55,7 +55,7 @@ func Nullary1[F1 ~func() T1, T1 any](f1 F1) func() T1 {
 
 // Curry1 takes a function with 1 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry1]
-func Curry1[FCT ~func(T0) T1, T0, T1 any](f FCT) func(T0) T1 {
+func Curry1[T0, T1 any](f func(T0) T1) func(T0) T1 {
 	return func(t0 T0) T1 {
 		return f(t0)
 	}
@@ -63,7 +63,7 @@ func Curry1[FCT ~func(T0) T1, T0, T1 any](f FCT) func(T0) T1 {
 
 // Uncurry1 takes a cascade of 1 functions each taking only one parameter and returns a function with 1 parameters .
 // The inverse function is [Curry1]
-func Uncurry1[FCT ~func(T0) T1, T0, T1 any](f FCT) func(T0) T1 {
+func Uncurry1[T0, T1 any](f func(T0) T1) func(T0) T1 {
 	return func(t0 T0) T1 {
 		return f(t0)
 	}
@@ -115,7 +115,7 @@ func Nullary2[F1 ~func() T1, F2 ~func(T1) T2, T1, T2 any](f1 F1, f2 F2) func() T
 
 // Curry2 takes a function with 2 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry2]
-func Curry2[FCT ~func(T0, T1) T2, T0, T1, T2 any](f FCT) func(T0) func(T1) T2 {
+func Curry2[T0, T1, T2 any](f func(T0, T1) T2) func(T0) func(T1) T2 {
 	return func(t0 T0) func(t1 T1) T2 {
 		return func(t1 T1) T2 {
 			return f(t0, t1)
@@ -125,7 +125,7 @@ func Curry2[FCT ~func(T0, T1) T2, T0, T1, T2 any](f FCT) func(T0) func(T1) T2 {
 
 // Uncurry2 takes a cascade of 2 functions each taking only one parameter and returns a function with 2 parameters .
 // The inverse function is [Curry2]
-func Uncurry2[FCT ~func(T0) func(T1) T2, T0, T1, T2 any](f FCT) func(T0, T1) T2 {
+func Uncurry2[T0, T1, T2 any](f func(T0) func(T1) T2) func(T0, T1) T2 {
 	return func(t0 T0, t1 T1) T2 {
 		return f(t0)(t1)
 	}
@@ -178,7 +178,7 @@ func Nullary3[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, T1, T2, T3 any](f
 
 // Curry3 takes a function with 3 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry3]
-func Curry3[FCT ~func(T0, T1, T2) T3, T0, T1, T2, T3 any](f FCT) func(T0) func(T1) func(T2) T3 {
+func Curry3[T0, T1, T2, T3 any](f func(T0, T1, T2) T3) func(T0) func(T1) func(T2) T3 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) T3 {
 		return func(t1 T1) func(t2 T2) T3 {
 			return func(t2 T2) T3 {
@@ -190,7 +190,7 @@ func Curry3[FCT ~func(T0, T1, T2) T3, T0, T1, T2, T3 any](f FCT) func(T0) func(T
 
 // Uncurry3 takes a cascade of 3 functions each taking only one parameter and returns a function with 3 parameters .
 // The inverse function is [Curry3]
-func Uncurry3[FCT ~func(T0) func(T1) func(T2) T3, T0, T1, T2, T3 any](f FCT) func(T0, T1, T2) T3 {
+func Uncurry3[T0, T1, T2, T3 any](f func(T0) func(T1) func(T2) T3) func(T0, T1, T2) T3 {
 	return func(t0 T0, t1 T1, t2 T2) T3 {
 		return f(t0)(t1)(t2)
 	}
@@ -244,7 +244,7 @@ func Nullary4[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry4 takes a function with 4 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry4]
-func Curry4[FCT ~func(T0, T1, T2, T3) T4, T0, T1, T2, T3, T4 any](f FCT) func(T0) func(T1) func(T2) func(T3) T4 {
+func Curry4[T0, T1, T2, T3, T4 any](f func(T0, T1, T2, T3) T4) func(T0) func(T1) func(T2) func(T3) T4 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) T4 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) T4 {
 			return func(t2 T2) func(t3 T3) T4 {
@@ -258,7 +258,7 @@ func Curry4[FCT ~func(T0, T1, T2, T3) T4, T0, T1, T2, T3, T4 any](f FCT) func(T0
 
 // Uncurry4 takes a cascade of 4 functions each taking only one parameter and returns a function with 4 parameters .
 // The inverse function is [Curry4]
-func Uncurry4[FCT ~func(T0) func(T1) func(T2) func(T3) T4, T0, T1, T2, T3, T4 any](f FCT) func(T0, T1, T2, T3) T4 {
+func Uncurry4[T0, T1, T2, T3, T4 any](f func(T0) func(T1) func(T2) func(T3) T4) func(T0, T1, T2, T3) T4 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3) T4 {
 		return f(t0)(t1)(t2)(t3)
 	}
@@ -313,7 +313,7 @@ func Nullary5[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry5 takes a function with 5 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry5]
-func Curry5[FCT ~func(T0, T1, T2, T3, T4) T5, T0, T1, T2, T3, T4, T5 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) T5 {
+func Curry5[T0, T1, T2, T3, T4, T5 any](f func(T0, T1, T2, T3, T4) T5) func(T0) func(T1) func(T2) func(T3) func(T4) T5 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) T5 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) T5 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) T5 {
@@ -329,7 +329,7 @@ func Curry5[FCT ~func(T0, T1, T2, T3, T4) T5, T0, T1, T2, T3, T4, T5 any](f FCT)
 
 // Uncurry5 takes a cascade of 5 functions each taking only one parameter and returns a function with 5 parameters .
 // The inverse function is [Curry5]
-func Uncurry5[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) T5, T0, T1, T2, T3, T4, T5 any](f FCT) func(T0, T1, T2, T3, T4) T5 {
+func Uncurry5[T0, T1, T2, T3, T4, T5 any](f func(T0) func(T1) func(T2) func(T3) func(T4) T5) func(T0, T1, T2, T3, T4) T5 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) T5 {
 		return f(t0)(t1)(t2)(t3)(t4)
 	}
@@ -385,7 +385,7 @@ func Nullary6[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry6 takes a function with 6 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry6]
-func Curry6[FCT ~func(T0, T1, T2, T3, T4, T5) T6, T0, T1, T2, T3, T4, T5, T6 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) T6 {
+func Curry6[T0, T1, T2, T3, T4, T5, T6 any](f func(T0, T1, T2, T3, T4, T5) T6) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) T6 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) T6 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) T6 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) T6 {
@@ -403,7 +403,7 @@ func Curry6[FCT ~func(T0, T1, T2, T3, T4, T5) T6, T0, T1, T2, T3, T4, T5, T6 any
 
 // Uncurry6 takes a cascade of 6 functions each taking only one parameter and returns a function with 6 parameters .
 // The inverse function is [Curry6]
-func Uncurry6[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) T6, T0, T1, T2, T3, T4, T5, T6 any](f FCT) func(T0, T1, T2, T3, T4, T5) T6 {
+func Uncurry6[T0, T1, T2, T3, T4, T5, T6 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) T6) func(T0, T1, T2, T3, T4, T5) T6 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) T6 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)
 	}
@@ -460,7 +460,7 @@ func Nullary7[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry7 takes a function with 7 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry7]
-func Curry7[FCT ~func(T0, T1, T2, T3, T4, T5, T6) T7, T0, T1, T2, T3, T4, T5, T6, T7 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) T7 {
+func Curry7[T0, T1, T2, T3, T4, T5, T6, T7 any](f func(T0, T1, T2, T3, T4, T5, T6) T7) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) T7 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) T7 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) T7 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) T7 {
@@ -480,7 +480,7 @@ func Curry7[FCT ~func(T0, T1, T2, T3, T4, T5, T6) T7, T0, T1, T2, T3, T4, T5, T6
 
 // Uncurry7 takes a cascade of 7 functions each taking only one parameter and returns a function with 7 parameters .
 // The inverse function is [Curry7]
-func Uncurry7[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) T7, T0, T1, T2, T3, T4, T5, T6, T7 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6) T7 {
+func Uncurry7[T0, T1, T2, T3, T4, T5, T6, T7 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) T7) func(T0, T1, T2, T3, T4, T5, T6) T7 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) T7 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)
 	}
@@ -538,7 +538,7 @@ func Nullary8[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry8 takes a function with 8 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry8]
-func Curry8[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7) T8, T0, T1, T2, T3, T4, T5, T6, T7, T8 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T8 {
+func Curry8[T0, T1, T2, T3, T4, T5, T6, T7, T8 any](f func(T0, T1, T2, T3, T4, T5, T6, T7) T8) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T8 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) T8 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) T8 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) T8 {
@@ -560,7 +560,7 @@ func Curry8[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7) T8, T0, T1, T2, T3, T4, T5
 
 // Uncurry8 takes a cascade of 8 functions each taking only one parameter and returns a function with 8 parameters .
 // The inverse function is [Curry8]
-func Uncurry8[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T8, T0, T1, T2, T3, T4, T5, T6, T7, T8 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7) T8 {
+func Uncurry8[T0, T1, T2, T3, T4, T5, T6, T7, T8 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T8) func(T0, T1, T2, T3, T4, T5, T6, T7) T8 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) T8 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)
 	}
@@ -619,7 +619,7 @@ func Nullary9[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry9 takes a function with 9 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry9]
-func Curry9[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) T9, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T9 {
+func Curry9[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8) T9) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T9 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) T9 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) T9 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) T9 {
@@ -643,7 +643,7 @@ func Curry9[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) T9, T0, T1, T2, T3, T4
 
 // Uncurry9 takes a cascade of 9 functions each taking only one parameter and returns a function with 9 parameters .
 // The inverse function is [Curry9]
-func Uncurry9[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T9, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) T9 {
+func Uncurry9[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T9) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) T9 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) T9 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)
 	}
@@ -703,7 +703,7 @@ func Nullary10[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry10 takes a function with 10 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry10]
-func Curry10[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) T10, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T10 {
+func Curry10[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) T10) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T10 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) T10 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) T10 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) T10 {
@@ -729,7 +729,7 @@ func Curry10[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) T10, T0, T1, T2,
 
 // Uncurry10 takes a cascade of 10 functions each taking only one parameter and returns a function with 10 parameters .
 // The inverse function is [Curry10]
-func Uncurry10[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T10, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) T10 {
+func Uncurry10[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T10) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) T10 {
 	return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) T10 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)
 	}
@@ -790,7 +790,7 @@ func Nullary11[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry11 takes a function with 11 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry11]
-func Curry11[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) T11, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T11 {
+func Curry11[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) T11) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T11 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) T11 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) T11 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) T11 {
@@ -818,7 +818,7 @@ func Curry11[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) T11, T0, T1,
 
 // Uncurry11 takes a cascade of 11 functions each taking only one parameter and returns a function with 11 parameters .
 // The inverse function is [Curry11]
-func Uncurry11[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T11, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) T11 {
+func Uncurry11[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T11) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) T11 {
 	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 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)
 	}
@@ -880,7 +880,7 @@ func Nullary12[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry12 takes a function with 12 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry12]
-func Curry12[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) T12, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T12 {
+func Curry12[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) T12) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T12 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) T12 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) T12 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) T12 {
@@ -910,7 +910,7 @@ func Curry12[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) T12, T0
 
 // Uncurry12 takes a cascade of 12 functions each taking only one parameter and returns a function with 12 parameters .
 // The inverse function is [Curry12]
-func Uncurry12[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T12, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) T12 {
+func Uncurry12[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) T12) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) T12 {
 	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 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)
 	}
@@ -973,7 +973,7 @@ func Nullary13[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry13 takes a function with 13 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry13]
-func Curry13[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) T13, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](f FCT) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T13 {
+func Curry13[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) T13) func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T13 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) T13 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) T13 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) T13 {
@@ -1005,7 +1005,7 @@ func Curry13[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) T1
 
 // Uncurry13 takes a cascade of 13 functions each taking only one parameter and returns a function with 13 parameters .
 // The inverse function is [Curry13]
-func Uncurry13[FCT ~func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T13, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) T13 {
+func Uncurry13[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](f func(T0) func(T1) func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) func(T11) func(T12) T13) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) T13 {
 	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 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)(t12)
 	}
@@ -1069,7 +1069,7 @@ func Nullary14[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry14 takes a function with 14 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry14]
-func Curry14[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) T14, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](f FCT) func(T0) func(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) T14 {
+func Curry14[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) T14) func(T0) func(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) T14 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) T14 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) T14 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) T14 {
@@ -1103,7 +1103,7 @@ func Curry14[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T1
 
 // Uncurry14 takes a cascade of 14 functions each taking only one parameter and returns a function with 14 parameters .
 // The inverse function is [Curry14]
-func Uncurry14[FCT ~func(T0) func(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) T14, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) T14 {
+func Uncurry14[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](f func(T0) func(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) T14) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) T14 {
 	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 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)(t12)(t13)
 	}
@@ -1168,7 +1168,7 @@ func Nullary15[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry15 takes a function with 15 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry15]
-func Curry15[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) T15, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](f FCT) func(T0) func(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) T15 {
+func Curry15[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) T15) func(T0) func(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) T15 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) T15 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) T15 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) T15 {
@@ -1204,7 +1204,7 @@ func Curry15[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T1
 
 // Uncurry15 takes a cascade of 15 functions each taking only one parameter and returns a function with 15 parameters .
 // The inverse function is [Curry15]
-func Uncurry15[FCT ~func(T0) func(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) T15, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) T15 {
+func Uncurry15[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](f func(T0) func(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) T15) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) T15 {
 	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) T15 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)(t12)(t13)(t14)
 	}
@@ -1270,7 +1270,7 @@ func Nullary16[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry16 takes a function with 16 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry16]
-func Curry16[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) T16, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 any](f FCT) func(T0) func(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) T16 {
+func Curry16[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) T16) func(T0) func(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) T16 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) T16 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) T16 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) T16 {
@@ -1308,7 +1308,7 @@ func Curry16[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T1
 
 // Uncurry16 takes a cascade of 16 functions each taking only one parameter and returns a function with 16 parameters .
 // The inverse function is [Curry16]
-func Uncurry16[FCT ~func(T0) func(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) T16, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) T16 {
+func Uncurry16[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 any](f func(T0) func(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) T16) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) T16 {
 	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, t15 T15) T16 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)(t12)(t13)(t14)(t15)
 	}
@@ -1375,7 +1375,7 @@ func Nullary17[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry17 takes a function with 17 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry17]
-func Curry17[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) T17, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 any](f FCT) func(T0) func(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) func(T16) T17 {
+func Curry17[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) T17) func(T0) func(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) func(T16) T17 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) T17 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) T17 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) T17 {
@@ -1415,7 +1415,7 @@ func Curry17[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T1
 
 // Uncurry17 takes a cascade of 17 functions each taking only one parameter and returns a function with 17 parameters .
 // The inverse function is [Curry17]
-func Uncurry17[FCT ~func(T0) func(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) func(T16) T17, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) T17 {
+func Uncurry17[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 any](f func(T0) func(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) func(T16) T17) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) T17 {
 	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, t15 T15, t16 T16) T17 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)(t12)(t13)(t14)(t15)(t16)
 	}
@@ -1483,7 +1483,7 @@ func Nullary18[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry18 takes a function with 18 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry18]
-func Curry18[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) T18, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 any](f FCT) func(T0) func(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) func(T16) func(T17) T18 {
+func Curry18[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) T18) func(T0) func(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) func(T16) func(T17) T18 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) T18 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) T18 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) T18 {
@@ -1525,7 +1525,7 @@ func Curry18[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T1
 
 // Uncurry18 takes a cascade of 18 functions each taking only one parameter and returns a function with 18 parameters .
 // The inverse function is [Curry18]
-func Uncurry18[FCT ~func(T0) func(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) func(T16) func(T17) T18, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) T18 {
+func Uncurry18[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 any](f func(T0) func(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) func(T16) func(T17) T18) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) T18 {
 	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, t15 T15, t16 T16, t17 T17) T18 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)(t12)(t13)(t14)(t15)(t16)(t17)
 	}
@@ -1594,7 +1594,7 @@ func Nullary19[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry19 takes a function with 19 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry19]
-func Curry19[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) T19, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 any](f FCT) func(T0) func(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) func(T16) func(T17) func(T18) T19 {
+func Curry19[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) T19) func(T0) func(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) func(T16) func(T17) func(T18) T19 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) func(t18 T18) T19 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) func(t18 T18) T19 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) func(t18 T18) T19 {
@@ -1638,7 +1638,7 @@ func Curry19[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T1
 
 // Uncurry19 takes a cascade of 19 functions each taking only one parameter and returns a function with 19 parameters .
 // The inverse function is [Curry19]
-func Uncurry19[FCT ~func(T0) func(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) func(T16) func(T17) func(T18) T19, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 any](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) T19 {
+func Uncurry19[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 any](f func(T0) func(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) func(T16) func(T17) func(T18) T19) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) T19 {
 	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, t15 T15, t16 T16, t17 T17, t18 T18) T19 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)(t12)(t13)(t14)(t15)(t16)(t17)(t18)
 	}
@@ -1708,7 +1708,7 @@ func Nullary20[F1 ~func() T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 
 // Curry20 takes a function with 20 parameters and returns a cascade of functions each taking only one parameter.
 // The inverse function is [Uncurry20]
-func Curry20[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) T20, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 any](f FCT) func(T0) func(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) func(T16) func(T17) func(T18) func(T19) T20 {
+func Curry20[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) T20) func(T0) func(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) func(T16) func(T17) func(T18) func(T19) T20 {
 	return func(t0 T0) func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) func(t18 T18) func(t19 T19) T20 {
 		return func(t1 T1) func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) func(t18 T18) func(t19 T19) T20 {
 			return func(t2 T2) func(t3 T3) func(t4 T4) func(t5 T5) func(t6 T6) func(t7 T7) func(t8 T8) func(t9 T9) func(t10 T10) func(t11 T11) func(t12 T12) func(t13 T13) func(t14 T14) func(t15 T15) func(t16 T16) func(t17 T17) func(t18 T18) func(t19 T19) T20 {
@@ -1754,7 +1754,7 @@ func Curry20[FCT ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T1
 
 // Uncurry20 takes a cascade of 20 functions each taking only one parameter and returns a function with 20 parameters .
 // The inverse function is [Curry20]
-func Uncurry20[FCT ~func(T0) func(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) func(T16) func(T17) func(T18) 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](f FCT) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) T20 {
+func Uncurry20[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 any](f func(T0) func(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) func(T16) func(T17) func(T18) func(T19) T20) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) T20 {
 	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, t15 T15, t16 T16, t17 T17, t18 T18, t19 T19) T20 {
 		return f(t0)(t1)(t2)(t3)(t4)(t5)(t6)(t7)(t8)(t9)(t10)(t11)(t12)(t13)(t14)(t15)(t16)(t17)(t18)(t19)
 	}

go.mod

@@ -4,7 +4,7 @@ go 1.20
 
 require (
 	github.com/stretchr/testify v1.8.4
-	github.com/urfave/cli/v2 v2.26.0
+	github.com/urfave/cli/v2 v2.25.7
 )
 
 require (

go.sum

@@ -10,8 +10,6 @@ github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcU
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/urfave/cli/v2 v2.25.7 h1:VAzn5oq403l5pHjc4OhD54+XGO9cdKVL/7lDjF+iKUs=
 github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=
-github.com/urfave/cli/v2 v2.26.0 h1:3f3AMg3HpThFNT4I++TKOejZO8yU55t3JnnSr4S4QEI=
-github.com/urfave/cli/v2 v2.26.0/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=
 github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU=
 github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=

http/content/content.go

@@ -1,22 +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 content
-
-const (
-	TextPlain   = "text/plain"
-	Json        = "application/json"
-	FormEncoded = "application/x-www-form-urlencoded"
-)

http/form/form.go

@@ -1,70 +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 form
-
-import (
-	"net/url"
-
-	A "github.com/IBM/fp-go/array"
-	ENDO "github.com/IBM/fp-go/endomorphism"
-	F "github.com/IBM/fp-go/function"
-	L "github.com/IBM/fp-go/optics/lens"
-	LA "github.com/IBM/fp-go/optics/lens/array"
-	LRG "github.com/IBM/fp-go/optics/lens/record/generic"
-	O "github.com/IBM/fp-go/option"
-)
-
-type (
-	// Endomorphism returns an [ENDO.Endomorphism] that transforms a form
-	Endomorphism = ENDO.Endomorphism[url.Values]
-)
-
-var (
-	// Default is the default form field
-	Default = make(url.Values)
-
-	noField = O.None[string]()
-
-	// FormMonoid is the [M.Monoid] for the [Endomorphism]
-	Monoid = ENDO.Monoid[url.Values]()
-
-	// AtValues is a [L.Lens] that focusses on the values of a form field
-	AtValues = LRG.AtRecord[url.Values, []string]
-
-	composeHead = F.Pipe1(
-		LA.AtHead[string](),
-		L.ComposeOptions[url.Values, string](A.Empty[string]()),
-	)
-
-	// AtValue is a [L.Lens] that focusses on first value in form fields
-	AtValue = F.Flow2(
-		AtValues,
-		composeHead,
-	)
-)
-
-// WithValue creates a [FormBuilder] for a certain field
-func WithValue(name string) func(value string) Endomorphism {
-	return F.Flow2(
-		O.Of[string],
-		AtValue(name).Set,
-	)
-}
-
-// WithoutValue creates a [FormBuilder] that removes a field
-func WithoutValue(name string) Endomorphism {
-	return AtValue(name).Set(noField)
-}

http/form/form_test.go

@@ -1,93 +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 form
-
-import (
-	"net/url"
-	"testing"
-
-	A "github.com/IBM/fp-go/array"
-	"github.com/IBM/fp-go/eq"
-	F "github.com/IBM/fp-go/function"
-	LT "github.com/IBM/fp-go/optics/lens/testing"
-	O "github.com/IBM/fp-go/option"
-	RG "github.com/IBM/fp-go/record/generic"
-	S "github.com/IBM/fp-go/string"
-	"github.com/stretchr/testify/assert"
-)
-
-var (
-	sEq      = eq.FromEquals(S.Eq)
-	valuesEq = RG.Eq[url.Values](A.Eq(sEq))
-)
-
-func TestLaws(t *testing.T) {
-	name := "Content-Type"
-	fieldLaws := LT.AssertLaws[url.Values, O.Option[string]](t, O.Eq(sEq), valuesEq)(AtValue(name))
-
-	n := O.None[string]()
-	s1 := O.Some("s1")
-
-	v1 := F.Pipe1(
-		Default,
-		WithValue(name)("v1"),
-	)
-
-	v2 := F.Pipe1(
-		Default,
-		WithValue("Other-Header")("v2"),
-	)
-
-	assert.True(t, fieldLaws(Default, n))
-	assert.True(t, fieldLaws(v1, n))
-	assert.True(t, fieldLaws(v2, n))
-
-	assert.True(t, fieldLaws(Default, s1))
-	assert.True(t, fieldLaws(v1, s1))
-	assert.True(t, fieldLaws(v2, s1))
-}
-
-func TestFormField(t *testing.T) {
-
-	v1 := F.Pipe1(
-		Default,
-		WithValue("h1")("v1"),
-	)
-
-	v2 := F.Pipe1(
-		v1,
-		WithValue("h2")("v2"),
-	)
-
-	// make sure the code does not change structures
-	assert.False(t, valuesEq.Equals(Default, v1))
-	assert.False(t, valuesEq.Equals(Default, v2))
-	assert.False(t, valuesEq.Equals(v1, v2))
-
-	// check for existence of values
-	assert.Equal(t, "v1", v1.Get("h1"))
-	assert.Equal(t, "v1", v2.Get("h1"))
-	assert.Equal(t, "v2", v2.Get("h2"))
-
-	// check getter on lens
-
-	l1 := AtValue("h1")
-	l2 := AtValue("h2")
-
-	assert.Equal(t, O.Of("v1"), l1.Get(v1))
-	assert.Equal(t, O.Of("v1"), l1.Get(v2))
-	assert.Equal(t, O.Of("v2"), l2.Get(v2))
-}

http/headers/headers.go

@@ -1,24 +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 headers
-
-// HTTP headers
-const (
-	Accept        = "Accept"
-	Authorization = "Authorization"
-	ContentType   = "Content-Type"
-	ContentLength = "Content-Length"
-)

http/utils_test.go

@@ -20,7 +20,6 @@ import (
 
 	E "github.com/IBM/fp-go/either"
 	F "github.com/IBM/fp-go/function"
-	C "github.com/IBM/fp-go/http/content"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -39,7 +38,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("application/json"),
 		NoError[ParsedMediaType](t),
 	)
 

internal/eithert/either.go

@@ -32,17 +32,6 @@ func MonadAlt[LAZY ~func() HKTFA, E, A, HKTFA any](
 	return fchain(first, ET.Fold(F.Ignore1of1[E](second), F.Flow2(ET.Of[E, A], fof)))
 }
 
-func Alt[LAZY ~func() HKTFA, E, A, HKTFA any](
-	fof func(ET.Either[E, A]) HKTFA,
-	fchain func(HKTFA, func(ET.Either[E, A]) HKTFA) HKTFA,
-
-	second LAZY) func(HKTFA) HKTFA {
-
-	return func(fa HKTFA) HKTFA {
-		return MonadAlt(fof, fchain, fa, second)
-	}
-}
-
 // HKTFA = HKT<F, Either<E, A>>
 // HKTFB = HKT<F, Either<E, B>>
 func MonadMap[E, A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(ET.Either[E, A]) ET.Either[E, B]) HKTFB, fa HKTFA, f func(A) B) HKTFB {

internal/optiont/option.go

@@ -49,16 +49,6 @@ func MonadChain[A, B, HKTFA, HKTFB any](
 	return fchain(ma, O.Fold(F.Nullary2(O.None[B], fof), f))
 }
 
-func Chain[A, B, HKTFA, HKTFB any](
-	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 func(ma HKTFA) HKTFB {
-		return MonadChain(fchain, fof, ma, f)
-	}
-}
-
 func MonadAp[A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
 	fap func(HKTFGAB, HKTFA) HKTFB,
 	fmap func(HKTFAB, func(O.Option[func(A) B]) func(O.Option[A]) O.Option[B]) HKTFGAB,
@@ -88,24 +78,3 @@ func MonadChainOptionK[A, B, HKTA, HKTB any](
 ) HKTB {
 	return MonadChain(fchain, fof, ma, 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,
-
-	first HKTFA,
-	second LAZY) HKTFA {
-
-	return fchain(first, O.Fold(second, F.Flow2(O.Of[A], fof)))
-}
-
-func Alt[LAZY ~func() HKTFA, A, HKTFA any](
-	fof func(O.Option[A]) HKTFA,
-	fchain func(HKTFA, func(O.Option[A]) HKTFA) HKTFA,
-
-	second LAZY) func(HKTFA) HKTFA {
-
-	return func(fa HKTFA) HKTFA {
-		return MonadAlt(fof, fchain, fa, second)
-	}
-}

io/generic/ap.go

@@ -16,7 +16,6 @@
 package generic
 
 import (
-	F "github.com/IBM/fp-go/function"
 	G "github.com/IBM/fp-go/internal/apply"
 )
 
@@ -28,10 +27,7 @@ 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 MakeIO[GB](func() B {
-		return F.Pipe1(
-			ma(),
-			mab(),
-		)
+		return mab()(ma())
 	})
 }
 

io/generic/resource.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 generic
-
-import (
-	F "github.com/IBM/fp-go/function"
-)
-
-// WithResource constructs a function that creates a resource, then operates on it and then releases the resource
-func WithResource[
-	GA ~func() A,
-	GR ~func() R,
-	GANY ~func() ANY,
-	R, A, ANY any](onCreate GR, onRelease func(R) GANY) func(func(R) GA) GA {
-	// simply map to implementation of bracket
-	return F.Bind13of3(Bracket[GR, GA, GANY, R, A, ANY])(onCreate, F.Ignore2of2[A](onRelease))
-}

io/resource.go

@@ -1,27 +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 io
-
-import (
-	G "github.com/IBM/fp-go/io/generic"
-)
-
-// WithResource constructs a function that creates a resource, then operates on it and then releases the resource
-func WithResource[
-	R, A, ANY any](onCreate IO[R], onRelease func(R) IO[ANY]) func(func(R) IO[A]) IO[A] {
-	// just dispatch
-	return G.WithResource[IO[A], IO[R], IO[ANY]](onCreate, onRelease)
-}

ioeither/generic/ioeither.go

@@ -275,27 +275,6 @@ func ChainFirstIOK[GA ~func() ET.Either[E, A], GIOB ~func() B, E, A, B any](f fu
 	)
 }
 
-// MonadChainFirstEitherK runs the monad returned by the function but returns the result of the original monad
-func MonadChainFirstEitherK[GA ~func() ET.Either[E, A], E, A, B any](first GA, f func(A) ET.Either[E, B]) GA {
-	return FE.MonadChainFirstEitherK(
-		MonadChain[GA, GA, E, A, A],
-		MonadMap[func() ET.Either[E, B], GA, E, B, A],
-		FromEither[func() ET.Either[E, B], E, B],
-		first,
-		f,
-	)
-}
-
-// ChainFirstEitherK runs the monad returned by the function but returns the result of the original monad
-func ChainFirstEitherK[GA ~func() ET.Either[E, A], E, A, B any](f func(A) ET.Either[E, B]) func(GA) GA {
-	return FE.ChainFirstEitherK(
-		MonadChain[GA, GA, E, A, A],
-		MonadMap[func() ET.Either[E, B], GA, E, B, A],
-		FromEither[func() ET.Either[E, B], E, B],
-		f,
-	)
-}
-
 // Swap changes the order of type parameters
 func Swap[GEA ~func() ET.Either[E, A], GAE ~func() ET.Either[A, E], E, A any](val GEA) GAE {
 	return MonadFold(val, Right[GAE], Left[GAE])
@@ -336,14 +315,3 @@ func MonadFlap[GEAB ~func() ET.Either[E, func(A) B], GEB ~func() ET.Either[E, B]
 func Flap[GEAB ~func() ET.Either[E, func(A) B], GEB ~func() ET.Either[E, B], E, B, A any](a A) func(GEAB) GEB {
 	return FC.Flap(MonadMap[GEAB, GEB], a)
 }
-
-func ToIOOption[GA ~func() O.Option[A], GEA ~func() ET.Either[E, A], E, A any](ioe GEA) GA {
-	return F.Pipe1(
-		ioe,
-		IO.Map[GEA, GA](ET.ToOption[E, A]),
-	)
-}
-
-func FromIOOption[GEA ~func() ET.Either[E, A], GA ~func() O.Option[A], E, A any](onNone func() E) func(ioo GA) GEA {
-	return IO.Map[GA, GEA](ET.FromOption[A](onNone))
-}

ioeither/generic/traverse.go

@@ -111,183 +111,3 @@ func TraverseRecordWithIndex[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E
 func SequenceRecord[GA ~func() ET.Either[E, A], GAS ~func() ET.Either[E, AAS], AAS ~map[K]A, GAAS ~map[K]GA, K comparable, E, A any](tas GAAS) GAS {
 	return MonadTraverseRecord[GA, GAS](tas, F.Identity[GA])
 }
-
-// MonadTraverseArraySeq transforms an array
-func MonadTraverseArraySeq[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](tas AAS, f func(A) GB) GBS {
-	return RA.MonadTraverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseArraySeq transforms an array
-func TraverseArraySeq[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](f func(A) GB) func(AAS) GBS {
-	return RA.Traverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// MonadTraverseArrayWithIndexSeq transforms an array
-func MonadTraverseArrayWithIndexSeq[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](tas AAS, f func(int, A) GB) GBS {
-	return RA.MonadTraverseWithIndex[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseArrayWithIndexSeq transforms an array
-func TraverseArrayWithIndexSeq[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](f func(int, A) GB) func(AAS) GBS {
-	return RA.TraverseWithIndex[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// SequenceArraySeq converts a homogeneous sequence of either into an either of sequence
-func SequenceArraySeq[GA ~func() ET.Either[E, A], GAS ~func() ET.Either[E, AAS], AAS ~[]A, GAAS ~[]GA, E, A any](tas GAAS) GAS {
-	return MonadTraverseArraySeq[GA, GAS](tas, F.Identity[GA])
-}
-
-// MonadTraverseRecordSeq transforms an array
-func MonadTraverseRecordSeq[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, E, A, B any](tas AAS, f func(A) GB) GBS {
-	return RR.MonadTraverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseRecordSeq transforms an array
-func TraverseRecordSeq[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, E, A, B any](f func(A) GB) func(AAS) GBS {
-	return RR.Traverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// TraverseRecordWithIndexSeq transforms an array
-func TraverseRecordWithIndexSeq[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, E, A, B any](f func(K, A) GB) func(AAS) GBS {
-	return RR.TraverseWithIndex[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// SequenceRecordSeq converts a homogeneous sequence of either into an either of sequence
-func SequenceRecordSeq[GA ~func() ET.Either[E, A], GAS ~func() ET.Either[E, AAS], AAS ~map[K]A, GAAS ~map[K]GA, K comparable, E, A any](tas GAAS) GAS {
-	return MonadTraverseRecordSeq[GA, GAS](tas, F.Identity[GA])
-}
-
-// MonadTraverseArrayPar transforms an array
-func MonadTraverseArrayPar[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](tas AAS, f func(A) GB) GBS {
-	return RA.MonadTraverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseArrayPar transforms an array
-func TraverseArrayPar[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](f func(A) GB) func(AAS) GBS {
-	return RA.Traverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// MonadTraverseArrayWithIndexPar transforms an array
-func MonadTraverseArrayWithIndexPar[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](tas AAS, f func(int, A) GB) GBS {
-	return RA.MonadTraverseWithIndex[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseArrayWithIndexPar transforms an array
-func TraverseArrayWithIndexPar[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](f func(int, A) GB) func(AAS) GBS {
-	return RA.TraverseWithIndex[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// SequenceArrayPar converts a homogeneous sequence of either into an either of sequence
-func SequenceArrayPar[GA ~func() ET.Either[E, A], GAS ~func() ET.Either[E, AAS], AAS ~[]A, GAAS ~[]GA, E, A any](tas GAAS) GAS {
-	return MonadTraverseArrayPar[GA, GAS](tas, F.Identity[GA])
-}
-
-// MonadTraverseRecordPar transforms an array
-func MonadTraverseRecordPar[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, E, A, B any](tas AAS, f func(A) GB) GBS {
-	return RR.MonadTraverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseRecordPar transforms an array
-func TraverseRecordPar[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, E, A, B any](f func(A) GB) func(AAS) GBS {
-	return RR.Traverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// TraverseRecordWithIndexPar transforms an array
-func TraverseRecordWithIndexPar[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, E, A, B any](f func(K, A) GB) func(AAS) GBS {
-	return RR.TraverseWithIndex[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// SequenceRecordPar converts a homogeneous sequence of either into an either of sequence
-func SequenceRecordPar[GA ~func() ET.Either[E, A], GAS ~func() ET.Either[E, AAS], AAS ~map[K]A, GAAS ~map[K]GA, K comparable, E, A any](tas GAAS) GAS {
-	return MonadTraverseRecordPar[GA, GAS](tas, F.Identity[GA])
-}

ioeither/http/builder/builder.go

@@ -1,265 +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 builder
-
-import (
-	"bytes"
-	"net/http"
-	"net/url"
-	"strconv"
-
-	ENDO "github.com/IBM/fp-go/endomorphism"
-	F "github.com/IBM/fp-go/function"
-	C "github.com/IBM/fp-go/http/content"
-	H "github.com/IBM/fp-go/http/headers"
-	IOE "github.com/IBM/fp-go/ioeither"
-	IOEH "github.com/IBM/fp-go/ioeither/http"
-	J "github.com/IBM/fp-go/json"
-	LZ "github.com/IBM/fp-go/lazy"
-	L "github.com/IBM/fp-go/optics/lens"
-	O "github.com/IBM/fp-go/option"
-	S "github.com/IBM/fp-go/string"
-)
-
-type (
-	Builder struct {
-		method  O.Option[string]
-		url     string
-		headers http.Header
-		body    O.Option[IOE.IOEither[error, []byte]]
-	}
-
-	// Endomorphism returns an [ENDO.Endomorphism] that transforms a builder
-	Endomorphism = ENDO.Endomorphism[*Builder]
-)
-
-var (
-	// Default is the default builder
-	Default = &Builder{method: O.Some(defaultMethod()), headers: make(http.Header), body: noBody}
-
-	defaultMethod = F.Constant(http.MethodGet)
-
-	// Monoid is the [M.Monoid] for the [Endomorphism]
-	Monoid = ENDO.Monoid[*Builder]()
-
-	// Url is a [L.Lens] for the URL
-	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
-	Body = L.MakeLensRef((*Builder).GetBody, (*Builder).SetBody)
-	// Headers is a [L.Lens] for the complete set of request headers
-	Headers = L.MakeLensRef((*Builder).GetHeaders, (*Builder).SetHeaders)
-
-	getHeader = F.Bind2of2((*Builder).GetHeader)
-	delHeader = F.Bind2of2((*Builder).DelHeader)
-	setHeader = F.Bind2of3((*Builder).SetHeader)
-
-	noHeader = O.None[string]()
-	noBody   = O.None[IOE.IOEither[error, []byte]]()
-
-	// WithMethod creates a [BuilderBuilder] for a certain method
-	WithMethod = Method.Set
-	// WithUrl creates a [BuilderBuilder] for a certain method
-	WithUrl = Url.Set
-	// WithHeaders creates a [BuilderBuilder] for a set of headers
-	WithHeaders = Headers.Set
-	// WithBody creates a [BuilderBuilder] for a request body
-	WithBody = F.Flow2(
-		O.Of[IOE.IOEither[error, []byte]],
-		Body.Set,
-	)
-	// WithContentType adds the [H.ContentType] header
-	WithContentType = WithHeader(H.ContentType)
-	// WithAuthorization adds the [H.Authorization] header
-	WithAuthorization = WithHeader(H.Authorization)
-
-	// WithGet adds the [http.MethodGet] method
-	WithGet = WithMethod(http.MethodGet)
-	// WithPost adds the [http.MethodPost] method
-	WithPost = WithMethod(http.MethodPost)
-	// WithPut adds the [http.MethodPut] method
-	WithPut = WithMethod(http.MethodPut)
-	// WithDelete adds the [http.MethodDelete] method
-	WithDelete = WithMethod(http.MethodDelete)
-
-	// WithBearer creates a [BuilderBuilder] to add a Bearer [H.Authorization] header
-	WithBearer = F.Flow2(
-		S.Format[string]("Bearer %s"),
-		WithAuthorization,
-	)
-
-	// Requester creates a requester from a builder
-	Requester = (*Builder).Requester
-
-	// WithoutBody creates a [BuilderBuilder] to remove the body
-	WithoutBody = F.Pipe1(
-		noBody,
-		Body.Set,
-	)
-)
-
-func (builder *Builder) clone() *Builder {
-	cpy := *builder
-	cpy.headers = cpy.headers.Clone()
-	return &cpy
-}
-
-func (builder *Builder) GetUrl() string {
-	return builder.url
-}
-
-func (builder *Builder) GetMethod() string {
-	return F.Pipe1(
-		builder.method,
-		O.GetOrElse(defaultMethod),
-	)
-}
-
-func (builder *Builder) GetHeaders() http.Header {
-	return builder.headers
-}
-
-func (builder *Builder) GetBody() O.Option[IOE.IOEither[error, []byte]] {
-	return builder.body
-}
-
-func (builder *Builder) SetMethod(method string) *Builder {
-	builder.method = O.Some(method)
-	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
-}
-
-func (builder *Builder) SetBody(body O.Option[IOE.IOEither[error, []byte]]) *Builder {
-	builder.body = body
-	return builder
-}
-
-func (builder *Builder) SetHeader(name, value string) *Builder {
-	builder.headers.Set(name, value)
-	return builder
-}
-
-func (builder *Builder) DelHeader(name string) *Builder {
-	builder.headers.Del(name)
-	return builder
-}
-
-func (builder *Builder) GetHeader(name string) O.Option[string] {
-	return F.Pipe2(
-		name,
-		builder.headers.Get,
-		O.FromPredicate(S.IsNonEmpty),
-	)
-}
-
-func (builder *Builder) GetHeaderValues(name string) []string {
-	return builder.headers.Values(name)
-}
-
-func (builder *Builder) AddHeaderHeader(name, value string) *Builder {
-	builder.headers.Add(name, value)
-	return builder
-}
-
-func (builder *Builder) Requester() IOEH.Requester {
-	return F.Pipe3(
-		builder.GetBody(),
-		O.Map(IOE.Map[error](bytes.NewReader)),
-		O.GetOrElse(F.Constant(IOE.Of[error, *bytes.Reader](nil))),
-		IOE.Chain(func(rdr *bytes.Reader) IOE.IOEither[error, *http.Request] {
-			return IOE.TryCatchError(func() (*http.Request, error) {
-				req, err := http.NewRequest(builder.GetMethod(), builder.GetUrl(), rdr)
-				if err == nil {
-					for name, value := range builder.GetHeaders() {
-						req.Header[name] = value
-					}
-					if rdr != nil {
-						req.Header.Set(H.ContentLength, strconv.FormatInt(rdr.Size(), 10))
-					}
-				}
-				return req, err
-			})
-		}),
-	)
-}
-
-// Header returns a [L.Lens] for a single header
-func Header(name string) L.Lens[*Builder, O.Option[string]] {
-	get := getHeader(name)
-	set := F.Bind1of2(setHeader(name))
-	del := F.Flow2(
-		LZ.Of[*Builder],
-		LZ.Map(delHeader(name)),
-	)
-
-	return L.MakeLens(get, func(b *Builder, value O.Option[string]) *Builder {
-		cpy := b.clone()
-		return F.Pipe1(
-			value,
-			O.Fold(del(cpy), set(cpy)),
-		)
-	})
-}
-
-// WithHeader creates a [BuilderBuilder] for a certain header
-func WithHeader(name string) func(value string) Endomorphism {
-	return F.Flow2(
-		O.Of[string],
-		Header(name).Set,
-	)
-}
-
-// WithoutHeader creates a [BuilderBuilder] to remove a certain header
-func WithoutHeader(name string) Endomorphism {
-	return Header(name).Set(noHeader)
-}
-
-// WithFormData creates a [BuilderBuilder] to send form data payload
-func WithFormData(value url.Values) Endomorphism {
-	return F.Flow2(
-		F.Pipe4(
-			value,
-			url.Values.Encode,
-			S.ToBytes,
-			IOE.Of[error, []byte],
-			WithBody,
-		),
-		WithContentType(C.FormEncoded),
-	)
-}
-
-// WithJson creates a [BuilderBuilder] to send JSON payload
-func WithJson[T any](data T) Endomorphism {
-	return F.Flow2(
-		F.Pipe3(
-			data,
-			J.Marshal[T],
-			IOE.FromEither[error, []byte],
-			WithBody,
-		),
-		WithContentType(C.Json),
-	)
-}

ioeither/http/builder/builder_test.go

@@ -1,53 +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 builder
-
-import (
-	"testing"
-
-	F "github.com/IBM/fp-go/function"
-	C "github.com/IBM/fp-go/http/content"
-	H "github.com/IBM/fp-go/http/headers"
-	O "github.com/IBM/fp-go/option"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestBuiler(t *testing.T) {
-
-	name := H.ContentType
-	withContentType := WithHeader(name)
-	withoutContentType := WithoutHeader(name)
-
-	b1 := F.Pipe1(
-		Default,
-		withContentType(C.Json),
-	)
-
-	b2 := F.Pipe1(
-		b1,
-		withContentType(C.TextPlain),
-	)
-
-	b3 := F.Pipe1(
-		b2,
-		withoutContentType,
-	)
-
-	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.TextPlain), b2.GetHeader(name))
-	assert.Equal(t, O.None[string](), b3.GetHeader(name))
-}

ioeither/http/di/di.go

@@ -1,32 +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 di
-
-import (
-	"net/http"
-
-	DI "github.com/IBM/fp-go/di"
-	IOE "github.com/IBM/fp-go/ioeither"
-	IOEH "github.com/IBM/fp-go/ioeither/http"
-)
-
-var (
-	// InjHttpClient is the [DI.InjectionToken] for the [http.DefaultClient]
-	InjHttpClient = DI.MakeTokenWithDefault0("HTTP_CLIENT", IOE.Of[error](http.DefaultClient))
-
-	// InjClient is the [DI.InjectionToken] for the default [IOEH.Client]
-	InjClient = DI.MakeTokenWithDefault1("CLIENT", InjHttpClient.IOEither(), IOE.Map[error](IOEH.MakeClient))
-)

ioeither/http/request.go

@@ -16,118 +16,58 @@
 package http
 
 import (
-	"bytes"
 	"io"
 	"net/http"
 
 	B "github.com/IBM/fp-go/bytes"
-	FL "github.com/IBM/fp-go/file"
+	ER "github.com/IBM/fp-go/errors"
 	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 (
-	// Requester is a reader that constructs a request
-	Requester = IOE.IOEither[error, *http.Request]
-
-	Client interface {
-		Do(Requester) IOE.IOEither[error, *http.Response]
-	}
-
-	client struct {
-		delegate *http.Client
-		doIOE    func(*http.Request) IOE.IOEither[error, *http.Response]
-	}
-)
-
-var (
-	// MakeRequest is an eitherized version of [http.NewRequest]
-	MakeRequest = IOE.Eitherize3(http.NewRequest)
-	makeRequest = F.Bind13of3(MakeRequest)
-
-	// specialize
-	MakeGetRequest = makeRequest("GET", nil)
-)
-
-// MakeBodyRequest creates a request that carries a body
-func MakeBodyRequest(method string, body IOE.IOEither[error, []byte]) func(url string) IOE.IOEither[error, *http.Request] {
-	onBody := F.Pipe1(
-		body,
-		IOE.Map[error](F.Flow2(
-			bytes.NewReader,
-			FL.ToReader[*bytes.Reader],
-		)),
-	)
-	onRelease := IOE.Of[error, io.Reader]
-	withMethod := F.Bind1of3(MakeRequest)(method)
-
-	return F.Flow2(
-		F.Bind1of2(withMethod),
-		IOE.WithResource[*http.Request](onBody, onRelease),
-	)
+type Client interface {
+	Do(req *http.Request) IOE.IOEither[error, *http.Response]
 }
 
-func (client client) Do(req Requester) IOE.IOEither[error, *http.Response] {
-	return F.Pipe1(
-		req,
-		IOE.Chain(client.doIOE),
-	)
+type client struct {
+	delegate *http.Client
+}
+
+func (client client) Do(req *http.Request) IOE.IOEither[error, *http.Response] {
+	return IOE.TryCatch(func() (*http.Response, error) {
+		return client.delegate.Do(req)
+	}, ER.IdentityError)
 }
 
 func MakeClient(httpClient *http.Client) Client {
-	return client{delegate: httpClient, doIOE: IOE.Eitherize1(httpClient.Do)}
+	return client{delegate: httpClient}
 }
 
-// ReadFullResponse sends a request,  reads the response as a byte array and represents the result as a tuple
-func ReadFullResponse(client Client) func(Requester) IOE.IOEither[error, H.FullResponse] {
-	return F.Flow3(
-		client.Do,
-		IOE.ChainEitherK(H.ValidateResponse),
-		IOE.Chain(func(resp *http.Response) IOE.IOEither[error, H.FullResponse] {
-			return F.Pipe1(
-				F.Pipe3(
-					resp,
-					H.GetBody,
-					IOE.Of[error, io.ReadCloser],
-					IOEF.ReadAll[io.ReadCloser],
-				),
-				IOE.Map[error](F.Bind1st(T.MakeTuple2[*http.Response, []byte], resp)),
-			)
-		}),
-	)
+func ReadAll(client Client) func(*http.Request) IOE.IOEither[error, []byte] {
+	return func(req *http.Request) IOE.IOEither[error, []byte] {
+		return IOEF.ReadAll(F.Pipe2(
+			req,
+			client.Do,
+			IOE.Map[error](func(resp *http.Response) io.ReadCloser {
+				return resp.Body
+			}),
+		),
+		)
+	}
 }
 
-// ReadAll sends a request and reads the response as bytes
-func ReadAll(client Client) func(Requester) IOE.IOEither[error, []byte] {
-	return F.Flow2(
-		ReadFullResponse(client),
-		IOE.Map[error](H.Body),
-	)
-}
-
-// ReadText sends a request, reads the response and represents the response as a text string
-func ReadText(client Client) func(Requester) IOE.IOEither[error, string] {
+func ReadText(client Client) func(*http.Request) IOE.IOEither[error, string] {
 	return F.Flow2(
 		ReadAll(client),
 		IOE.Map[error](B.ToString),
 	)
 }
 
-// ReadJson sends a request, reads the response and parses the response as JSON
-func ReadJson[A any](client Client) func(Requester) IOE.IOEither[error, A] {
-	return F.Flow3(
-		ReadFullResponse(client),
-		IOE.ChainFirstEitherK(F.Flow2(
-			H.Response,
-			H.ValidateJsonResponse,
-		)),
-		IOE.ChainEitherK(F.Flow2(
-			H.Body,
-			J.Unmarshal[A],
-		)),
+func ReadJson[A any](client Client) func(*http.Request) IOE.IOEither[error, A] {
+	return F.Flow2(
+		ReadAll(client),
+		IOE.ChainEitherK(J.Unmarshal[A]),
 	)
 }

ioeither/http/retry_test.go

@@ -23,6 +23,7 @@ import (
 
 	AR "github.com/IBM/fp-go/array"
 	E "github.com/IBM/fp-go/either"
+	HE "github.com/IBM/fp-go/either/http"
 	"github.com/IBM/fp-go/errors"
 	F "github.com/IBM/fp-go/function"
 	IOE "github.com/IBM/fp-go/ioeither"
@@ -52,9 +53,10 @@ func TestRetryHttp(t *testing.T) {
 	client := MakeClient(&http.Client{})
 
 	action := func(status R.RetryStatus) IOE.IOEither[error, *PostItem] {
-		return F.Pipe1(
-			MakeGetRequest(urls[status.IterNumber]),
-			ReadJson[*PostItem](client),
+		return F.Pipe2(
+			HE.GetRequest(urls[status.IterNumber]),
+			IOE.FromEither[error, *http.Request],
+			IOE.Chain(ReadJson[*PostItem](client)),
 		)
 	}
 

ioeither/ioeither.go

@@ -19,7 +19,6 @@ import (
 	ET "github.com/IBM/fp-go/either"
 	I "github.com/IBM/fp-go/io"
 	G "github.com/IBM/fp-go/ioeither/generic"
-	IOO "github.com/IBM/fp-go/iooption"
 	L "github.com/IBM/fp-go/lazy"
 	O "github.com/IBM/fp-go/option"
 )
@@ -64,10 +63,6 @@ func FromOption[A, E any](onNone func() E) func(o O.Option[A]) IOEither[E, A] {
 	return G.FromOption[IOEither[E, A]](onNone)
 }
 
-func FromIOOption[A, E any](onNone func() E) func(o IOO.IOOption[A]) IOEither[E, A] {
-	return G.FromIOOption[IOEither[E, A], IOO.IOOption[A]](onNone)
-}
-
 func ChainOptionK[A, B, E any](onNone func() E) func(func(A) O.Option[B]) func(IOEither[E, A]) IOEither[E, B] {
 	return G.ChainOptionK[IOEither[E, A], IOEither[E, B]](onNone)
 }
@@ -197,12 +192,12 @@ func GetOrElse[E, A any](onLeft func(E) I.IO[A]) func(IOEither[E, A]) I.IO[A] {
 }
 
 // MonadChainTo composes to the second monad ignoring the return value of the first
-func MonadChainTo[A, E, B any](fa IOEither[E, A], fb IOEither[E, B]) IOEither[E, B] {
+func MonadChainTo[E, A, B any](fa IOEither[E, A], fb IOEither[E, B]) IOEither[E, B] {
 	return G.MonadChainTo(fa, fb)
 }
 
 // ChainTo composes to the second [IOEither] monad ignoring the return value of the first
-func ChainTo[A, E, B any](fb IOEither[E, B]) func(IOEither[E, A]) IOEither[E, B] {
+func ChainTo[E, A, B any](fb IOEither[E, B]) func(IOEither[E, A]) IOEither[E, B] {
 	return G.ChainTo[IOEither[E, A]](fb)
 }
 
@@ -216,14 +211,6 @@ func ChainFirst[E, A, B any](f func(A) IOEither[E, B]) func(IOEither[E, A]) IOEi
 	return G.ChainFirst[IOEither[E, A]](f)
 }
 
-func MonadChainFirstEitherK[A, E, B any](ma IOEither[E, A], f func(A) ET.Either[E, B]) IOEither[E, A] {
-	return G.MonadChainFirstEitherK[IOEither[E, A]](ma, f)
-}
-
-func ChainFirstEitherK[A, E, B any](f func(A) ET.Either[E, B]) func(ma IOEither[E, A]) IOEither[E, A] {
-	return G.ChainFirstEitherK[IOEither[E, A]](f)
-}
-
 // MonadChainFirstIOK runs [IO] the monad returned by the function but returns the result of the original monad
 func MonadChainFirstIOK[E, A, B any](ma IOEither[E, A], f func(A) I.IO[B]) IOEither[E, A] {
 	return G.MonadChainFirstIOK(ma, f)
@@ -271,8 +258,3 @@ func MonadFlap[E, B, A any](fab IOEither[E, func(A) B], a A) IOEither[E, B] {
 func Flap[E, B, A any](a A) func(IOEither[E, func(A) B]) IOEither[E, B] {
 	return G.Flap[IOEither[E, func(A) B], IOEither[E, B]](a)
 }
-
-// ToIOOption converts an [IOEither] to an [IOO.IOOption]
-func ToIOOption[E, A any](ioe IOEither[E, A]) IOO.IOOption[A] {
-	return G.ToIOOption[IOO.IOOption[A]](ioe)
-}

ioeither/traverse.go

@@ -48,63 +48,3 @@ func TraverseRecordWithIndex[K comparable, E, A, B any](f func(K, A) IOEither[E,
 func SequenceRecord[K comparable, E, A any](ma map[K]IOEither[E, A]) IOEither[E, map[K]A] {
 	return G.SequenceRecord[IOEither[E, A], IOEither[E, map[K]A]](ma)
 }
-
-// TraverseArraySeq transforms an array
-func TraverseArraySeq[E, A, B any](f func(A) IOEither[E, B]) func([]A) IOEither[E, []B] {
-	return G.TraverseArraySeq[IOEither[E, B], IOEither[E, []B], []A](f)
-}
-
-// TraverseArrayWithIndexSeq transforms an array
-func TraverseArrayWithIndexSeq[E, A, B any](f func(int, A) IOEither[E, B]) func([]A) IOEither[E, []B] {
-	return G.TraverseArrayWithIndexSeq[IOEither[E, B], IOEither[E, []B], []A](f)
-}
-
-// SequenceArraySeq converts a homogeneous sequence of either into an either of sequence
-func SequenceArraySeq[E, A any](ma []IOEither[E, A]) IOEither[E, []A] {
-	return G.SequenceArraySeq[IOEither[E, A], IOEither[E, []A]](ma)
-}
-
-// TraverseRecordSeq transforms a record
-func TraverseRecordSeq[K comparable, E, A, B any](f func(A) IOEither[E, B]) func(map[K]A) IOEither[E, map[K]B] {
-	return G.TraverseRecordSeq[IOEither[E, B], IOEither[E, map[K]B], map[K]A](f)
-}
-
-// TraverseRecordWithIndexSeq transforms a record
-func TraverseRecordWithIndexSeq[K comparable, E, A, B any](f func(K, A) IOEither[E, B]) func(map[K]A) IOEither[E, map[K]B] {
-	return G.TraverseRecordWithIndexSeq[IOEither[E, B], IOEither[E, map[K]B], map[K]A](f)
-}
-
-// SequenceRecordSeq converts a homogeneous sequence of either into an either of sequence
-func SequenceRecordSeq[K comparable, E, A any](ma map[K]IOEither[E, A]) IOEither[E, map[K]A] {
-	return G.SequenceRecordSeq[IOEither[E, A], IOEither[E, map[K]A]](ma)
-}
-
-// TraverseArrayPar transforms an array
-func TraverseArrayPar[E, A, B any](f func(A) IOEither[E, B]) func([]A) IOEither[E, []B] {
-	return G.TraverseArrayPar[IOEither[E, B], IOEither[E, []B], []A](f)
-}
-
-// TraverseArrayWithIndexPar transforms an array
-func TraverseArrayWithIndexPar[E, A, B any](f func(int, A) IOEither[E, B]) func([]A) IOEither[E, []B] {
-	return G.TraverseArrayWithIndexPar[IOEither[E, B], IOEither[E, []B], []A](f)
-}
-
-// SequenceArrayPar converts a homogeneous Paruence of either into an either of Paruence
-func SequenceArrayPar[E, A any](ma []IOEither[E, A]) IOEither[E, []A] {
-	return G.SequenceArrayPar[IOEither[E, A], IOEither[E, []A]](ma)
-}
-
-// TraverseRecordPar transforms a record
-func TraverseRecordPar[K comparable, E, A, B any](f func(A) IOEither[E, B]) func(map[K]A) IOEither[E, map[K]B] {
-	return G.TraverseRecordPar[IOEither[E, B], IOEither[E, map[K]B], map[K]A](f)
-}
-
-// TraverseRecordWithIndexPar transforms a record
-func TraverseRecordWithIndexPar[K comparable, E, A, B any](f func(K, A) IOEither[E, B]) func(map[K]A) IOEither[E, map[K]B] {
-	return G.TraverseRecordWithIndexPar[IOEither[E, B], IOEither[E, map[K]B], map[K]A](f)
-}
-
-// SequenceRecordPar converts a homogeneous Paruence of either into an either of Paruence
-func SequenceRecordPar[K comparable, E, A any](ma map[K]IOEither[E, A]) IOEither[E, map[K]A] {
-	return G.SequenceRecordPar[IOEither[E, A], IOEither[E, map[K]A]](ma)
-}

iooption/generic/iooption.go

@@ -20,7 +20,6 @@ import (
 
 	ET "github.com/IBM/fp-go/either"
 	F "github.com/IBM/fp-go/function"
-	C "github.com/IBM/fp-go/internal/chain"
 	FI "github.com/IBM/fp-go/internal/fromio"
 	"github.com/IBM/fp-go/internal/optiont"
 	IO "github.com/IBM/fp-go/io/generic"
@@ -65,6 +64,13 @@ func FromEither[GA ~func() O.Option[A], E, A any](e ET.Either[E, A]) GA {
 	)
 }
 
+func FromIOEither[GA ~func() O.Option[A], GEA ~func() ET.Either[E, A], E, A any](ioe GEA) GA {
+	return F.Pipe1(
+		ioe,
+		IO.Map[GEA, GA](ET.ToOption[E, A]),
+	)
+}
+
 func MonadMap[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](fa GA, f func(A) B) GB {
 	return optiont.MonadMap(IO.MonadMap[GA, GB, O.Option[A], O.Option[B]], fa, f)
 }
@@ -77,48 +83,8 @@ func MonadChain[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](fa GA,
 	return optiont.MonadChain(IO.MonadChain[GA, GB, O.Option[A], O.Option[B]], IO.MonadOf[GB, O.Option[B]], fa, f)
 }
 
-// MonadChainFirst runs the monad returned by the function but returns the result of the original monad
-func MonadChainFirst[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](ma GA, f func(A) GB) GA {
-	return C.MonadChainFirst(
-		MonadChain[GA, GA, A, A],
-		MonadMap[GB, GA, B, A],
-		ma,
-		f,
-	)
-}
-
-// ChainFirst runs the monad returned by the function but returns the result of the original monad
-func ChainFirst[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](f func(A) GB) func(GA) GA {
-	return C.ChainFirst(
-		MonadChain[GA, GA, A, A],
-		MonadMap[GB, GA, B, A],
-		f,
-	)
-}
-
-// MonadChainFirstIOK runs the monad returned by the function but returns the result of the original monad
-func MonadChainFirstIOK[GA ~func() O.Option[A], GIOB ~func() B, A, B any](first GA, f func(A) GIOB) GA {
-	return FI.MonadChainFirstIOK(
-		MonadChain[GA, GA, A, A],
-		MonadMap[func() O.Option[B], GA, B, A],
-		FromIO[func() O.Option[B], GIOB, B],
-		first,
-		f,
-	)
-}
-
-// ChainFirstIOK runs the monad returned by the function but returns the result of the original monad
-func ChainFirstIOK[GA ~func() O.Option[A], GIOB ~func() B, A, B any](f func(A) GIOB) func(GA) GA {
-	return FI.ChainFirstIOK(
-		MonadChain[GA, GA, A, A],
-		MonadMap[func() O.Option[B], GA, B, A],
-		FromIO[func() O.Option[B], GIOB, B],
-		f,
-	)
-}
-
 func Chain[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](f func(A) GB) func(GA) GB {
-	return optiont.Chain(IO.MonadChain[GA, GB, O.Option[A], O.Option[B]], IO.MonadOf[GB, O.Option[B]], f)
+	return F.Bind2nd(MonadChain[GA, GB, A, B], f)
 }
 
 func MonadChainOptionK[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](ma GA, f func(A) O.Option[B]) GB {
@@ -228,17 +194,3 @@ func Fold[GA ~func() O.Option[A], GB ~func() B, A, B any](onNone func() GB, onSo
 func Defer[GA ~func() O.Option[A], A any](gen func() GA) GA {
 	return IO.Defer[GA](gen)
 }
-
-func MonadAlt[LAZY ~func() GIOA, GIOA ~func() O.Option[A], A any](first GIOA, second LAZY) GIOA {
-	return optiont.MonadAlt(
-		IO.Of[GIOA],
-		IO.MonadChain[GIOA, GIOA],
-
-		first,
-		second,
-	)
-}
-
-func Alt[LAZY ~func() GIOA, GIOA ~func() O.Option[A], A any](second LAZY) func(GIOA) GIOA {
-	return F.Bind2nd(MonadAlt[LAZY], second)
-}

iooption/generic/resource.go

@@ -1,31 +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 generic
-
-import (
-	F "github.com/IBM/fp-go/function"
-	O "github.com/IBM/fp-go/option"
-)
-
-// WithResource constructs a function that creates a resource, then operates on it and then releases the resource
-func WithResource[
-	GA ~func() O.Option[A],
-	GR ~func() O.Option[R],
-	GANY ~func() O.Option[ANY],
-	R, A, ANY any](onCreate GR, onRelease func(R) GANY) func(func(R) GA) GA {
-	// simply map to implementation of bracket
-	return F.Bind13of3(Bracket[GR, GA, GANY, R, A, ANY])(onCreate, F.Ignore2of2[O.Option[A]](onRelease))
-}

iooption/iooption.go

@@ -18,9 +18,8 @@ package iooption
 import (
 	ET "github.com/IBM/fp-go/either"
 	I "github.com/IBM/fp-go/io"
-	IO "github.com/IBM/fp-go/io"
+	IOE "github.com/IBM/fp-go/ioeither"
 	G "github.com/IBM/fp-go/iooption/generic"
-	L "github.com/IBM/fp-go/lazy"
 	O "github.com/IBM/fp-go/option"
 )
 
@@ -130,37 +129,12 @@ func Defer[A any](gen func() IOOption[A]) IOOption[A] {
 	return G.Defer[IOOption[A]](gen)
 }
 
+// FromIOEither converts an [IOEither] into an [IOOption]
+func FromIOEither[E, A any](ioe IOE.IOEither[E, A]) IOOption[A] {
+	return G.FromIOEither[IOOption[A]](ioe)
+}
+
 // FromEither converts an [Either] into an [IOOption]
 func FromEither[E, A any](e ET.Either[E, A]) IOOption[A] {
 	return G.FromEither[IOOption[A]](e)
 }
-
-// MonadAlt identifies an associative operation on a type constructor
-func MonadAlt[A any](first IOOption[A], second L.Lazy[IOOption[A]]) IOOption[A] {
-	return G.MonadAlt(first, second)
-}
-
-// Alt identifies an associative operation on a type constructor
-func Alt[A any](second L.Lazy[IOOption[A]]) func(IOOption[A]) IOOption[A] {
-	return G.Alt(second)
-}
-
-// MonadChainFirst runs the monad returned by the function but returns the result of the original monad
-func MonadChainFirst[A, B any](ma IOOption[A], f func(A) IOOption[B]) IOOption[A] {
-	return G.MonadChainFirst[IOOption[A], IOOption[B]](ma, f)
-}
-
-// ChainFirst runs the monad returned by the function but returns the result of the original monad
-func ChainFirst[A, B any](f func(A) IOOption[B]) func(IOOption[A]) IOOption[A] {
-	return G.ChainFirst[IOOption[A], IOOption[B]](f)
-}
-
-// MonadChainFirstIOK runs the monad returned by the function but returns the result of the original monad
-func MonadChainFirstIOK[A, B any](first IOOption[A], f func(A) IO.IO[B]) IOOption[A] {
-	return G.MonadChainFirstIOK[IOOption[A], IO.IO[B]](first, f)
-}
-
-// ChainFirstIOK runs the monad returned by the function but returns the result of the original monad
-func ChainFirstIOK[A, B any](f func(A) IO.IO[B]) func(IOOption[A]) IOOption[A] {
-	return G.ChainFirstIOK[IOOption[A], IO.IO[B]](f)
-}

iooption/resource.go

@@ -1,27 +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 iooption
-
-import (
-	G "github.com/IBM/fp-go/iooption/generic"
-)
-
-// WithResource constructs a function that creates a resource, then operates on it and then releases the resource
-func WithResource[
-	R, A, ANY any](onCreate IOOption[R], onRelease func(R) IOOption[ANY]) func(func(R) IOOption[A]) IOOption[A] {
-	// just dispatch
-	return G.WithResource[IOOption[A], IOOption[R], IOOption[ANY]](onCreate, onRelease)
-}

iterator/stateless/uniq.go

@@ -19,13 +19,13 @@ import (
 	G "github.com/IBM/fp-go/iterator/stateless/generic"
 )
 
-// StrictUniq converts an [Iterator] of arbitrary items into an [Iterator] or unique items
+// StrictUniq converts an [Iterator] or arbitrary items into an [Iterator] or unique items
 // where uniqueness is determined by the built-in uniqueness constraint
 func StrictUniq[A comparable](as Iterator[A]) Iterator[A] {
 	return G.StrictUniq[Iterator[A]](as)
 }
 
-// Uniq converts an [Iterator] of arbitrary items into an [Iterator] or unique items
+// Uniq converts an [Iterator] or arbitrary items into an [Iterator] or unique items
 // where uniqueness is determined based on a key extractor function
 func Uniq[A any, K comparable](f func(A) K) func(as Iterator[A]) Iterator[A] {
 	return G.Uniq[Iterator[A], K](f)

optics/iso/iso.go

@@ -17,7 +17,6 @@
 package iso
 
 import (
-	EM "github.com/IBM/fp-go/endomorphism"
 	F "github.com/IBM/fp-go/function"
 )
 
@@ -53,7 +52,7 @@ func Reverse[S, A any](sa Iso[S, A]) Iso[A, S] {
 	)
 }
 
-func modify[FCT ~func(A) A, S, A any](f FCT, sa Iso[S, A], s S) S {
+func modify[S, A any](f func(A) A, sa Iso[S, A], s S) S {
 	return F.Pipe3(
 		s,
 		sa.Get,
@@ -63,8 +62,8 @@ func modify[FCT ~func(A) A, S, A any](f FCT, sa Iso[S, A], s S) S {
 }
 
 // Modify applies a transformation
-func Modify[S any, FCT ~func(A) A, A any](f FCT) func(Iso[S, A]) EM.Endomorphism[S] {
-	return EM.Curry3(modify[FCT, S, A])(f)
+func Modify[S, A any](f func(A) A) func(Iso[S, A]) func(S) S {
+	return F.Curry3(modify[S, A])(f)
 }
 
 // Wrap wraps the value

optics/iso/lens/lens.go

@@ -16,7 +16,6 @@
 package lens
 
 import (
-	EM "github.com/IBM/fp-go/endomorphism"
 	F "github.com/IBM/fp-go/function"
 	I "github.com/IBM/fp-go/optics/iso"
 	L "github.com/IBM/fp-go/optics/lens"
@@ -24,10 +23,10 @@ import (
 
 // IsoAsLens converts an `Iso` to a `Lens`
 func IsoAsLens[S, A any](sa I.Iso[S, A]) L.Lens[S, A] {
-	return L.MakeLensCurried(sa.Get, F.Flow2(sa.ReverseGet, F.Flow2(F.Constant1[S, S], EM.Of[func(S) S])))
+	return L.MakeLensCurried(sa.Get, F.Flow2(sa.ReverseGet, F.Constant1[S, S]))
 }
 
 // IsoAsLensRef converts an `Iso` to a `Lens`
 func IsoAsLensRef[S, A any](sa I.Iso[*S, A]) L.Lens[*S, A] {
-	return L.MakeLensRefCurried(sa.Get, F.Flow2(sa.ReverseGet, F.Flow2(F.Constant1[*S, *S], EM.Of[func(*S) *S])))
+	return L.MakeLensRefCurried(sa.Get, F.Flow2(sa.ReverseGet, F.Constant1[*S, *S]))
 }

optics/lens/array/generic/head.go

@@ -1,39 +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 generic
-
-import (
-	AA "github.com/IBM/fp-go/array/generic"
-	L "github.com/IBM/fp-go/optics/lens"
-	O "github.com/IBM/fp-go/option"
-)
-
-// AtHead focusses on the head of an array. The setter works as follows
-// - if the new value is none, the result will be an empty array
-// - if the new value is some and the array is empty, it creates a new array with one element
-// - if the new value is some and the array is not empty, it replaces the head
-func AtHead[AS []A, A any]() L.Lens[AS, O.Option[A]] {
-	return L.MakeLens(AA.Head[AS, A], func(as AS, a O.Option[A]) AS {
-		return O.MonadFold(a, AA.Empty[AS], func(v A) AS {
-			if AA.IsEmpty(as) {
-				return AA.Of[AS, A](v)
-			}
-			cpy := AA.Copy(as)
-			cpy[0] = v
-			return cpy
-		})
-	})
-}

optics/lens/array/head.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 array
-
-import (
-	L "github.com/IBM/fp-go/optics/lens"
-	G "github.com/IBM/fp-go/optics/lens/array/generic"
-	O "github.com/IBM/fp-go/option"
-)
-
-// AtHead focusses on the head of an array. The setter works as follows
-// - if the new value is none, the result will be an empty array
-// - if the new value is some and the array is empty, it creates a new array with one element
-// - if the new value is some and the array is not empty, it replaces the head
-func AtHead[A any]() L.Lens[[]A, O.Option[A]] {
-	return G.AtHead[[]A]()
-}

optics/lens/array/head_test.go

@@ -1,40 +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 array
-
-import (
-	"testing"
-
-	A "github.com/IBM/fp-go/array"
-	"github.com/IBM/fp-go/eq"
-	LT "github.com/IBM/fp-go/optics/lens/testing"
-	O "github.com/IBM/fp-go/option"
-	S "github.com/IBM/fp-go/string"
-	"github.com/stretchr/testify/assert"
-)
-
-var (
-	sEq = eq.FromEquals(S.Eq)
-)
-
-func TestLaws(t *testing.T) {
-	headLaws := LT.AssertLaws(t, O.Eq(sEq), A.Eq(sEq))(AtHead[string]())
-
-	assert.True(t, headLaws(A.Empty[string](), O.None[string]()))
-	assert.True(t, headLaws(A.Empty[string](), O.Of("a")))
-	assert.True(t, headLaws(A.From("a", "b"), O.None[string]()))
-	assert.True(t, headLaws(A.From("a", "b"), O.Of("c")))
-}

optics/lens/lens.go

@@ -17,8 +17,8 @@
 package lens
 
 import (
-	EM "github.com/IBM/fp-go/endomorphism"
 	F "github.com/IBM/fp-go/function"
+	I "github.com/IBM/fp-go/identity"
 	O "github.com/IBM/fp-go/option"
 )
 
@@ -26,13 +26,13 @@ type (
 	// Lens is a reference to a subpart of a data type
 	Lens[S, A any] struct {
 		Get func(s S) A
-		Set func(a A) EM.Endomorphism[S]
+		Set func(a A) func(S) S
 	}
 )
 
 // setCopy wraps a setter for a pointer into a setter that first creates a copy before
 // modifying that copy
-func setCopy[SET ~func(*S, A) *S, S, A any](setter SET) func(s *S, a A) *S {
+func setCopy[S, A any](setter func(*S, A) *S) func(s *S, a A) *S {
 	return func(s *S, a A) *S {
 		copy := *s
 		return setter(&copy, a)
@@ -41,8 +41,8 @@ func setCopy[SET ~func(*S, A) *S, S, A any](setter SET) func(s *S, a A) *S {
 
 // setCopyCurried wraps a setter for a pointer into a setter that first creates a copy before
 // modifying that copy
-func setCopyCurried[SET ~func(A) EM.Endomorphism[*S], S, A any](setter SET) func(a A) EM.Endomorphism[*S] {
-	return func(a A) EM.Endomorphism[*S] {
+func setCopyCurried[S, A any](setter func(A) func(*S) *S) func(a A) func(*S) *S {
+	return func(a A) func(*S) *S {
 		seta := setter(a)
 		return func(s *S) *S {
 			copy := *s
@@ -51,53 +51,53 @@ func setCopyCurried[SET ~func(A) EM.Endomorphism[*S], S, A any](setter SET) func
 	}
 }
 
-// MakeLens creates a [Lens] based on a getter and a setter function. Make sure that the setter creates a (shallow) copy of the
+// MakeLens creates a lens based on a getter and a setter function. Make sure that the setter creates a (shallow) copy of the
 // data. This happens automatically if the data is passed by value. For pointers consider to use `MakeLensRef`
 // and for other kinds of data structures that are copied by reference make sure the setter creates the copy.
-func MakeLens[GET ~func(S) A, SET ~func(S, A) S, S, A any](get GET, set SET) Lens[S, A] {
-	return MakeLensCurried(get, EM.Curry2(F.Swap(set)))
+func MakeLens[S, A any](get func(S) A, set func(S, A) S) Lens[S, A] {
+	return MakeLensCurried(get, F.Curry2(F.Swap(set)))
 }
 
-// MakeLensCurried creates a [Lens] based on a getter and a setter function. Make sure that the setter creates a (shallow) copy of the
+// MakeLensCurried creates a lens based on a getter and a setter function. Make sure that the setter creates a (shallow) copy of the
 // data. This happens automatically if the data is passed by value. For pointers consider to use `MakeLensRef`
 // and for other kinds of data structures that are copied by reference make sure the setter creates the copy.
-func MakeLensCurried[GET ~func(S) A, SET ~func(A) EM.Endomorphism[S], S, A any](get GET, set SET) Lens[S, A] {
+func MakeLensCurried[S, A any](get func(S) A, set func(A) func(S) S) Lens[S, A] {
 	return Lens[S, A]{Get: get, Set: set}
 }
 
-// MakeLensRef creates a [Lens] based on a getter and a setter function. The setter passed in does not have to create a shallow
+// MakeLensRef creates a lens based on a getter and a setter function. The setter passed in does not have to create a shallow
 // copy, the implementation wraps the setter into one that copies the pointer before modifying it
 //
-// Such a [Lens] assumes that property A of S always exists
-func MakeLensRef[GET ~func(*S) A, SET func(*S, A) *S, S, A any](get GET, set SET) Lens[*S, A] {
+// Such a lens assumes that property A of S always exists
+func MakeLensRef[S, A any](get func(*S) A, set func(*S, A) *S) Lens[*S, A] {
 	return MakeLens(get, setCopy(set))
 }
 
-// MakeLensRefCurried creates a [Lens] based on a getter and a setter function. The setter passed in does not have to create a shallow
+// MakeLensRefCurried creates a lens based on a getter and a setter function. The setter passed in does not have to create a shallow
 // copy, the implementation wraps the setter into one that copies the pointer before modifying it
 //
-// Such a [Lens] assumes that property A of S always exists
-func MakeLensRefCurried[S, A any](get func(*S) A, set func(A) EM.Endomorphism[*S]) Lens[*S, A] {
+// Such a lens assumes that property A of S always exists
+func MakeLensRefCurried[S, A any](get func(*S) A, set func(A) func(*S) *S) Lens[*S, A] {
 	return MakeLensCurried(get, setCopyCurried(set))
 }
 
-// id returns a [Lens] implementing the identity operation
-func id[GET ~func(S) S, SET ~func(S, S) S, S any](creator func(get GET, set SET) Lens[S, S]) Lens[S, S] {
+// Id returns a lens implementing the identity operation
+func id[S any](creator func(get func(S) S, set func(S, S) S) Lens[S, S]) Lens[S, S] {
 	return creator(F.Identity[S], F.Second[S, S])
 }
 
-// Id returns a [Lens] implementing the identity operation
+// Id returns a lens implementing the identity operation
 func Id[S any]() Lens[S, S] {
-	return id(MakeLens[EM.Endomorphism[S], func(S, S) S])
+	return id(MakeLens[S, S])
 }
 
-// IdRef returns a [Lens] implementing the identity operation
+// IdRef returns a lens implementing the identity operation
 func IdRef[S any]() Lens[*S, *S] {
-	return id(MakeLensRef[EM.Endomorphism[*S], func(*S, *S) *S])
+	return id(MakeLensRef[S, *S])
 }
 
 // Compose combines two lenses and allows to narrow down the focus to a sub-lens
-func compose[GET ~func(S) B, SET ~func(S, B) S, S, A, B any](creator func(get GET, set SET) Lens[S, B], ab Lens[A, B]) func(Lens[S, A]) Lens[S, B] {
+func compose[S, A, B any](creator func(get func(S) B, set func(S, B) S) Lens[S, B], ab Lens[A, B]) func(Lens[S, A]) Lens[S, B] {
 	abget := ab.Get
 	abset := ab.Set
 	return func(sa Lens[S, A]) Lens[S, B] {
@@ -114,7 +114,7 @@ func compose[GET ~func(S) B, SET ~func(S, B) S, S, A, B any](creator func(get GE
 
 // Compose combines two lenses and allows to narrow down the focus to a sub-lens
 func Compose[S, A, B any](ab Lens[A, B]) func(Lens[S, A]) Lens[S, B] {
-	return compose(MakeLens[func(S) B, func(S, B) S], ab)
+	return compose(MakeLens[S, B], ab)
 }
 
 // ComposeOption combines a `Lens` that returns an optional value with a `Lens` that returns a definite value
@@ -141,7 +141,7 @@ func ComposeOption[S, B, A any](defaultA A) func(ab Lens[A, B]) func(Lens[S, O.O
 				func(s S, ob O.Option[B]) S {
 					return F.Pipe2(
 						ob,
-						O.Fold(unseta, func(b B) EM.Endomorphism[S] {
+						O.Fold(unseta, func(b B) func(S) S {
 							setbona := F.Flow2(
 								ab.Set(b),
 								seta,
@@ -158,7 +158,7 @@ func ComposeOption[S, B, A any](defaultA A) func(ab Lens[A, B]) func(Lens[S, O.O
 								),
 							)
 						}),
-						EM.Ap(s),
+						I.Ap[S, S](s),
 					)
 				},
 			)
@@ -174,7 +174,7 @@ func ComposeOption[S, B, A any](defaultA A) func(ab Lens[A, B]) func(Lens[S, O.O
 // if the setter is called with `None[B]` and `A` does exist, 'B' is removed from 'A'
 func ComposeOptions[S, B, A any](defaultA A) func(ab Lens[A, O.Option[B]]) func(Lens[S, O.Option[A]]) Lens[S, O.Option[B]] {
 	defa := F.Constant(defaultA)
-	noops := EM.Identity[S]
+	noops := F.Constant(F.Identity[S])
 	noneb := O.None[B]()
 	return func(ab Lens[A, O.Option[B]]) func(Lens[S, O.Option[A]]) Lens[S, O.Option[B]] {
 		unsetb := ab.Set(noneb)
@@ -189,15 +189,15 @@ func ComposeOptions[S, B, A any](defaultA A) func(ab Lens[A, O.Option[B]]) func(
 					sa.Get,
 					O.Chain(ab.Get),
 				),
-				func(b O.Option[B]) EM.Endomorphism[S] {
+				func(b O.Option[B]) func(S) S {
 					return func(s S) S {
-						return O.MonadFold(b, func() EM.Endomorphism[S] {
+						return O.MonadFold(b, func() func(S) S {
 							return F.Pipe2(
 								s,
 								sa.Get,
 								O.Fold(noops, F.Flow2(unsetb, seta)),
 							)
-						}, func(b B) EM.Endomorphism[S] {
+						}, func(b B) func(S) S {
 							// sets a B onto an A
 							setb := F.Flow2(
 								ab.Set(O.Some(b)),
@@ -218,20 +218,20 @@ func ComposeOptions[S, B, A any](defaultA A) func(ab Lens[A, O.Option[B]]) func(
 
 // Compose combines two lenses and allows to narrow down the focus to a sub-lens
 func ComposeRef[S, A, B any](ab Lens[A, B]) func(Lens[*S, A]) Lens[*S, B] {
-	return compose(MakeLensRef[func(*S) B, func(*S, B) *S], ab)
+	return compose(MakeLensRef[S, B], ab)
 }
 
-func modify[FCT ~func(A) A, S, A any](f FCT, sa Lens[S, A], s S) S {
+func modify[S, A any](f func(A) A, sa Lens[S, A], s S) S {
 	return sa.Set(f(sa.Get(s)))(s)
 }
 
-// Modify changes a property of a [Lens] by invoking a transformation function
+// Modify changes a property of a lens by invoking a transformation function
 // if the transformed property has not changes, the method returns the original state
-func Modify[S any, FCT ~func(A) A, A any](f FCT) func(Lens[S, A]) EM.Endomorphism[S] {
-	return EM.Curry3(modify[FCT, S, A])(f)
+func Modify[S, A any](f func(A) A) func(Lens[S, A]) func(S) S {
+	return F.Curry3(modify[S, A])(f)
 }
 
-func IMap[E any, AB ~func(A) B, BA ~func(B) A, A, B any](ab AB, ba BA) func(Lens[E, A]) Lens[E, B] {
+func IMap[E, A, B any](ab func(A) B, ba func(B) A) func(Lens[E, A]) Lens[E, B] {
 	return func(ea Lens[E, A]) Lens[E, B] {
 		return Lens[E, B]{Get: F.Flow2(ea.Get, ab), Set: F.Flow2(ba, ea.Set)}
 	}
@@ -239,7 +239,7 @@ func IMap[E any, AB ~func(A) B, BA ~func(B) A, A, B any](ab AB, ba BA) func(Lens
 
 // fromPredicate returns a `Lens` for a property accessibly as a getter and setter that can be optional
 // if the optional value is set then the nil value will be set instead
-func fromPredicate[GET ~func(S) O.Option[A], SET ~func(S, O.Option[A]) S, S, A any](creator func(get GET, set SET) Lens[S, O.Option[A]], pred func(A) bool, nilValue A) func(sa Lens[S, A]) Lens[S, O.Option[A]] {
+func fromPredicate[S, A any](creator func(get func(S) O.Option[A], set func(S, O.Option[A]) S) Lens[S, O.Option[A]], pred func(A) bool, nilValue A) func(sa Lens[S, A]) Lens[S, O.Option[A]] {
 	fromPred := O.FromPredicate(pred)
 	return func(sa Lens[S, A]) Lens[S, O.Option[A]] {
 		fold := O.Fold(F.Bind1of1(sa.Set)(nilValue), sa.Set)
@@ -247,7 +247,7 @@ func fromPredicate[GET ~func(S) O.Option[A], SET ~func(S, O.Option[A]) S, S, A a
 			return F.Pipe2(
 				a,
 				fold,
-				EM.Ap(s),
+				I.Ap[S, S](s),
 			)
 		})
 	}
@@ -256,13 +256,13 @@ func fromPredicate[GET ~func(S) O.Option[A], SET ~func(S, O.Option[A]) S, S, A a
 // FromPredicate returns a `Lens` for a property accessibly as a getter and setter that can be optional
 // if the optional value is set then the nil value will be set instead
 func FromPredicate[S, A any](pred func(A) bool, nilValue A) func(sa Lens[S, A]) Lens[S, O.Option[A]] {
-	return fromPredicate(MakeLens[func(S) O.Option[A], func(S, O.Option[A]) S], pred, nilValue)
+	return fromPredicate(MakeLens[S, O.Option[A]], pred, nilValue)
 }
 
 // FromPredicateRef returns a `Lens` for a property accessibly as a getter and setter that can be optional
 // if the optional value is set then the nil value will be set instead
 func FromPredicateRef[S, A any](pred func(A) bool, nilValue A) func(sa Lens[*S, A]) Lens[*S, O.Option[A]] {
-	return fromPredicate(MakeLensRef[func(*S) O.Option[A], func(*S, O.Option[A]) *S], pred, nilValue)
+	return fromPredicate(MakeLensRef[S, O.Option[A]], pred, nilValue)
 }
 
 // FromPredicate returns a `Lens` for a property accessibly as a getter and setter that can be optional
@@ -278,7 +278,7 @@ func FromNillableRef[S, A any](sa Lens[*S, *A]) Lens[*S, O.Option[*A]] {
 }
 
 // fromNullableProp returns a `Lens` from a property that may be optional. The getter returns a default value for these items
-func fromNullableProp[GET ~func(S) A, SET ~func(S, A) S, S, A any](creator func(get GET, set SET) Lens[S, A], isNullable func(A) O.Option[A], defaultValue A) func(sa Lens[S, A]) Lens[S, A] {
+func fromNullableProp[S, A any](creator func(get func(S) A, set func(S, A) S) Lens[S, A], isNullable func(A) O.Option[A], defaultValue A) func(sa Lens[S, A]) Lens[S, A] {
 	return func(sa Lens[S, A]) Lens[S, A] {
 		return creator(F.Flow3(
 			sa.Get,
@@ -293,16 +293,16 @@ func fromNullableProp[GET ~func(S) A, SET ~func(S, A) S, S, A any](creator func(
 
 // FromNullableProp returns a `Lens` from a property that may be optional. The getter returns a default value for these items
 func FromNullableProp[S, A any](isNullable func(A) O.Option[A], defaultValue A) func(sa Lens[S, A]) Lens[S, A] {
-	return fromNullableProp(MakeLens[func(S) A, func(S, A) S], isNullable, defaultValue)
+	return fromNullableProp(MakeLens[S, A], isNullable, defaultValue)
 }
 
 // FromNullablePropRef returns a `Lens` from a property that may be optional. The getter returns a default value for these items
 func FromNullablePropRef[S, A any](isNullable func(A) O.Option[A], defaultValue A) func(sa Lens[*S, A]) Lens[*S, A] {
-	return fromNullableProp(MakeLensRef[func(*S) A, func(*S, A) *S], isNullable, defaultValue)
+	return fromNullableProp(MakeLensRef[S, A], isNullable, defaultValue)
 }
 
 // fromFromOption returns a `Lens` from an option property. The getter returns a default value the setter will always set the some option
-func fromOption[GET ~func(S) A, SET ~func(S, A) S, S, A any](creator func(get GET, set SET) Lens[S, A], defaultValue A) func(sa Lens[S, O.Option[A]]) Lens[S, A] {
+func fromOption[S, A any](creator func(get func(S) A, set func(S, A) S) Lens[S, A], defaultValue A) func(sa Lens[S, O.Option[A]]) Lens[S, A] {
 	return func(sa Lens[S, O.Option[A]]) Lens[S, A] {
 		return creator(F.Flow2(
 			sa.Get,
@@ -316,10 +316,10 @@ func fromOption[GET ~func(S) A, SET ~func(S, A) S, S, A any](creator func(get GE
 
 // FromFromOption returns a `Lens` from an option property. The getter returns a default value the setter will always set the some option
 func FromOption[S, A any](defaultValue A) func(sa Lens[S, O.Option[A]]) Lens[S, A] {
-	return fromOption(MakeLens[func(S) A, func(S, A) S], defaultValue)
+	return fromOption(MakeLens[S, A], defaultValue)
 }
 
 // FromFromOptionRef returns a `Lens` from an option property. The getter returns a default value the setter will always set the some option
 func FromOptionRef[S, A any](defaultValue A) func(sa Lens[*S, O.Option[A]]) Lens[*S, A] {
-	return fromOption(MakeLensRef[func(*S) A, func(*S, A) *S], defaultValue)
+	return fromOption(MakeLensRef[S, A], defaultValue)
 }

optics/optional/optional.go

@@ -18,7 +18,6 @@
 package optional
 
 import (
-	EM "github.com/IBM/fp-go/endomorphism"
 	F "github.com/IBM/fp-go/function"
 	O "github.com/IBM/fp-go/option"
 )
@@ -26,12 +25,12 @@ import (
 // Optional is an optional reference to a subpart of a data type
 type Optional[S, A any] struct {
 	GetOption func(s S) O.Option[A]
-	Set       func(a A) EM.Endomorphism[S]
+	Set       func(a A) func(S) S
 }
 
 // setCopy wraps a setter for a pointer into a setter that first creates a copy before
 // modifying that copy
-func setCopy[SET ~func(*S, A) *S, S, A any](setter SET) func(s *S, a A) *S {
+func setCopy[S, A any](setter func(*S, A) *S) func(s *S, a A) *S {
 	return func(s *S, a A) *S {
 		copy := *s
 		return setter(&copy, a)
@@ -42,7 +41,7 @@ func setCopy[SET ~func(*S, A) *S, S, A any](setter SET) func(s *S, a A) *S {
 // data. This happens automatically if the data is passed by value. For pointers consider to use `MakeOptionalRef`
 // and for other kinds of data structures that are copied by reference make sure the setter creates the copy.
 func MakeOptional[S, A any](get func(S) O.Option[A], set func(S, A) S) Optional[S, A] {
-	return Optional[S, A]{GetOption: get, Set: EM.Curry2(F.Swap(set))}
+	return Optional[S, A]{GetOption: get, Set: F.Curry2(F.Swap(set))}
 }
 
 // MakeOptionalRef creates an Optional based on a getter and a setter function. The setter passed in does not have to create a shallow
@@ -169,7 +168,7 @@ func ichain[S, A, B any](sa Optional[S, A], ab func(A) O.Option[B], ba func(B) O
 	return MakeOptional(
 		F.Flow2(sa.GetOption, O.Chain(ab)),
 		func(s S, b B) S {
-			return O.MonadFold(ba(b), EM.Identity[S], sa.Set)(s)
+			return O.MonadFold(ba(b), F.Constant(F.Identity[S]), sa.Set)(s)
 		},
 	)
 }

optics/prism/prism.go

@@ -17,7 +17,6 @@
 package prism
 
 import (
-	EM "github.com/IBM/fp-go/endomorphism"
 	F "github.com/IBM/fp-go/function"
 	O "github.com/IBM/fp-go/option"
 )
@@ -87,12 +86,12 @@ func prismModify[S, A any](f func(A) A, sa Prism[S, A], s S) S {
 	)
 }
 
-func prismSet[S, A any](a A) func(Prism[S, A]) EM.Endomorphism[S] {
-	return EM.Curry3(prismModify[S, A])(F.Constant1[A](a))
+func prismSet[S, A any](a A) func(Prism[S, A]) func(S) S {
+	return F.Curry3(prismModify[S, A])(F.Constant1[A](a))
 }
 
-func Set[S, A any](a A) func(Prism[S, A]) EM.Endomorphism[S] {
-	return EM.Curry3(prismModify[S, A])(F.Constant1[A](a))
+func Set[S, A any](a A) func(Prism[S, A]) func(S) S {
+	return F.Curry3(prismModify[S, A])(F.Constant1[A](a))
 }
 
 func prismSome[A any]() Prism[O.Option[A], A] {
@@ -104,14 +103,14 @@ func Some[S, A any](soa Prism[S, O.Option[A]]) Prism[S, A] {
 	return Compose[S](prismSome[A]())(soa)
 }
 
-func imap[S any, AB ~func(A) B, BA ~func(B) A, A, B any](sa Prism[S, A], ab AB, ba BA) Prism[S, B] {
+func imap[S, A, B any](sa Prism[S, A], ab func(A) B, ba func(B) A) Prism[S, B] {
 	return MakePrism(
 		F.Flow2(sa.GetOption, O.Map(ab)),
 		F.Flow2(ba, sa.ReverseGet),
 	)
 }
 
-func IMap[S any, AB ~func(A) B, BA ~func(B) A, A, B any](ab AB, ba BA) func(Prism[S, A]) Prism[S, B] {
+func IMap[S, A, B any](ab func(A) B, ba func(B) A) func(Prism[S, A]) Prism[S, B] {
 	return func(sa Prism[S, A]) Prism[S, B] {
 		return imap(sa, ab, ba)
 	}

option/array.go

@@ -65,7 +65,7 @@ func SequenceArray[A any](ma []Option[A]) Option[[]A] {
 func CompactArrayG[A1 ~[]Option[A], A2 ~[]A, A any](fa A1) A2 {
 	return RA.Reduce(fa, func(out A2, value Option[A]) A2 {
 		return MonadFold(value, F.Constant(out), F.Bind1st(RA.Append[A2, A], out))
-	}, make(A2, 0, len(fa)))
+	}, make(A2, len(fa)))
 }
 
 // CompactArray discards the none values and keeps the some values

option/array_test.go

@@ -34,14 +34,3 @@ func TestSequenceArray(t *testing.T) {
 
 	assert.Equal(t, res, Of([]int{1, 2}))
 }
-
-func TestCompactArray(t *testing.T) {
-	ar := []Option[string]{
-		Of("ok"),
-		None[string](),
-		Of("ok"),
-	}
-
-	res := CompactArray(ar)
-	assert.Equal(t, 2, len(res))
-}

record/generic/record.go

@@ -531,12 +531,3 @@ func MonadFlap[GFAB ~map[K]func(A) B, GB ~map[K]B, K comparable, A, B any](fab G
 func Flap[GFAB ~map[K]func(A) B, GB ~map[K]B, K comparable, A, B any](a A) func(GFAB) GB {
 	return FC.Flap(MonadMap[GFAB, GB], a)
 }
-
-func Copy[M ~map[K]V, K comparable, V any](m M) M {
-	return duplicate(m)
-}
-
-func Clone[M ~map[K]V, K comparable, V any](f func(V) V) func(m M) M {
-	// impementation assumes that map does not optimize for the empty map
-	return Map[M, M](f)
-}

record/record.go

@@ -284,13 +284,3 @@ func MonadFlap[B any, K comparable, A any](fab map[K]func(A) B, a A) map[K]B {
 func Flap[B any, K comparable, A any](a A) func(map[K]func(A) B) map[K]B {
 	return G.Flap[map[K]func(A) B, map[K]B](a)
 }
-
-// Copy creates a shallow copy of the map
-func Copy[K comparable, V any](m map[K]V) map[K]V {
-	return G.Copy[map[K]V](m)
-}
-
-// Clone creates a deep copy of the map using the provided endomorphism to clone the values
-func Clone[K comparable, V any](f func(V) V) func(m map[K]V) map[K]V {
-	return G.Clone[map[K]V](f)
-}

record/record_test.go

@@ -21,7 +21,6 @@ import (
 	"strings"
 	"testing"
 
-	A "github.com/IBM/fp-go/array"
 	"github.com/IBM/fp-go/internal/utils"
 	O "github.com/IBM/fp-go/option"
 	S "github.com/IBM/fp-go/string"
@@ -132,20 +131,3 @@ func ExampleValuesOrd() {
 	// Output: [c b a]
 
 }
-
-func TestCopyVsClone(t *testing.T) {
-	slc := []string{"b", "c"}
-	src := map[string][]string{
-		"a": slc,
-	}
-	// make a shallow copy
-	cpy := Copy(src)
-	// make a deep copy
-	cln := Clone[string](A.Copy[string])(src)
-
-	assert.Equal(t, cpy, cln)
-	// make a modification to the original slice
-	slc[0] = "d"
-	assert.NotEqual(t, cpy, cln)
-	assert.Equal(t, src, cpy)
-}

samples/tuples/option_test.go

@@ -52,7 +52,7 @@ func TestIOEitherToOption2(t *testing.T) {
 		content,
 		IOEF.WriteFile(filepath.Join(tmpDir, "test.txt"), os.ModePerm),
 		IOE.Swap[error, []byte],
-		IOE.ToIOOption[[]byte, error],
+		IOO.FromIOEither[[]byte, error],
 	)
 
 	fmt.Println(resIOO())