go/fp-go
1
0
Fork 0
mirror of https://github.com/IBM/fp-go.git synced 2025-07-17 01:32:23 +02:00
Code Issues Releases Activity

fix: some cleanup

Browse Source 
Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>
This commit is contained in:
Dr. Carsten Leue
2025-03-08 15:25:32 +01:00
parent 6cffae8f89
commit 24960f87a0
35 changed files with 14203 additions and 13813 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
v2/README.md Normal file
View File

@ -0,0 +1,5 @@
# Functional programming library for golang V2
Go 1.24 introduces [generic type aliases](https://github.com/golang/go/issues/46477) which are leveraged by V2.
##

9
v2/context/ioeither/ioeither.go
View File

@ -18,11 +18,16 @@ package ioeither
import (
"context"
G "github.com/IBM/fp-go/v2/context/ioeither/generic"
"github.com/IBM/fp-go/v2/either"
IOE "github.com/IBM/fp-go/v2/ioeither"
)
// withContext wraps an existing IOEither and performs a context check for cancellation before delegating
func WithContext[A any](ctx context.Context, ma IOE.IOEither[error, A]) IOE.IOEither[error, A] {
return G.WithContext(ctx, ma)
return func() either.Either[error, A] {
if err := context.Cause(ctx); err != nil {
return either.Left[A](err)
}
return ma()
}
}

2625
v2/context/readerioeither/gen.go
View File

File diff suppressed because it is too large Load Diff

89
v2/context/readerioeither/generic/gen.go
View File

@ -4,7 +4,6 @@ package generic
// This file was generated by robots at
// 2025-03-07 23:15:45.4688315 +0100 CET m=+0.002075201
import (
"context"
@ -15,153 +14,153 @@ import (
// Eitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [GRA]
// The inverse function is [Uneitherize0]
func Eitherize0[GRA ~func(context.Context) GIOA, F ~func(context.Context) (R, error), GIOA ~func() E.Either[error, R], R any](f F) func() GRA {
return RE.Eitherize0[GRA](f)
return RE.Eitherize0[GRA](f)
}
// Uneitherize0 converts a function with 0 parameters returning a [GRA] into a function with 0 parameters returning a tuple.
// The first parameter is considered to be the [context.Context].
func Uneitherize0[GRA ~func(context.Context) GIOA, F ~func(context.Context) (R, error), GIOA ~func() E.Either[error, R], R any](f func() GRA) F {
return func(c context.Context) (R, error) {
return E.UnwrapError(f()(c)())
}
return func(c context.Context) (R, error) {
return E.UnwrapError(f()(c)())
}
}
// Eitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [GRA]
// The inverse function is [Uneitherize1]
func Eitherize1[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0) (R, error), GIOA ~func() E.Either[error, R], T0, R any](f F) func(T0) GRA {
return RE.Eitherize1[GRA](f)
return RE.Eitherize1[GRA](f)
}
// Uneitherize1 converts a function with 1 parameters returning a [GRA] into a function with 1 parameters returning a tuple.
// The first parameter is considered to be the [context.Context].
func Uneitherize1[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0) (R, error), GIOA ~func() E.Either[error, R], T0, R any](f func(T0) GRA) F {
return func(c context.Context, t0 T0) (R, error) {
return E.UnwrapError(f(t0)(c)())
}
return func(c context.Context, t0 T0) (R, error) {
return E.UnwrapError(f(t0)(c)())
}
}
// Eitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning a [GRA]
// The inverse function is [Uneitherize2]
func Eitherize2[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1) (R, error), GIOA ~func() E.Either[error, R], T0, T1, R any](f F) func(T0, T1) GRA {
return RE.Eitherize2[GRA](f)
return RE.Eitherize2[GRA](f)
}
// Uneitherize2 converts a function with 2 parameters returning a [GRA] into a function with 2 parameters returning a tuple.
// The first parameter is considered to be the [context.Context].
func Uneitherize2[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1) (R, error), GIOA ~func() E.Either[error, R], T0, T1, R any](f func(T0, T1) GRA) F {
return func(c context.Context, t0 T0, t1 T1) (R, error) {
return E.UnwrapError(f(t0, t1)(c)())
}
return func(c context.Context, t0 T0, t1 T1) (R, error) {
return E.UnwrapError(f(t0, t1)(c)())
}
}
// Eitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning a [GRA]
// The inverse function is [Uneitherize3]
func Eitherize3[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, R any](f F) func(T0, T1, T2) GRA {
return RE.Eitherize3[GRA](f)
return RE.Eitherize3[GRA](f)
}
// Uneitherize3 converts a function with 3 parameters returning a [GRA] into a function with 3 parameters returning a tuple.
// The first parameter is considered to be the [context.Context].
func Uneitherize3[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, R any](f func(T0, T1, T2) GRA) F {
return func(c context.Context, t0 T0, t1 T1, t2 T2) (R, error) {
return E.UnwrapError(f(t0, t1, t2)(c)())
}
return func(c context.Context, t0 T0, t1 T1, t2 T2) (R, error) {
return E.UnwrapError(f(t0, t1, t2)(c)())
}
}
// Eitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning a [GRA]
// The inverse function is [Uneitherize4]
func Eitherize4[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) GRA {
return RE.Eitherize4[GRA](f)
return RE.Eitherize4[GRA](f)
}
// Uneitherize4 converts a function with 4 parameters returning a [GRA] into a function with 4 parameters returning a tuple.
// The first parameter is considered to be the [context.Context].
func Uneitherize4[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, R any](f func(T0, T1, T2, T3) GRA) F {
return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3)(c)())
}
return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3)(c)())
}
}
// Eitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning a [GRA]
// The inverse function is [Uneitherize5]
func Eitherize5[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) GRA {
return RE.Eitherize5[GRA](f)
return RE.Eitherize5[GRA](f)
}
// Uneitherize5 converts a function with 5 parameters returning a [GRA] into a function with 5 parameters returning a tuple.
// The first parameter is considered to be the [context.Context].
func Uneitherize5[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, R any](f func(T0, T1, T2, T3, T4) GRA) F {
return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4)(c)())
}
return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4)(c)())
}
}
// Eitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning a [GRA]
// The inverse function is [Uneitherize6]
func Eitherize6[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, R any](f F) func(T0, T1, T2, T3, T4, T5) GRA {
return RE.Eitherize6[GRA](f)
return RE.Eitherize6[GRA](f)
}
// Uneitherize6 converts a function with 6 parameters returning a [GRA] into a function with 6 parameters returning a tuple.
// The first parameter is considered to be the [context.Context].
func Uneitherize6[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, R any](f func(T0, T1, T2, T3, T4, T5) GRA) F {
return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5)(c)())
}
return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5)(c)())
}
}
// Eitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning a [GRA]
// The inverse function is [Uneitherize7]
func Eitherize7[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) GRA {
return RE.Eitherize7[GRA](f)
return RE.Eitherize7[GRA](f)
}
// Uneitherize7 converts a function with 7 parameters returning a [GRA] into a function with 7 parameters returning a tuple.
// The first parameter is considered to be the [context.Context].
func Uneitherize7[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, R any](f func(T0, T1, T2, T3, T4, T5, T6) GRA) F {
return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6)(c)())
}
return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6)(c)())
}
}
// Eitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning a [GRA]
// The inverse function is [Uneitherize8]
func Eitherize8[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) GRA {
return RE.Eitherize8[GRA](f)
return RE.Eitherize8[GRA](f)
}
// Uneitherize8 converts a function with 8 parameters returning a [GRA] into a function with 8 parameters returning a tuple.
// The first parameter is considered to be the [context.Context].
func Uneitherize8[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7) GRA) F {
return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7)(c)())
}
return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7)(c)())
}
}
// Eitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning a [GRA]
// The inverse function is [Uneitherize9]
func Eitherize9[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA {
return RE.Eitherize9[GRA](f)
return RE.Eitherize9[GRA](f)
}
// Uneitherize9 converts a function with 9 parameters returning a [GRA] into a function with 9 parameters returning a tuple.
// The first parameter is considered to be the [context.Context].
func Uneitherize9[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA) F {
return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8)(c)())
}
return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8)(c)())
}
}
// Eitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning a [GRA]
// The inverse function is [Uneitherize10]
func Eitherize10[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA {
return RE.Eitherize10[GRA](f)
return RE.Eitherize10[GRA](f)
}
// Uneitherize10 converts a function with 10 parameters returning a [GRA] into a function with 10 parameters returning a tuple.
// The first parameter is considered to be the [context.Context].
func Uneitherize10[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA) F {
return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)(c)())
}
return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)(c)())
}
}

3185
v2/di/gen.go
View File

File diff suppressed because it is too large Load Diff

4
v2/either/core.go
View File

@ -31,7 +31,7 @@ type (
// String prints some debug info for the object
//
// go:noinline
//go:noinline
func eitherString(s *either) string {
if s.isLeft {
return fmt.Sprintf("Left[%T](%v)", s.value, s.value)
@ -41,7 +41,7 @@ func eitherString(s *either) string {
// Format prints some debug info for the object
//
// go:noinline
//go:noinline
func eitherFormat(e *either, f fmt.State, c rune) {
switch c {
case 's':

1723
v2/either/gen.go
View File

File diff suppressed because it is too large Load Diff

420
v2/function/binds.go
View File

@ -3,449 +3,453 @@
// 2025-03-07 23:15:51.1152342 +0100 CET m=+0.077222801
package function
// Combinations for a total of 1 arguments
// Bind1of1 takes a function with 1 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
// The return value of is a function with the remaining 0 parameters at positions [] of the original function.
func Bind1of1[F ~func(T1) R, T1, R any](f F) func(T1) func() R {
return func(t1 T1) func() R {
return func() R {
return f(t1)
}
}
return func(t1 T1) func() R {
return func() R {
return f(t1)
}
}
}
// Ignore1of1 takes a function with 0 parameters and returns a new function with 1 parameters that will ignore the values at positions [1] and pass the remaining 0 parameters to the original function
func Ignore1of1[T1 any, F ~func() R, R any](f F) func(T1) R {
return func(t1 T1) R {
return f()
}
return func(t1 T1) R {
return f()
}
}
// Combinations for a total of 2 arguments
// Bind1of2 takes a function with 2 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
// The return value of is a function with the remaining 1 parameters at positions [2] of the original function.
func Bind1of2[F ~func(T1, T2) R, T1, T2, R any](f F) func(T1) func(T2) R {
return func(t1 T1) func(T2) R {
return func(t2 T2) R {
return f(t1, t2)
}
}
return func(t1 T1) func(T2) R {
return func(t2 T2) R {
return f(t1, t2)
}
}
}
// Ignore1of2 takes a function with 1 parameters and returns a new function with 2 parameters that will ignore the values at positions [1] and pass the remaining 1 parameters to the original function
func Ignore1of2[T1 any, F ~func(T2) R, T2, R any](f F) func(T1, T2) R {
return func(t1 T1, t2 T2) R {
return f(t2)
}
return func(t1 T1, t2 T2) R {
return f(t2)
}
}
// Bind2of2 takes a function with 2 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [2] of the original function.
// The return value of is a function with the remaining 1 parameters at positions [1] of the original function.
func Bind2of2[F ~func(T1, T2) R, T1, T2, R any](f F) func(T2) func(T1) R {
return func(t2 T2) func(T1) R {
return func(t1 T1) R {
return f(t1, t2)
}
}
return func(t2 T2) func(T1) R {
return func(t1 T1) R {
return f(t1, t2)
}
}
}
// Ignore2of2 takes a function with 1 parameters and returns a new function with 2 parameters that will ignore the values at positions [2] and pass the remaining 1 parameters to the original function
func Ignore2of2[T2 any, F ~func(T1) R, T1, R any](f F) func(T1, T2) R {
return func(t1 T1, t2 T2) R {
return f(t1)
}
return func(t1 T1, t2 T2) R {
return f(t1)
}
}
// Bind12of2 takes a function with 2 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 2] of the original function.
// The return value of is a function with the remaining 0 parameters at positions [] of the original function.
func Bind12of2[F ~func(T1, T2) R, T1, T2, R any](f F) func(T1, T2) func() R {
return func(t1 T1, t2 T2) func() R {
return func() R {
return f(t1, t2)
}
}
return func(t1 T1, t2 T2) func() R {
return func() R {
return f(t1, t2)
}
}
}
// Ignore12of2 takes a function with 0 parameters and returns a new function with 2 parameters that will ignore the values at positions [1, 2] and pass the remaining 0 parameters to the original function
func Ignore12of2[T1, T2 any, F ~func() R, R any](f F) func(T1, T2) R {
return func(t1 T1, t2 T2) R {
return f()
}
return func(t1 T1, t2 T2) R {
return f()
}
}
// Combinations for a total of 3 arguments
// Bind1of3 takes a function with 3 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
// The return value of is a function with the remaining 2 parameters at positions [2, 3] of the original function.
func Bind1of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T1) func(T2, T3) R {
return func(t1 T1) func(T2, T3) R {
return func(t2 T2, t3 T3) R {
return f(t1, t2, t3)
}
}
return func(t1 T1) func(T2, T3) R {
return func(t2 T2, t3 T3) R {
return f(t1, t2, t3)
}
}
}
// Ignore1of3 takes a function with 2 parameters and returns a new function with 3 parameters that will ignore the values at positions [1] and pass the remaining 2 parameters to the original function
func Ignore1of3[T1 any, F ~func(T2, T3) R, T2, T3, R any](f F) func(T1, T2, T3) R {
return func(t1 T1, t2 T2, t3 T3) R {
return f(t2, t3)
}
return func(t1 T1, t2 T2, t3 T3) R {
return f(t2, t3)
}
}
// Bind2of3 takes a function with 3 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [2] of the original function.
// The return value of is a function with the remaining 2 parameters at positions [1, 3] of the original function.
func Bind2of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T2) func(T1, T3) R {
return func(t2 T2) func(T1, T3) R {
return func(t1 T1, t3 T3) R {
return f(t1, t2, t3)
}
}
return func(t2 T2) func(T1, T3) R {
return func(t1 T1, t3 T3) R {
return f(t1, t2, t3)
}
}
}
// Ignore2of3 takes a function with 2 parameters and returns a new function with 3 parameters that will ignore the values at positions [2] and pass the remaining 2 parameters to the original function
func Ignore2of3[T2 any, F ~func(T1, T3) R, T1, T3, R any](f F) func(T1, T2, T3) R {
return func(t1 T1, t2 T2, t3 T3) R {
return f(t1, t3)
}
return func(t1 T1, t2 T2, t3 T3) R {
return f(t1, t3)
}
}
// Bind3of3 takes a function with 3 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [3] of the original function.
// The return value of is a function with the remaining 2 parameters at positions [1, 2] of the original function.
func Bind3of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T3) func(T1, T2) R {
return func(t3 T3) func(T1, T2) R {
return func(t1 T1, t2 T2) R {
return f(t1, t2, t3)
}
}
return func(t3 T3) func(T1, T2) R {
return func(t1 T1, t2 T2) R {
return f(t1, t2, t3)
}
}
}
// Ignore3of3 takes a function with 2 parameters and returns a new function with 3 parameters that will ignore the values at positions [3] and pass the remaining 2 parameters to the original function
func Ignore3of3[T3 any, F ~func(T1, T2) R, T1, T2, R any](f F) func(T1, T2, T3) R {
return func(t1 T1, t2 T2, t3 T3) R {
return f(t1, t2)
}
return func(t1 T1, t2 T2, t3 T3) R {
return f(t1, t2)
}
}
// Bind12of3 takes a function with 3 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 2] of the original function.
// The return value of is a function with the remaining 1 parameters at positions [3] of the original function.
func Bind12of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T1, T2) func(T3) R {
return func(t1 T1, t2 T2) func(T3) R {
return func(t3 T3) R {
return f(t1, t2, t3)
}
}
return func(t1 T1, t2 T2) func(T3) R {
return func(t3 T3) R {
return f(t1, t2, t3)
}
}
}
// Ignore12of3 takes a function with 1 parameters and returns a new function with 3 parameters that will ignore the values at positions [1, 2] and pass the remaining 1 parameters to the original function
func Ignore12of3[T1, T2 any, F ~func(T3) R, T3, R any](f F) func(T1, T2, T3) R {
return func(t1 T1, t2 T2, t3 T3) R {
return f(t3)
}
return func(t1 T1, t2 T2, t3 T3) R {
return f(t3)
}
}
// Bind13of3 takes a function with 3 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 3] of the original function.
// The return value of is a function with the remaining 1 parameters at positions [2] of the original function.
func Bind13of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T1, T3) func(T2) R {
return func(t1 T1, t3 T3) func(T2) R {
return func(t2 T2) R {
return f(t1, t2, t3)
}
}
return func(t1 T1, t3 T3) func(T2) R {
return func(t2 T2) R {
return f(t1, t2, t3)
}
}
}
// Ignore13of3 takes a function with 1 parameters and returns a new function with 3 parameters that will ignore the values at positions [1, 3] and pass the remaining 1 parameters to the original function
func Ignore13of3[T1, T3 any, F ~func(T2) R, T2, R any](f F) func(T1, T2, T3) R {
return func(t1 T1, t2 T2, t3 T3) R {
return f(t2)
}
return func(t1 T1, t2 T2, t3 T3) R {
return f(t2)
}
}
// Bind23of3 takes a function with 3 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [2, 3] of the original function.
// The return value of is a function with the remaining 1 parameters at positions [1] of the original function.
func Bind23of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T2, T3) func(T1) R {
return func(t2 T2, t3 T3) func(T1) R {
return func(t1 T1) R {
return f(t1, t2, t3)
}
}
return func(t2 T2, t3 T3) func(T1) R {
return func(t1 T1) R {
return f(t1, t2, t3)
}
}
}
// Ignore23of3 takes a function with 1 parameters and returns a new function with 3 parameters that will ignore the values at positions [2, 3] and pass the remaining 1 parameters to the original function
func Ignore23of3[T2, T3 any, F ~func(T1) R, T1, R any](f F) func(T1, T2, T3) R {
return func(t1 T1, t2 T2, t3 T3) R {
return f(t1)
}
return func(t1 T1, t2 T2, t3 T3) R {
return f(t1)
}
}
// Bind123of3 takes a function with 3 parameters and returns a new function with 3 parameters that will bind these parameters to the positions [1, 2, 3] of the original function.
// The return value of is a function with the remaining 0 parameters at positions [] of the original function.
func Bind123of3[F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T1, T2, T3) func() R {
return func(t1 T1, t2 T2, t3 T3) func() R {
return func() R {
return f(t1, t2, t3)
}
}
return func(t1 T1, t2 T2, t3 T3) func() R {
return func() R {
return f(t1, t2, t3)
}
}
}
// Ignore123of3 takes a function with 0 parameters and returns a new function with 3 parameters that will ignore the values at positions [1, 2, 3] and pass the remaining 0 parameters to the original function
func Ignore123of3[T1, T2, T3 any, F ~func() R, R any](f F) func(T1, T2, T3) R {
return func(t1 T1, t2 T2, t3 T3) R {
return f()
}
return func(t1 T1, t2 T2, t3 T3) R {
return f()
}
}
// Combinations for a total of 4 arguments
// Bind1of4 takes a function with 4 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
// The return value of is a function with the remaining 3 parameters at positions [2, 3, 4] of the original function.
func Bind1of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1) func(T2, T3, T4) R {
return func(t1 T1) func(T2, T3, T4) R {
return func(t2 T2, t3 T3, t4 T4) R {
return f(t1, t2, t3, t4)
}
}
return func(t1 T1) func(T2, T3, T4) R {
return func(t2 T2, t3 T3, t4 T4) R {
return f(t1, t2, t3, t4)
}
}
}
// Ignore1of4 takes a function with 3 parameters and returns a new function with 4 parameters that will ignore the values at positions [1] and pass the remaining 3 parameters to the original function
func Ignore1of4[T1 any, F ~func(T2, T3, T4) R, T2, T3, T4, R any](f F) func(T1, T2, T3, T4) R {
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t2, t3, t4)
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t2, t3, t4)
}
}
// Bind2of4 takes a function with 4 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [2] of the original function.
// The return value of is a function with the remaining 3 parameters at positions [1, 3, 4] of the original function.
func Bind2of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T2) func(T1, T3, T4) R {
return func(t2 T2) func(T1, T3, T4) R {
return func(t1 T1, t3 T3, t4 T4) R {
return f(t1, t2, t3, t4)
}
}
return func(t2 T2) func(T1, T3, T4) R {
return func(t1 T1, t3 T3, t4 T4) R {
return f(t1, t2, t3, t4)
}
}
}
// Ignore2of4 takes a function with 3 parameters and returns a new function with 4 parameters that will ignore the values at positions [2] and pass the remaining 3 parameters to the original function
func Ignore2of4[T2 any, F ~func(T1, T3, T4) R, T1, T3, T4, R any](f F) func(T1, T2, T3, T4) R {
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t1, t3, t4)
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t1, t3, t4)
}
}
// Bind3of4 takes a function with 4 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [3] of the original function.
// The return value of is a function with the remaining 3 parameters at positions [1, 2, 4] of the original function.
func Bind3of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T3) func(T1, T2, T4) R {
return func(t3 T3) func(T1, T2, T4) R {
return func(t1 T1, t2 T2, t4 T4) R {
return f(t1, t2, t3, t4)
}
}
return func(t3 T3) func(T1, T2, T4) R {
return func(t1 T1, t2 T2, t4 T4) R {
return f(t1, t2, t3, t4)
}
}
}
// Ignore3of4 takes a function with 3 parameters and returns a new function with 4 parameters that will ignore the values at positions [3] and pass the remaining 3 parameters to the original function
func Ignore3of4[T3 any, F ~func(T1, T2, T4) R, T1, T2, T4, R any](f F) func(T1, T2, T3, T4) R {
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t1, t2, t4)
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t1, t2, t4)
}
}
// Bind4of4 takes a function with 4 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [4] of the original function.
// The return value of is a function with the remaining 3 parameters at positions [1, 2, 3] of the original function.
func Bind4of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T4) func(T1, T2, T3) R {
return func(t4 T4) func(T1, T2, T3) R {
return func(t1 T1, t2 T2, t3 T3) R {
return f(t1, t2, t3, t4)
}
}
return func(t4 T4) func(T1, T2, T3) R {
return func(t1 T1, t2 T2, t3 T3) R {
return f(t1, t2, t3, t4)
}
}
}
// Ignore4of4 takes a function with 3 parameters and returns a new function with 4 parameters that will ignore the values at positions [4] and pass the remaining 3 parameters to the original function
func Ignore4of4[T4 any, F ~func(T1, T2, T3) R, T1, T2, T3, R any](f F) func(T1, T2, T3, T4) R {
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t1, t2, t3)
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t1, t2, t3)
}
}
// Bind12of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 2] of the original function.
// The return value of is a function with the remaining 2 parameters at positions [3, 4] of the original function.
func Bind12of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T2) func(T3, T4) R {
return func(t1 T1, t2 T2) func(T3, T4) R {
return func(t3 T3, t4 T4) R {
return f(t1, t2, t3, t4)
}
}
return func(t1 T1, t2 T2) func(T3, T4) R {
return func(t3 T3, t4 T4) R {
return f(t1, t2, t3, t4)
}
}
}
// Ignore12of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 2] and pass the remaining 2 parameters to the original function
func Ignore12of4[T1, T2 any, F ~func(T3, T4) R, T3, T4, R any](f F) func(T1, T2, T3, T4) R {
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t3, t4)
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t3, t4)
}
}
// Bind13of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 3] of the original function.
// The return value of is a function with the remaining 2 parameters at positions [2, 4] of the original function.
func Bind13of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T3) func(T2, T4) R {
return func(t1 T1, t3 T3) func(T2, T4) R {
return func(t2 T2, t4 T4) R {
return f(t1, t2, t3, t4)
}
}
return func(t1 T1, t3 T3) func(T2, T4) R {
return func(t2 T2, t4 T4) R {
return f(t1, t2, t3, t4)
}
}
}
// Ignore13of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 3] and pass the remaining 2 parameters to the original function
func Ignore13of4[T1, T3 any, F ~func(T2, T4) R, T2, T4, R any](f F) func(T1, T2, T3, T4) R {
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t2, t4)
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t2, t4)
}
}
// Bind14of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [1, 4] of the original function.
// The return value of is a function with the remaining 2 parameters at positions [2, 3] of the original function.
func Bind14of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T4) func(T2, T3) R {
return func(t1 T1, t4 T4) func(T2, T3) R {
return func(t2 T2, t3 T3) R {
return f(t1, t2, t3, t4)
}
}
return func(t1 T1, t4 T4) func(T2, T3) R {
return func(t2 T2, t3 T3) R {
return f(t1, t2, t3, t4)
}
}
}
// Ignore14of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 4] and pass the remaining 2 parameters to the original function
func Ignore14of4[T1, T4 any, F ~func(T2, T3) R, T2, T3, R any](f F) func(T1, T2, T3, T4) R {
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t2, t3)
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t2, t3)
}
}
// Bind23of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [2, 3] of the original function.
// The return value of is a function with the remaining 2 parameters at positions [1, 4] of the original function.
func Bind23of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T2, T3) func(T1, T4) R {
return func(t2 T2, t3 T3) func(T1, T4) R {
return func(t1 T1, t4 T4) R {
return f(t1, t2, t3, t4)
}
}
return func(t2 T2, t3 T3) func(T1, T4) R {
return func(t1 T1, t4 T4) R {
return f(t1, t2, t3, t4)
}
}
}
// Ignore23of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [2, 3] and pass the remaining 2 parameters to the original function
func Ignore23of4[T2, T3 any, F ~func(T1, T4) R, T1, T4, R any](f F) func(T1, T2, T3, T4) R {
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t1, t4)
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t1, t4)
}
}
// Bind24of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [2, 4] of the original function.
// The return value of is a function with the remaining 2 parameters at positions [1, 3] of the original function.
func Bind24of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T2, T4) func(T1, T3) R {
return func(t2 T2, t4 T4) func(T1, T3) R {
return func(t1 T1, t3 T3) R {
return f(t1, t2, t3, t4)
}
}
return func(t2 T2, t4 T4) func(T1, T3) R {
return func(t1 T1, t3 T3) R {
return f(t1, t2, t3, t4)
}
}
}
// Ignore24of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [2, 4] and pass the remaining 2 parameters to the original function
func Ignore24of4[T2, T4 any, F ~func(T1, T3) R, T1, T3, R any](f F) func(T1, T2, T3, T4) R {
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t1, t3)
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t1, t3)
}
}
// Bind34of4 takes a function with 4 parameters and returns a new function with 2 parameters that will bind these parameters to the positions [3, 4] of the original function.
// The return value of is a function with the remaining 2 parameters at positions [1, 2] of the original function.
func Bind34of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T3, T4) func(T1, T2) R {
return func(t3 T3, t4 T4) func(T1, T2) R {
return func(t1 T1, t2 T2) R {
return f(t1, t2, t3, t4)
}
}
return func(t3 T3, t4 T4) func(T1, T2) R {
return func(t1 T1, t2 T2) R {
return f(t1, t2, t3, t4)
}
}
}
// Ignore34of4 takes a function with 2 parameters and returns a new function with 4 parameters that will ignore the values at positions [3, 4] and pass the remaining 2 parameters to the original function
func Ignore34of4[T3, T4 any, F ~func(T1, T2) R, T1, T2, R any](f F) func(T1, T2, T3, T4) R {
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t1, t2)
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t1, t2)
}
}
// Bind123of4 takes a function with 4 parameters and returns a new function with 3 parameters that will bind these parameters to the positions [1, 2, 3] of the original function.
// The return value of is a function with the remaining 1 parameters at positions [4] of the original function.
func Bind123of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T2, T3) func(T4) R {
return func(t1 T1, t2 T2, t3 T3) func(T4) R {
return func(t4 T4) R {
return f(t1, t2, t3, t4)
}
}
return func(t1 T1, t2 T2, t3 T3) func(T4) R {
return func(t4 T4) R {
return f(t1, t2, t3, t4)
}
}
}
// Ignore123of4 takes a function with 1 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 2, 3] and pass the remaining 1 parameters to the original function
func Ignore123of4[T1, T2, T3 any, F ~func(T4) R, T4, R any](f F) func(T1, T2, T3, T4) R {
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t4)
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t4)
}
}
// Bind124of4 takes a function with 4 parameters and returns a new function with 3 parameters that will bind these parameters to the positions [1, 2, 4] of the original function.
// The return value of is a function with the remaining 1 parameters at positions [3] of the original function.
func Bind124of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T2, T4) func(T3) R {
return func(t1 T1, t2 T2, t4 T4) func(T3) R {
return func(t3 T3) R {
return f(t1, t2, t3, t4)
}
}
return func(t1 T1, t2 T2, t4 T4) func(T3) R {
return func(t3 T3) R {
return f(t1, t2, t3, t4)
}
}
}
// Ignore124of4 takes a function with 1 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 2, 4] and pass the remaining 1 parameters to the original function
func Ignore124of4[T1, T2, T4 any, F ~func(T3) R, T3, R any](f F) func(T1, T2, T3, T4) R {
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t3)
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t3)
}
}
// Bind134of4 takes a function with 4 parameters and returns a new function with 3 parameters that will bind these parameters to the positions [1, 3, 4] of the original function.
// The return value of is a function with the remaining 1 parameters at positions [2] of the original function.
func Bind134of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T3, T4) func(T2) R {
return func(t1 T1, t3 T3, t4 T4) func(T2) R {
return func(t2 T2) R {
return f(t1, t2, t3, t4)
}
}
return func(t1 T1, t3 T3, t4 T4) func(T2) R {
return func(t2 T2) R {
return f(t1, t2, t3, t4)
}
}
}
// Ignore134of4 takes a function with 1 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 3, 4] and pass the remaining 1 parameters to the original function
func Ignore134of4[T1, T3, T4 any, F ~func(T2) R, T2, R any](f F) func(T1, T2, T3, T4) R {
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t2)
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t2)
}
}
// Bind234of4 takes a function with 4 parameters and returns a new function with 3 parameters that will bind these parameters to the positions [2, 3, 4] of the original function.
// The return value of is a function with the remaining 1 parameters at positions [1] of the original function.
func Bind234of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T2, T3, T4) func(T1) R {
return func(t2 T2, t3 T3, t4 T4) func(T1) R {
return func(t1 T1) R {
return f(t1, t2, t3, t4)
}
}
return func(t2 T2, t3 T3, t4 T4) func(T1) R {
return func(t1 T1) R {
return f(t1, t2, t3, t4)
}
}
}
// Ignore234of4 takes a function with 1 parameters and returns a new function with 4 parameters that will ignore the values at positions [2, 3, 4] and pass the remaining 1 parameters to the original function
func Ignore234of4[T2, T3, T4 any, F ~func(T1) R, T1, R any](f F) func(T1, T2, T3, T4) R {
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t1)
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f(t1)
}
}
// Bind1234of4 takes a function with 4 parameters and returns a new function with 4 parameters that will bind these parameters to the positions [1, 2, 3, 4] of the original function.
// The return value of is a function with the remaining 0 parameters at positions [] of the original function.
func Bind1234of4[F ~func(T1, T2, T3, T4) R, T1, T2, T3, T4, R any](f F) func(T1, T2, T3, T4) func() R {
return func(t1 T1, t2 T2, t3 T3, t4 T4) func() R {
return func() R {
return f(t1, t2, t3, t4)
}
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) func() R {
return func() R {
return f(t1, t2, t3, t4)
}
}
}
// Ignore1234of4 takes a function with 0 parameters and returns a new function with 4 parameters that will ignore the values at positions [1, 2, 3, 4] and pass the remaining 0 parameters to the original function
func Ignore1234of4[T1, T2, T3, T4 any, F ~func() R, R any](f F) func(T1, T2, T3, T4) R {
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f()
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) R {
return f()
}
}

1660
v2/function/gen.go
View File

File diff suppressed because it is too large Load Diff

771
v2/identity/gen.go
View File

@ -4,7 +4,6 @@
package identity
import (
A "github.com/IBM/fp-go/v2/internal/apply"
T "github.com/IBM/fp-go/v2/tuple"
@ -12,495 +11,495 @@ import (
// SequenceT1 converts 1 parameters of [T] into a [Tuple1].
func SequenceT1[T1 any](t1 T1) T.Tuple1[T1] {
return A.SequenceT1(
Map[T1, T.Tuple1[T1]],
t1,
)
return A.SequenceT1(
Map[T1, T.Tuple1[T1]],
t1,
)
}
// SequenceTuple1 converts a [Tuple1] of [T] into an [Tuple1].
func SequenceTuple1[T1 any](t T.Tuple1[T1]) T.Tuple1[T1] {
return A.SequenceTuple1(
Map[T1, T.Tuple1[T1]],
t,
)
return A.SequenceTuple1(
Map[T1, T.Tuple1[T1]],
t,
)
}
// TraverseTuple1 converts a [Tuple1] of [A] via transformation functions transforming [A] to [A] into a [Tuple1].
func TraverseTuple1[F1 ~func(A1) T1, A1, T1 any](f1 F1) func (T.Tuple1[A1]) T.Tuple1[T1] {
return func(t T.Tuple1[A1]) T.Tuple1[T1] {
return A.TraverseTuple1(
Map[T1, T.Tuple1[T1]],
f1,
t,
)
}
func TraverseTuple1[F1 ~func(A1) T1, A1, T1 any](f1 F1) func(T.Tuple1[A1]) T.Tuple1[T1] {
return func(t T.Tuple1[A1]) T.Tuple1[T1] {
return A.TraverseTuple1(
Map[T1, T.Tuple1[T1]],
f1,
t,
)
}
}
// SequenceT2 converts 2 parameters of [T] into a [Tuple2].
func SequenceT2[T1, T2 any](t1 T1, t2 T2) T.Tuple2[T1, T2] {
return A.SequenceT2(
Map[T1, func(T2) T.Tuple2[T1, T2]],
Ap[T.Tuple2[T1, T2], T2],
t1,
t2,
)
return A.SequenceT2(
Map[T1, func(T2) T.Tuple2[T1, T2]],
Ap[T.Tuple2[T1, T2], T2],
t1,
t2,
)
}
// SequenceTuple2 converts a [Tuple2] of [T] into an [Tuple2].
func SequenceTuple2[T1, T2 any](t T.Tuple2[T1, T2]) T.Tuple2[T1, T2] {
return A.SequenceTuple2(
Map[T1, func(T2) T.Tuple2[T1, T2]],
Ap[T.Tuple2[T1, T2], T2],
t,
)
return A.SequenceTuple2(
Map[T1, func(T2) T.Tuple2[T1, T2]],
Ap[T.Tuple2[T1, T2], T2],
t,
)
}
// TraverseTuple2 converts a [Tuple2] of [A] via transformation functions transforming [A] to [A] into a [Tuple2].
func TraverseTuple2[F1 ~func(A1) T1, F2 ~func(A2) T2, A1, T1, A2, T2 any](f1 F1, f2 F2) func (T.Tuple2[A1, A2]) T.Tuple2[T1, T2] {
return func(t T.Tuple2[A1, A2]) T.Tuple2[T1, T2] {
return A.TraverseTuple2(
Map[T1, func(T2) T.Tuple2[T1, T2]],
Ap[T.Tuple2[T1, T2], T2],
f1,
f2,
t,
)
}
func TraverseTuple2[F1 ~func(A1) T1, F2 ~func(A2) T2, A1, T1, A2, T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) T.Tuple2[T1, T2] {
return func(t T.Tuple2[A1, A2]) T.Tuple2[T1, T2] {
return A.TraverseTuple2(
Map[T1, func(T2) T.Tuple2[T1, T2]],
Ap[T.Tuple2[T1, T2], T2],
f1,
f2,
t,
)
}
}
// SequenceT3 converts 3 parameters of [T] into a [Tuple3].
func SequenceT3[T1, T2, T3 any](t1 T1, t2 T2, t3 T3) T.Tuple3[T1, T2, T3] {
return A.SequenceT3(
Map[T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
Ap[func(T3) T.Tuple3[T1, T2, T3], T2],
Ap[T.Tuple3[T1, T2, T3], T3],
t1,
t2,
t3,
)
return A.SequenceT3(
Map[T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
Ap[func(T3) T.Tuple3[T1, T2, T3], T2],
Ap[T.Tuple3[T1, T2, T3], T3],
t1,
t2,
t3,
)
}
// SequenceTuple3 converts a [Tuple3] of [T] into an [Tuple3].
func SequenceTuple3[T1, T2, T3 any](t T.Tuple3[T1, T2, T3]) T.Tuple3[T1, T2, T3] {
return A.SequenceTuple3(
Map[T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
Ap[func(T3) T.Tuple3[T1, T2, T3], T2],
Ap[T.Tuple3[T1, T2, T3], T3],
t,
)
return A.SequenceTuple3(
Map[T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
Ap[func(T3) T.Tuple3[T1, T2, T3], T2],
Ap[T.Tuple3[T1, T2, T3], T3],
t,
)
}
// TraverseTuple3 converts a [Tuple3] of [A] via transformation functions transforming [A] to [A] into a [Tuple3].
func TraverseTuple3[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, A1, T1, A2, T2, A3, T3 any](f1 F1, f2 F2, f3 F3) func (T.Tuple3[A1, A2, A3]) T.Tuple3[T1, T2, T3] {
return func(t T.Tuple3[A1, A2, A3]) T.Tuple3[T1, T2, T3] {
return A.TraverseTuple3(
Map[T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
Ap[func(T3) T.Tuple3[T1, T2, T3], T2],
Ap[T.Tuple3[T1, T2, T3], T3],
f1,
f2,
f3,
t,
)
}
func TraverseTuple3[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, A1, T1, A2, T2, A3, T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) T.Tuple3[T1, T2, T3] {
return func(t T.Tuple3[A1, A2, A3]) T.Tuple3[T1, T2, T3] {
return A.TraverseTuple3(
Map[T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
Ap[func(T3) T.Tuple3[T1, T2, T3], T2],
Ap[T.Tuple3[T1, T2, T3], T3],
f1,
f2,
f3,
t,
)
}
}
// SequenceT4 converts 4 parameters of [T] into a [Tuple4].
func SequenceT4[T1, T2, T3, T4 any](t1 T1, t2 T2, t3 T3, t4 T4) T.Tuple4[T1, T2, T3, T4] {
return A.SequenceT4(
Map[T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
Ap[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], T2],
Ap[func(T4) T.Tuple4[T1, T2, T3, T4], T3],
Ap[T.Tuple4[T1, T2, T3, T4], T4],
t1,
t2,
t3,
t4,
)
return A.SequenceT4(
Map[T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
Ap[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], T2],
Ap[func(T4) T.Tuple4[T1, T2, T3, T4], T3],
Ap[T.Tuple4[T1, T2, T3, T4], T4],
t1,
t2,
t3,
t4,
)
}
// SequenceTuple4 converts a [Tuple4] of [T] into an [Tuple4].
func SequenceTuple4[T1, T2, T3, T4 any](t T.Tuple4[T1, T2, T3, T4]) T.Tuple4[T1, T2, T3, T4] {
return A.SequenceTuple4(
Map[T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
Ap[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], T2],
Ap[func(T4) T.Tuple4[T1, T2, T3, T4], T3],
Ap[T.Tuple4[T1, T2, T3, T4], T4],
t,
)
return A.SequenceTuple4(
Map[T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
Ap[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], T2],
Ap[func(T4) T.Tuple4[T1, T2, T3, T4], T3],
Ap[T.Tuple4[T1, T2, T3, T4], T4],
t,
)
}
// TraverseTuple4 converts a [Tuple4] of [A] via transformation functions transforming [A] to [A] into a [Tuple4].
func TraverseTuple4[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, A1, T1, A2, T2, A3, T3, A4, T4 any](f1 F1, f2 F2, f3 F3, f4 F4) func (T.Tuple4[A1, A2, A3, A4]) T.Tuple4[T1, T2, T3, T4] {
return func(t T.Tuple4[A1, A2, A3, A4]) T.Tuple4[T1, T2, T3, T4] {
return A.TraverseTuple4(
Map[T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
Ap[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], T2],
Ap[func(T4) T.Tuple4[T1, T2, T3, T4], T3],
Ap[T.Tuple4[T1, T2, T3, T4], T4],
f1,
f2,
f3,
f4,
t,
)
}
func TraverseTuple4[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, A1, T1, A2, T2, A3, T3, A4, T4 any](f1 F1, f2 F2, f3 F3, f4 F4) func(T.Tuple4[A1, A2, A3, A4]) T.Tuple4[T1, T2, T3, T4] {
return func(t T.Tuple4[A1, A2, A3, A4]) T.Tuple4[T1, T2, T3, T4] {
return A.TraverseTuple4(
Map[T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
Ap[func(T3) func(T4) T.Tuple4[T1, T2, T3, T4], T2],
Ap[func(T4) T.Tuple4[T1, T2, T3, T4], T3],
Ap[T.Tuple4[T1, T2, T3, T4], T4],
f1,
f2,
f3,
f4,
t,
)
}
}
// SequenceT5 converts 5 parameters of [T] into a [Tuple5].
func SequenceT5[T1, T2, T3, T4, T5 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) T.Tuple5[T1, T2, T3, T4, T5] {
return A.SequenceT5(
Map[T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
Ap[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T2],
Ap[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T3],
Ap[func(T5) T.Tuple5[T1, T2, T3, T4, T5], T4],
Ap[T.Tuple5[T1, T2, T3, T4, T5], T5],
t1,
t2,
t3,
t4,
t5,
)
return A.SequenceT5(
Map[T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
Ap[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T2],
Ap[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T3],
Ap[func(T5) T.Tuple5[T1, T2, T3, T4, T5], T4],
Ap[T.Tuple5[T1, T2, T3, T4, T5], T5],
t1,
t2,
t3,
t4,
t5,
)
}
// SequenceTuple5 converts a [Tuple5] of [T] into an [Tuple5].
func SequenceTuple5[T1, T2, T3, T4, T5 any](t T.Tuple5[T1, T2, T3, T4, T5]) T.Tuple5[T1, T2, T3, T4, T5] {
return A.SequenceTuple5(
Map[T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
Ap[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T2],
Ap[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T3],
Ap[func(T5) T.Tuple5[T1, T2, T3, T4, T5], T4],
Ap[T.Tuple5[T1, T2, T3, T4, T5], T5],
t,
)
return A.SequenceTuple5(
Map[T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
Ap[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T2],
Ap[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T3],
Ap[func(T5) T.Tuple5[T1, T2, T3, T4, T5], T4],
Ap[T.Tuple5[T1, T2, T3, T4, T5], T5],
t,
)
}
// TraverseTuple5 converts a [Tuple5] of [A] via transformation functions transforming [A] to [A] into a [Tuple5].
func TraverseTuple5[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func (T.Tuple5[A1, A2, A3, A4, A5]) T.Tuple5[T1, T2, T3, T4, T5] {
return func(t T.Tuple5[A1, A2, A3, A4, A5]) T.Tuple5[T1, T2, T3, T4, T5] {
return A.TraverseTuple5(
Map[T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
Ap[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T2],
Ap[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T3],
Ap[func(T5) T.Tuple5[T1, T2, T3, T4, T5], T4],
Ap[T.Tuple5[T1, T2, T3, T4, T5], T5],
f1,
f2,
f3,
f4,
f5,
t,
)
}
func TraverseTuple5[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func(T.Tuple5[A1, A2, A3, A4, A5]) T.Tuple5[T1, T2, T3, T4, T5] {
return func(t T.Tuple5[A1, A2, A3, A4, A5]) T.Tuple5[T1, T2, T3, T4, T5] {
return A.TraverseTuple5(
Map[T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
Ap[func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T2],
Ap[func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5], T3],
Ap[func(T5) T.Tuple5[T1, T2, T3, T4, T5], T4],
Ap[T.Tuple5[T1, T2, T3, T4, T5], T5],
f1,
f2,
f3,
f4,
f5,
t,
)
}
}
// SequenceT6 converts 6 parameters of [T] into a [Tuple6].
func SequenceT6[T1, T2, T3, T4, T5, T6 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) T.Tuple6[T1, T2, T3, T4, T5, T6] {
return A.SequenceT6(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
Ap[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T2],
Ap[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T3],
Ap[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T4],
Ap[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T5],
Ap[T.Tuple6[T1, T2, T3, T4, T5, T6], T6],
t1,
t2,
t3,
t4,
t5,
t6,
)
return A.SequenceT6(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
Ap[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T2],
Ap[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T3],
Ap[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T4],
Ap[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T5],
Ap[T.Tuple6[T1, T2, T3, T4, T5, T6], T6],
t1,
t2,
t3,
t4,
t5,
t6,
)
}
// SequenceTuple6 converts a [Tuple6] of [T] into an [Tuple6].
func SequenceTuple6[T1, T2, T3, T4, T5, T6 any](t T.Tuple6[T1, T2, T3, T4, T5, T6]) T.Tuple6[T1, T2, T3, T4, T5, T6] {
return A.SequenceTuple6(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
Ap[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T2],
Ap[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T3],
Ap[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T4],
Ap[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T5],
Ap[T.Tuple6[T1, T2, T3, T4, T5, T6], T6],
t,
)
return A.SequenceTuple6(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
Ap[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T2],
Ap[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T3],
Ap[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T4],
Ap[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T5],
Ap[T.Tuple6[T1, T2, T3, T4, T5, T6], T6],
t,
)
}
// TraverseTuple6 converts a [Tuple6] of [A] via transformation functions transforming [A] to [A] into a [Tuple6].
func TraverseTuple6[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func (T.Tuple6[A1, A2, A3, A4, A5, A6]) T.Tuple6[T1, T2, T3, T4, T5, T6] {
return func(t T.Tuple6[A1, A2, A3, A4, A5, A6]) T.Tuple6[T1, T2, T3, T4, T5, T6] {
return A.TraverseTuple6(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
Ap[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T2],
Ap[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T3],
Ap[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T4],
Ap[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T5],
Ap[T.Tuple6[T1, T2, T3, T4, T5, T6], T6],
f1,
f2,
f3,
f4,
f5,
f6,
t,
)
}
func TraverseTuple6[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func(T.Tuple6[A1, A2, A3, A4, A5, A6]) T.Tuple6[T1, T2, T3, T4, T5, T6] {
return func(t T.Tuple6[A1, A2, A3, A4, A5, A6]) T.Tuple6[T1, T2, T3, T4, T5, T6] {
return A.TraverseTuple6(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
Ap[func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T2],
Ap[func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T3],
Ap[func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T4],
Ap[func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6], T5],
Ap[T.Tuple6[T1, T2, T3, T4, T5, T6], T6],
f1,
f2,
f3,
f4,
f5,
f6,
t,
)
}
}
// SequenceT7 converts 7 parameters of [T] into a [Tuple7].
func SequenceT7[T1, T2, T3, T4, T5, T6, T7 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7] {
return A.SequenceT7(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T2],
Ap[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T3],
Ap[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T4],
Ap[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T5],
Ap[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T6],
Ap[T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T7],
t1,
t2,
t3,
t4,
t5,
t6,
t7,
)
return A.SequenceT7(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T2],
Ap[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T3],
Ap[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T4],
Ap[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T5],
Ap[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T6],
Ap[T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T7],
t1,
t2,
t3,
t4,
t5,
t6,
t7,
)
}
// SequenceTuple7 converts a [Tuple7] of [T] into an [Tuple7].
func SequenceTuple7[T1, T2, T3, T4, T5, T6, T7 any](t T.Tuple7[T1, T2, T3, T4, T5, T6, T7]) T.Tuple7[T1, T2, T3, T4, T5, T6, T7] {
return A.SequenceTuple7(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T2],
Ap[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T3],
Ap[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T4],
Ap[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T5],
Ap[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T6],
Ap[T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T7],
t,
)
return A.SequenceTuple7(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T2],
Ap[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T3],
Ap[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T4],
Ap[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T5],
Ap[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T6],
Ap[T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T7],
t,
)
}
// TraverseTuple7 converts a [Tuple7] of [A] via transformation functions transforming [A] to [A] into a [Tuple7].
func TraverseTuple7[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, F7 ~func(A7) T7, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func (T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) T.Tuple7[T1, T2, T3, T4, T5, T6, T7] {
return func(t T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) T.Tuple7[T1, T2, T3, T4, T5, T6, T7] {
return A.TraverseTuple7(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T2],
Ap[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T3],
Ap[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T4],
Ap[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T5],
Ap[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T6],
Ap[T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T7],
f1,
f2,
f3,
f4,
f5,
f6,
f7,
t,
)
}
func TraverseTuple7[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, F7 ~func(A7) T7, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func(T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) T.Tuple7[T1, T2, T3, T4, T5, T6, T7] {
return func(t T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) T.Tuple7[T1, T2, T3, T4, T5, T6, T7] {
return A.TraverseTuple7(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T2],
Ap[func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T3],
Ap[func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T4],
Ap[func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T5],
Ap[func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T6],
Ap[T.Tuple7[T1, T2, T3, T4, T5, T6, T7], T7],
f1,
f2,
f3,
f4,
f5,
f6,
f7,
t,
)
}
}
// SequenceT8 converts 8 parameters of [T] into a [Tuple8].
func SequenceT8[T1, T2, T3, T4, T5, T6, T7, T8 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
return A.SequenceT8(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T3],
Ap[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T4],
Ap[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T5],
Ap[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T6],
Ap[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T7],
Ap[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T8],
t1,
t2,
t3,
t4,
t5,
t6,
t7,
t8,
)
return A.SequenceT8(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T3],
Ap[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T4],
Ap[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T5],
Ap[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T6],
Ap[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T7],
Ap[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T8],
t1,
t2,
t3,
t4,
t5,
t6,
t7,
t8,
)
}
// SequenceTuple8 converts a [Tuple8] of [T] into an [Tuple8].
func SequenceTuple8[T1, T2, T3, T4, T5, T6, T7, T8 any](t T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
return A.SequenceTuple8(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T3],
Ap[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T4],
Ap[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T5],
Ap[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T6],
Ap[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T7],
Ap[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T8],
t,
)
return A.SequenceTuple8(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T3],
Ap[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T4],
Ap[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T5],
Ap[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T6],
Ap[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T7],
Ap[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T8],
t,
)
}
// TraverseTuple8 converts a [Tuple8] of [A] via transformation functions transforming [A] to [A] into a [Tuple8].
func TraverseTuple8[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, F7 ~func(A7) T7, F8 ~func(A8) T8, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func (T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
return func(t T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
return A.TraverseTuple8(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T3],
Ap[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T4],
Ap[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T5],
Ap[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T6],
Ap[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T7],
Ap[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T8],
f1,
f2,
f3,
f4,
f5,
f6,
f7,
f8,
t,
)
}
func TraverseTuple8[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, F7 ~func(A7) T7, F8 ~func(A8) T8, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func(T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
return func(t T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
return A.TraverseTuple8(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T3],
Ap[func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T4],
Ap[func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T5],
Ap[func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T6],
Ap[func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T7],
Ap[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], T8],
f1,
f2,
f3,
f4,
f5,
f6,
f7,
f8,
t,
)
}
}
// SequenceT9 converts 9 parameters of [T] into a [Tuple9].
func SequenceT9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
return A.SequenceT9(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T3],
Ap[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T4],
Ap[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T5],
Ap[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T6],
Ap[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T7],
Ap[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T8],
Ap[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T9],
t1,
t2,
t3,
t4,
t5,
t6,
t7,
t8,
t9,
)
return A.SequenceT9(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T3],
Ap[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T4],
Ap[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T5],
Ap[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T6],
Ap[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T7],
Ap[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T8],
Ap[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T9],
t1,
t2,
t3,
t4,
t5,
t6,
t7,
t8,
t9,
)
}
// SequenceTuple9 converts a [Tuple9] of [T] into an [Tuple9].
func SequenceTuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
return A.SequenceTuple9(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T3],
Ap[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T4],
Ap[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T5],
Ap[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T6],
Ap[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T7],
Ap[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T8],
Ap[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T9],
t,
)
return A.SequenceTuple9(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T3],
Ap[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T4],
Ap[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T5],
Ap[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T6],
Ap[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T7],
Ap[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T8],
Ap[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T9],
t,
)
}
// TraverseTuple9 converts a [Tuple9] of [A] via transformation functions transforming [A] to [A] into a [Tuple9].
func TraverseTuple9[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, F7 ~func(A7) T7, F8 ~func(A8) T8, F9 ~func(A9) T9, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func (T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
return func(t T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
return A.TraverseTuple9(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T3],
Ap[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T4],
Ap[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T5],
Ap[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T6],
Ap[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T7],
Ap[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T8],
Ap[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T9],
f1,
f2,
f3,
f4,
f5,
f6,
f7,
f8,
f9,
t,
)
}
func TraverseTuple9[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, F7 ~func(A7) T7, F8 ~func(A8) T8, F9 ~func(A9) T9, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func(T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
return func(t T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
return A.TraverseTuple9(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T3],
Ap[func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T4],
Ap[func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T5],
Ap[func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T6],
Ap[func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T7],
Ap[func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T8],
Ap[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], T9],
f1,
f2,
f3,
f4,
f5,
f6,
f7,
f8,
f9,
t,
)
}
}
// SequenceT10 converts 10 parameters of [T] into a [Tuple10].
func SequenceT10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
return A.SequenceT10(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T3],
Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T4],
Ap[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T5],
Ap[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T6],
Ap[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T7],
Ap[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T8],
Ap[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T9],
Ap[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T10],
t1,
t2,
t3,
t4,
t5,
t6,
t7,
t8,
t9,
t10,
)
return A.SequenceT10(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T3],
Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T4],
Ap[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T5],
Ap[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T6],
Ap[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T7],
Ap[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T8],
Ap[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T9],
Ap[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T10],
t1,
t2,
t3,
t4,
t5,
t6,
t7,
t8,
t9,
t10,
)
}
// SequenceTuple10 converts a [Tuple10] of [T] into an [Tuple10].
func SequenceTuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
return A.SequenceTuple10(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T3],
Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T4],
Ap[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T5],
Ap[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T6],
Ap[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T7],
Ap[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T8],
Ap[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T9],
Ap[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T10],
t,
)
return A.SequenceTuple10(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T3],
Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T4],
Ap[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T5],
Ap[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T6],
Ap[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T7],
Ap[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T8],
Ap[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T9],
Ap[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T10],
t,
)
}
// TraverseTuple10 converts a [Tuple10] of [A] via transformation functions transforming [A] to [A] into a [Tuple10].
func TraverseTuple10[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, F7 ~func(A7) T7, F8 ~func(A8) T8, F9 ~func(A9) T9, F10 ~func(A10) T10, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func (T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
return func(t T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
return A.TraverseTuple10(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T3],
Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T4],
Ap[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T5],
Ap[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T6],
Ap[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T7],
Ap[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T8],
Ap[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T9],
Ap[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T10],
f1,
f2,
f3,
f4,
f5,
f6,
f7,
f8,
f9,
f10,
t,
)
}
func TraverseTuple10[F1 ~func(A1) T1, F2 ~func(A2) T2, F3 ~func(A3) T3, F4 ~func(A4) T4, F5 ~func(A5) T5, F6 ~func(A6) T6, F7 ~func(A7) T7, F8 ~func(A8) T8, F9 ~func(A9) T9, F10 ~func(A10) T10, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func(T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
return func(t T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
return A.TraverseTuple10(
Map[T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
Ap[func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T2],
Ap[func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T3],
Ap[func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T4],
Ap[func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T5],
Ap[func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T6],
Ap[func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T7],
Ap[func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T8],
Ap[func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T9],
Ap[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10], T10],
f1,
f2,
f3,
f4,
f5,
f6,
f7,
f8,
f9,
f10,
t,
)
}
}

5401
v2/internal/apply/gen.go
View File

File diff suppressed because it is too large Load Diff

2583
v2/io/gen.go
View File

File diff suppressed because it is too large Load Diff

22
v2/io/io.go
View File

@ -19,9 +19,9 @@ import (
"time"
F "github.com/IBM/fp-go/v2/function"
INTA "github.com/IBM/fp-go/v2/internal/apply"
INTC "github.com/IBM/fp-go/v2/internal/chain"
INTF "github.com/IBM/fp-go/v2/internal/functor"
"github.com/IBM/fp-go/v2/internal/apply"
"github.com/IBM/fp-go/v2/internal/chain"
"github.com/IBM/fp-go/v2/internal/functor"
INTL "github.com/IBM/fp-go/v2/internal/lazy"
M "github.com/IBM/fp-go/v2/monoid"
R "github.com/IBM/fp-go/v2/reader"
@ -150,13 +150,13 @@ func Memoize[A any](ma IO[A]) IO[A] {
// MonadChainFirst composes computations in sequence, using the return value of one computation to determine the next computation and
// keeping only the result of the first.
func MonadChainFirst[A, B any](fa IO[A], f func(A) IO[B]) IO[A] {
return INTC.MonadChainFirst(MonadChain[A, A], MonadMap[B, A], fa, f)
return chain.MonadChainFirst(MonadChain[A, A], MonadMap[B, A], fa, f)
}
// ChainFirst composes computations in sequence, using the return value of one computation to determine the next computation and
// keeping only the result of the first.
func ChainFirst[A, B any](f func(A) IO[B]) Operator[A, A] {
return INTC.ChainFirst(
return chain.ChainFirst(
Chain[A, A],
Map[B, A],
f,
@ -165,7 +165,7 @@ func ChainFirst[A, B any](f func(A) IO[B]) Operator[A, A] {
// MonadApFirst combines two effectful actions, keeping only the result of the first.
func MonadApFirst[A, B any](first IO[A], second IO[B]) IO[A] {
return INTA.MonadApFirst(
return apply.MonadApFirst(
MonadAp[B, A],
MonadMap[A, func(B) A],
@ -176,7 +176,7 @@ func MonadApFirst[A, B any](first IO[A], second IO[B]) IO[A] {
// ApFirst combines two effectful actions, keeping only the result of the first.
func ApFirst[A, B any](second IO[B]) Operator[A, A] {
return INTA.ApFirst(
return apply.ApFirst(
MonadAp[B, A],
MonadMap[A, func(B) A],
@ -186,7 +186,7 @@ func ApFirst[A, B any](second IO[B]) Operator[A, A] {
// MonadApSecond combines two effectful actions, keeping only the result of the second.
func MonadApSecond[A, B any](first IO[A], second IO[B]) IO[B] {
return INTA.MonadApSecond(
return apply.MonadApSecond(
MonadAp[B, B],
MonadMap[A, func(B) B],
@ -197,7 +197,7 @@ func MonadApSecond[A, B any](first IO[A], second IO[B]) IO[B] {
// ApSecond combines two effectful actions, keeping only the result of the second.
func ApSecond[A, B any](second IO[B]) Operator[A, B] {
return INTA.ApSecond(
return apply.ApSecond(
MonadAp[B, B],
MonadMap[A, func(B) B],
@ -226,11 +226,11 @@ func Defer[A any](gen func() IO[A]) IO[A] {
}
func MonadFlap[B, A any](fab IO[func(A) B], a A) IO[B] {
return INTF.MonadFlap(MonadMap[func(A) B, B], fab, a)
return functor.MonadFlap(MonadMap[func(A) B, B], fab, a)
}
func Flap[B, A any](a A) Operator[func(A) B, B] {
return INTF.Flap(Map[func(A) B, B], a)
return functor.Flap(Map[func(A) B, B], a)
}
// Delay creates an operation that passes in the value after some delay

2627
v2/ioeither/gen.go
View File

File diff suppressed because it is too large Load Diff

188
v2/ioeither/generic/gen.go
View File

@ -3,183 +3,193 @@
// 2025-03-07 23:16:04.9724675 +0100 CET m=+0.002696101
package generic
import (
ET "github.com/IBM/fp-go/v2/either"
)
// Eitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [GIOA]
func Eitherize0[GIOA ~func() ET.Either[error, R], F ~func() (R, error), R any](f F) func() GIOA {
e := ET.Eitherize0(f)
return func() GIOA {
return func() ET.Either[error, R] {
return e()
}}
e := ET.Eitherize0(f)
return func() GIOA {
return func() ET.Either[error, R] {
return e()
}
}
}
// Uneitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [GIOA]
func Uneitherize0[GIOA ~func() ET.Either[error, R], GTA ~func() GIOA, R any](f GTA) func() (R, error) {
return func() (R, error) {
return ET.Unwrap(f()())
}
return func() (R, error) {
return ET.Unwrap(f()())
}
}
// Eitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [GIOA]
func Eitherize1[GIOA ~func() ET.Either[error, R], F ~func(T1) (R, error), T1, R any](f F) func(T1) GIOA {
e := ET.Eitherize1(f)
return func(t1 T1) GIOA {
return func() ET.Either[error, R] {
return e(t1)
}}
e := ET.Eitherize1(f)
return func(t1 T1) GIOA {
return func() ET.Either[error, R] {
return e(t1)
}
}
}
// Uneitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [GIOA]
func Uneitherize1[GIOA ~func() ET.Either[error, R], GTA ~func(T1) GIOA, T1, R any](f GTA) func(T1) (R, error) {
return func(t1 T1) (R, error) {
return ET.Unwrap(f(t1)())
}
return func(t1 T1) (R, error) {
return ET.Unwrap(f(t1)())
}
}
// Eitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning a [GIOA]
func Eitherize2[GIOA ~func() ET.Either[error, R], F ~func(T1, T2) (R, error), T1, T2, R any](f F) func(T1, T2) GIOA {
e := ET.Eitherize2(f)
return func(t1 T1, t2 T2) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2)
}}
e := ET.Eitherize2(f)
return func(t1 T1, t2 T2) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2)
}
}
}
// Uneitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning a [GIOA]
func Uneitherize2[GIOA ~func() ET.Either[error, R], GTA ~func(T1, T2) GIOA, T1, T2, R any](f GTA) func(T1, T2) (R, error) {
return func(t1 T1, t2 T2) (R, error) {
return ET.Unwrap(f(t1, t2)())
}
return func(t1 T1, t2 T2) (R, error) {
return ET.Unwrap(f(t1, t2)())
}
}
// Eitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning a [GIOA]
func Eitherize3[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3) (R, error), T1, T2, T3, R any](f F) func(T1, T2, T3) GIOA {
e := ET.Eitherize3(f)
return func(t1 T1, t2 T2, t3 T3) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3)
}}
e := ET.Eitherize3(f)
return func(t1 T1, t2 T2, t3 T3) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3)
}
}
}
// Uneitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning a [GIOA]
func Uneitherize3[GIOA ~func() ET.Either[error, R], GTA ~func(T1, T2, T3) GIOA, T1, T2, T3, R any](f GTA) func(T1, T2, T3) (R, error) {
return func(t1 T1, t2 T2, t3 T3) (R, error) {
return ET.Unwrap(f(t1, t2, t3)())
}
return func(t1 T1, t2 T2, t3 T3) (R, error) {
return ET.Unwrap(f(t1, t2, t3)())
}
}
// Eitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning a [GIOA]
func Eitherize4[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4) (R, error), T1, T2, T3, T4, R any](f F) func(T1, T2, T3, T4) GIOA {
e := ET.Eitherize4(f)
return func(t1 T1, t2 T2, t3 T3, t4 T4) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4)
}}
e := ET.Eitherize4(f)
return func(t1 T1, t2 T2, t3 T3, t4 T4) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4)
}
}
}
// Uneitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning a [GIOA]
func Uneitherize4[GIOA ~func() ET.Either[error, R], GTA ~func(T1, T2, T3, T4) GIOA, T1, T2, T3, T4, R any](f GTA) func(T1, T2, T3, T4) (R, error) {
return func(t1 T1, t2 T2, t3 T3, t4 T4) (R, error) {
return ET.Unwrap(f(t1, t2, t3, t4)())
}
return func(t1 T1, t2 T2, t3 T3, t4 T4) (R, error) {
return ET.Unwrap(f(t1, t2, t3, t4)())
}
}
// Eitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning a [GIOA]
func Eitherize5[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5) (R, error), T1, T2, T3, T4, T5, R any](f F) func(T1, T2, T3, T4, T5) GIOA {
e := ET.Eitherize5(f)
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5)
}}
e := ET.Eitherize5(f)
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5)
}
}
}
// Uneitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning a [GIOA]
func Uneitherize5[GIOA ~func() ET.Either[error, R], GTA ~func(T1, T2, T3, T4, T5) GIOA, T1, T2, T3, T4, T5, R any](f GTA) func(T1, T2, T3, T4, T5) (R, error) {
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, error) {
return ET.Unwrap(f(t1, t2, t3, t4, t5)())
}
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, error) {
return ET.Unwrap(f(t1, t2, t3, t4, t5)())
}
}
// Eitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning a [GIOA]
func Eitherize6[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6) (R, error), T1, T2, T3, T4, T5, T6, R any](f F) func(T1, T2, T3, T4, T5, T6) GIOA {
e := ET.Eitherize6(f)
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5, t6)
}}
e := ET.Eitherize6(f)
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5, t6)
}
}
}
// Uneitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning a [GIOA]
func Uneitherize6[GIOA ~func() ET.Either[error, R], GTA ~func(T1, T2, T3, T4, T5, T6) GIOA, T1, T2, T3, T4, T5, T6, R any](f GTA) func(T1, T2, T3, T4, T5, T6) (R, error) {
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, error) {
return ET.Unwrap(f(t1, t2, t3, t4, t5, t6)())
}
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, error) {
return ET.Unwrap(f(t1, t2, t3, t4, t5, t6)())
}
}
// Eitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning a [GIOA]
func Eitherize7[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6, T7) (R, error), T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T1, T2, T3, T4, T5, T6, T7) GIOA {
e := ET.Eitherize7(f)
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5, t6, t7)
}}
e := ET.Eitherize7(f)
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5, t6, t7)
}
}
}
// Uneitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning a [GIOA]
func Uneitherize7[GIOA ~func() ET.Either[error, R], GTA ~func(T1, T2, T3, T4, T5, T6, T7) GIOA, T1, T2, T3, T4, T5, T6, T7, R any](f GTA) func(T1, T2, T3, T4, T5, T6, T7) (R, error) {
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, error) {
return ET.Unwrap(f(t1, t2, t3, t4, t5, t6, t7)())
}
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, error) {
return ET.Unwrap(f(t1, t2, t3, t4, t5, t6, t7)())
}
}
// Eitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning a [GIOA]
func Eitherize8[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6, T7, T8) (R, error), T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8) GIOA {
e := ET.Eitherize8(f)
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5, t6, t7, t8)
}}
e := ET.Eitherize8(f)
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5, t6, t7, t8)
}
}
}
// Uneitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning a [GIOA]
func Uneitherize8[GIOA ~func() ET.Either[error, R], GTA ~func(T1, T2, T3, T4, T5, T6, T7, T8) GIOA, T1, T2, T3, T4, T5, T6, T7, T8, R any](f GTA) func(T1, T2, T3, T4, T5, T6, T7, T8) (R, error) {
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, error) {
return ET.Unwrap(f(t1, t2, t3, t4, t5, t6, t7, t8)())
}
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, error) {
return ET.Unwrap(f(t1, t2, t3, t4, t5, t6, t7, t8)())
}
}
// Eitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning a [GIOA]
func Eitherize9[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9) GIOA {
e := ET.Eitherize9(f)
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5, t6, t7, t8, t9)
}}
e := ET.Eitherize9(f)
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5, t6, t7, t8, t9)
}
}
}
// Uneitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning a [GIOA]
func Uneitherize9[GIOA ~func() ET.Either[error, R], GTA ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9) GIOA, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f GTA) func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error) {
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, error) {
return ET.Unwrap(f(t1, t2, t3, t4, t5, t6, t7, t8, t9)())
}
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, error) {
return ET.Unwrap(f(t1, t2, t3, t4, t5, t6, t7, t8, t9)())
}
}
// Eitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning a [GIOA]
func Eitherize10[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) (R, error), T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) GIOA {
e := ET.Eitherize10(f)
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
}}
e := ET.Eitherize10(f)
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
}
}
}
// Uneitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning a [GIOA]
func Uneitherize10[GIOA ~func() ET.Either[error, R], GTA ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) GIOA, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f GTA) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) (R, error) {
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) (R, error) {
return ET.Unwrap(f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)())
}
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) (R, error) {
return ET.Unwrap(f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)())
}
}

4
v2/ioeither/ioeither_test.go
View File

@ -22,8 +22,8 @@ import (
E "github.com/IBM/fp-go/v2/either"
F "github.com/IBM/fp-go/v2/function"
"github.com/IBM/fp-go/v2/internal/utils"
"github.com/IBM/fp-go/v2/io"
I "github.com/IBM/fp-go/v2/io"
IG "github.com/IBM/fp-go/v2/io/generic"
O "github.com/IBM/fp-go/v2/option"
"github.com/stretchr/testify/assert"
)
@ -84,7 +84,7 @@ func TestChainWithIO(t *testing.T) {
r := F.Pipe1(
Of[error]("test"),
// sad, we need the generics version ...
IG.Map[IOEither[error, string], I.IO[bool]](E.IsRight[error, string]),
io.Map(E.IsRight[error, string]),
)
assert.True(t, r())

2583
v2/iooption/gen.go
View File

File diff suppressed because it is too large Load Diff

22
v2/iterator/stateless/types.go Normal file
View File

@ -0,0 +1,22 @@
// 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 stateless
import "github.com/IBM/fp-go/v2/option"
type (
Option[A any] = option.Option[A]
)

30
v2/optics/lens/lens.go
View File

@ -22,14 +22,6 @@ import (
O "github.com/IBM/fp-go/v2/option"
)
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]
}
)
// 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 {
@ -41,8 +33,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[SET ~func(A) Endomorphism[*S], S, A any](setter SET) func(a A) Endomorphism[*S] {
return func(a A) Endomorphism[*S] {
seta := setter(a)
return func(s *S) *S {
cpy := *s
@ -61,7 +53,7 @@ func MakeLens[GET ~func(S) A, SET ~func(S, A) S, S, A any](get GET, set SET) Len
// 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[GET ~func(S) A, SET ~func(A) Endomorphism[S], S, A any](get GET, set SET) Lens[S, A] {
return Lens[S, A]{Get: get, Set: set}
}
@ -77,7 +69,7 @@ func MakeLensRef[GET ~func(*S) A, SET func(*S, A) *S, S, A any](get GET, set SET
// 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] {
func MakeLensRefCurried[S, A any](get func(*S) A, set func(A) Endomorphism[*S]) Lens[*S, A] {
return MakeLensCurried(get, setCopyCurried(set))
}
@ -88,12 +80,12 @@ func id[GET ~func(S) S, SET ~func(S, S) S, S any](creator func(get GET, set SET)
// 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[Endomorphism[S], func(S, S) S])
}
// 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[Endomorphism[*S], func(*S, *S) *S])
}
// Compose combines two lenses and allows to narrow down the focus to a sub-lens
@ -141,7 +133,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) Endomorphism[S] {
setbona := F.Flow2(
ab.Set(b),
seta,
@ -189,15 +181,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]) Endomorphism[S] {
return func(s S) S {
return O.MonadFold(b, func() EM.Endomorphism[S] {
return O.MonadFold(b, func() Endomorphism[S] {
return F.Pipe2(
s,
sa.Get,
O.Fold(noops, F.Flow2(unsetb, seta)),
)
}, func(b B) EM.Endomorphism[S] {
}, func(b B) Endomorphism[S] {
// sets a B onto an A
setb := F.Flow2(
ab.Set(O.Some(b)),
@ -227,7 +219,7 @@ func modify[FCT ~func(A) A, S, A any](f FCT, sa Lens[S, A], s S) S {
// 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] {
func Modify[S any, FCT ~func(A) A, A any](f FCT) func(Lens[S, A]) Endomorphism[S] {
return EM.Curry3(modify[FCT, S, A])(f)
}

31
v2/optics/lens/types.go Normal file
View File

@ -0,0 +1,31 @@
// 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.
// Lens is an optic used to zoom inside a product.
package lens
import (
"github.com/IBM/fp-go/v2/endomorphism"
)
type (
Endomorphism[A any] = endomorphism.Endomorphism[A]
// 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) Endomorphism[S]
}
)

6
v2/option/core.go
View File

@ -35,7 +35,7 @@ type Option[A any] struct {
// optString prints some debug info for the object
//
// go:noinline
//go:noinline
func optString(isSome bool, value any) string {
if isSome {
return fmt.Sprintf("Some[%T](%v)", value, value)
@ -45,7 +45,7 @@ func optString(isSome bool, value any) string {
// optFormat prints some debug info for the object
//
// go:noinline
//go:noinline
func optFormat(isSome bool, value any, f fmt.State, c rune) {
switch c {
case 's':
@ -78,7 +78,7 @@ func (s Option[A]) MarshalJSON() ([]byte, error) {
// optUnmarshalJSON unmarshals the [Option] from a JSON string
//
// go:noinline
//go:noinline
func optUnmarshalJSON(isSome *bool, value any, data []byte) error {
// decode the value
if bytes.Equal(data, jsonNull) {

948
v2/option/gen.go
View File

File diff suppressed because it is too large Load Diff

13
v2/pair/pair.go
View File

@ -23,25 +23,16 @@ import (
T "github.com/IBM/fp-go/v2/tuple"
)
type (
pair struct {
h, t any
}
// Pair defines a data structure that holds two strongly typed values
Pair[A, B any] pair
)
// String prints some debug info for the object
//
// go:noinline
//go:noinline
func pairString(s *pair) string {
return fmt.Sprintf("Pair[%T, %T](%v, %v)", s.h, s.t, s.h, s.t)
}
// Format prints some debug info for the object
//
// go:noinline
//go:noinline
func pairFormat(e *pair, f fmt.State, c rune) {
switch c {
case 's':

25
v2/pair/types.go Normal file
View File

@ -0,0 +1,25 @@
// Copyright (c) 2024 IBM Corp.
// All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package pair
type (
pair struct {
h, t any
}
// Pair defines a data structure that holds two strongly typed values
Pair[L, R any] pair
)

25
v2/reader/gen.go
View File

@ -4,73 +4,72 @@
package reader
import (
G "github.com/IBM/fp-go/v2/reader/generic"
G "github.com/IBM/fp-go/v2/reader/generic"
)
// From0 converts a function with 1 parameters returning a [R] into a function with 0 parameters returning a [Reader[C, R]]
// The first parameter is considered to be the context [C] of the reader
func From0[F ~func(C) R, C, R any](f F) func() Reader[C, R] {
return G.From0[Reader[C, R]](f)
return G.From0[Reader[C, R]](f)
}
// From1 converts a function with 2 parameters returning a [R] into a function with 1 parameters returning a [Reader[C, R]]
// The first parameter is considered to be the context [C] of the reader
func From1[F ~func(C, T0) R, T0, C, R any](f F) func(T0) Reader[C, R] {
return G.From1[Reader[C, R]](f)
return G.From1[Reader[C, R]](f)
}
// From2 converts a function with 3 parameters returning a [R] into a function with 2 parameters returning a [Reader[C, R]]
// The first parameter is considered to be the context [C] of the reader
func From2[F ~func(C, T0, T1) R, T0, T1, C, R any](f F) func(T0, T1) Reader[C, R] {
return G.From2[Reader[C, R]](f)
return G.From2[Reader[C, R]](f)
}
// From3 converts a function with 4 parameters returning a [R] into a function with 3 parameters returning a [Reader[C, R]]
// The first parameter is considered to be the context [C] of the reader
func From3[F ~func(C, T0, T1, T2) R, T0, T1, T2, C, R any](f F) func(T0, T1, T2) Reader[C, R] {
return G.From3[Reader[C, R]](f)
return G.From3[Reader[C, R]](f)
}
// From4 converts a function with 5 parameters returning a [R] into a function with 4 parameters returning a [Reader[C, R]]
// The first parameter is considered to be the context [C] of the reader
func From4[F ~func(C, T0, T1, T2, T3) R, T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) Reader[C, R] {
return G.From4[Reader[C, R]](f)
return G.From4[Reader[C, R]](f)
}
// From5 converts a function with 6 parameters returning a [R] into a function with 5 parameters returning a [Reader[C, R]]
// The first parameter is considered to be the context [C] of the reader
func From5[F ~func(C, T0, T1, T2, T3, T4) R, T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) Reader[C, R] {
return G.From5[Reader[C, R]](f)
return G.From5[Reader[C, R]](f)
}
// From6 converts a function with 7 parameters returning a [R] into a function with 6 parameters returning a [Reader[C, R]]
// The first parameter is considered to be the context [C] of the reader
func From6[F ~func(C, T0, T1, T2, T3, T4, T5) R, T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) Reader[C, R] {
return G.From6[Reader[C, R]](f)
return G.From6[Reader[C, R]](f)
}
// From7 converts a function with 8 parameters returning a [R] into a function with 7 parameters returning a [Reader[C, R]]
// The first parameter is considered to be the context [C] of the reader
func From7[F ~func(C, T0, T1, T2, T3, T4, T5, T6) R, T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) Reader[C, R] {
return G.From7[Reader[C, R]](f)
return G.From7[Reader[C, R]](f)
}
// From8 converts a function with 9 parameters returning a [R] into a function with 8 parameters returning a [Reader[C, R]]
// The first parameter is considered to be the context [C] of the reader
func From8[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) R, T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) Reader[C, R] {
return G.From8[Reader[C, R]](f)
return G.From8[Reader[C, R]](f)
}
// From9 converts a function with 10 parameters returning a [R] into a function with 9 parameters returning a [Reader[C, R]]
// The first parameter is considered to be the context [C] of the reader
func From9[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) R, T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) Reader[C, R] {
return G.From9[Reader[C, R]](f)
return G.From9[Reader[C, R]](f)
}
// From10 converts a function with 11 parameters returning a [R] into a function with 10 parameters returning a [Reader[C, R]]
// The first parameter is considered to be the context [C] of the reader
func From10[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) Reader[C, R] {
return G.From10[Reader[C, R]](f)
return G.From10[Reader[C, R]](f)
}

111
v2/reader/generic/gen.go
View File

@ -3,113 +3,112 @@
// 2025-03-07 23:16:09.1430409 +0100 CET m=+0.002133701
package generic
// From0 converts a function with 1 parameters returning a [R] into a function with 0 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func From0[GRA ~func(C) R, F ~func(C) R, C, R any](f F) func() GRA {
return func() GRA {
return MakeReader[GRA](func(r C) R {
return f(r)
})
}
return func() GRA {
return MakeReader[GRA](func(r C) R {
return f(r)
})
}
}
// From1 converts a function with 2 parameters returning a [R] into a function with 1 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func From1[GRA ~func(C) R, F ~func(C, T0) R, T0, C, R any](f F) func(T0) GRA {
return func(t0 T0) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0)
})
}
return func(t0 T0) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0)
})
}
}
// From2 converts a function with 3 parameters returning a [R] into a function with 2 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func From2[GRA ~func(C) R, F ~func(C, T0, T1) R, T0, T1, C, R any](f F) func(T0, T1) GRA {
return func(t0 T0, t1 T1) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0, t1)
})
}
return func(t0 T0, t1 T1) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0, t1)
})
}
}
// From3 converts a function with 4 parameters returning a [R] into a function with 3 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func From3[GRA ~func(C) R, F ~func(C, T0, T1, T2) R, T0, T1, T2, C, R any](f F) func(T0, T1, T2) GRA {
return func(t0 T0, t1 T1, t2 T2) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0, t1, t2)
})
}
return func(t0 T0, t1 T1, t2 T2) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0, t1, t2)
})
}
}
// From4 converts a function with 5 parameters returning a [R] into a function with 4 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func From4[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3) R, T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) GRA {
return func(t0 T0, t1 T1, t2 T2, t3 T3) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0, t1, t2, t3)
})
}
return func(t0 T0, t1 T1, t2 T2, t3 T3) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0, t1, t2, t3)
})
}
}
// From5 converts a function with 6 parameters returning a [R] into a function with 5 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func From5[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4) R, T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) GRA {
return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0, t1, t2, t3, t4)
})
}
return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0, t1, t2, t3, t4)
})
}
}
// From6 converts a function with 7 parameters returning a [R] into a function with 6 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func From6[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4, T5) R, T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) GRA {
return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0, t1, t2, t3, t4, t5)
})
}
return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0, t1, t2, t3, t4, t5)
})
}
}
// From7 converts a function with 8 parameters returning a [R] into a function with 7 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func From7[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4, T5, T6) R, T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) GRA {
return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0, t1, t2, t3, t4, t5, t6)
})
}
return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0, t1, t2, t3, t4, t5, t6)
})
}
}
// From8 converts a function with 9 parameters returning a [R] into a function with 8 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func From8[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) R, T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) GRA {
return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, 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 T7) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0, t1, t2, t3, t4, t5, t6, t7)
})
}
}
// From9 converts a function with 10 parameters returning a [R] into a function with 9 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func From9[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) R, T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA {
return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, 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 T8) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8)
})
}
}
// From10 converts a function with 11 parameters returning a [R] into a function with 10 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func From10[GRA ~func(C) R, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA {
return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, 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 T9) GRA {
return MakeReader[GRA](func(r C) R {
return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
})
}
}

69
v2/readerioeither/gen.go
View File

@ -4,205 +4,204 @@
package readerioeither
import (
G "github.com/IBM/fp-go/v2/readerioeither/generic"
G "github.com/IBM/fp-go/v2/readerioeither/generic"
)
// From0 converts a function with 1 parameters returning a tuple into a function with 0 parameters returning a [ReaderIOEither[R]]
// The first parameter is considered to be the context [C].
func From0[F ~func(C) func() (R, error), C, R any](f F) func() ReaderIOEither[C, error, R] {
return G.From0[ReaderIOEither[C, error, R]](f)
return G.From0[ReaderIOEither[C, error, R]](f)
}
// Eitherize0 converts a function with 1 parameters returning a tuple into a function with 0 parameters returning a [ReaderIOEither[C, error, R]]
// The first parameter is considered to be the context [C].
func Eitherize0[F ~func(C) (R, error), C, R any](f F) func() ReaderIOEither[C, error, R] {
return G.Eitherize0[ReaderIOEither[C, error, R]](f)
return G.Eitherize0[ReaderIOEither[C, error, R]](f)
}
// Uneitherize0 converts a function with 1 parameters returning a [ReaderIOEither[C, error, R]] into a function with 0 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize0[F ~func() ReaderIOEither[C, error, R], C, R any](f F) func(C) (R, error) {
return G.Uneitherize0[ReaderIOEither[C, error, R], func(C)(R, error)](f)
return G.Uneitherize0[ReaderIOEither[C, error, R], func(C) (R, error)](f)
}
// From1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [ReaderIOEither[R]]
// The first parameter is considered to be the context [C].
func From1[F ~func(C, T0) func() (R, error), T0, C, R any](f F) func(T0) ReaderIOEither[C, error, R] {
return G.From1[ReaderIOEither[C, error, R]](f)
return G.From1[ReaderIOEither[C, error, R]](f)
}
// Eitherize1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [ReaderIOEither[C, error, R]]
// The first parameter is considered to be the context [C].
func Eitherize1[F ~func(C, T0) (R, error), T0, C, R any](f F) func(T0) ReaderIOEither[C, error, R] {
return G.Eitherize1[ReaderIOEither[C, error, R]](f)
return G.Eitherize1[ReaderIOEither[C, error, R]](f)
}
// Uneitherize1 converts a function with 2 parameters returning a [ReaderIOEither[C, error, R]] into a function with 1 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize1[F ~func(T0) ReaderIOEither[C, error, R], T0, C, R any](f F) func(C, T0) (R, error) {
return G.Uneitherize1[ReaderIOEither[C, error, R], func(C, T0)(R, error)](f)
return G.Uneitherize1[ReaderIOEither[C, error, R], func(C, T0) (R, error)](f)
}
// From2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [ReaderIOEither[R]]
// The first parameter is considered to be the context [C].
func From2[F ~func(C, T0, T1) func() (R, error), T0, T1, C, R any](f F) func(T0, T1) ReaderIOEither[C, error, R] {
return G.From2[ReaderIOEither[C, error, R]](f)
return G.From2[ReaderIOEither[C, error, R]](f)
}
// Eitherize2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [ReaderIOEither[C, error, R]]
// The first parameter is considered to be the context [C].
func Eitherize2[F ~func(C, T0, T1) (R, error), T0, T1, C, R any](f F) func(T0, T1) ReaderIOEither[C, error, R] {
return G.Eitherize2[ReaderIOEither[C, error, R]](f)
return G.Eitherize2[ReaderIOEither[C, error, R]](f)
}
// Uneitherize2 converts a function with 3 parameters returning a [ReaderIOEither[C, error, R]] into a function with 2 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize2[F ~func(T0, T1) ReaderIOEither[C, error, R], T0, T1, C, R any](f F) func(C, T0, T1) (R, error) {
return G.Uneitherize2[ReaderIOEither[C, error, R], func(C, T0, T1)(R, error)](f)
return G.Uneitherize2[ReaderIOEither[C, error, R], func(C, T0, T1) (R, error)](f)
}
// From3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [ReaderIOEither[R]]
// The first parameter is considered to be the context [C].
func From3[F ~func(C, T0, T1, T2) func() (R, error), T0, T1, T2, C, R any](f F) func(T0, T1, T2) ReaderIOEither[C, error, R] {
return G.From3[ReaderIOEither[C, error, R]](f)
return G.From3[ReaderIOEither[C, error, R]](f)
}
// Eitherize3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [ReaderIOEither[C, error, R]]
// The first parameter is considered to be the context [C].
func Eitherize3[F ~func(C, T0, T1, T2) (R, error), T0, T1, T2, C, R any](f F) func(T0, T1, T2) ReaderIOEither[C, error, R] {
return G.Eitherize3[ReaderIOEither[C, error, R]](f)
return G.Eitherize3[ReaderIOEither[C, error, R]](f)
}
// Uneitherize3 converts a function with 4 parameters returning a [ReaderIOEither[C, error, R]] into a function with 3 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize3[F ~func(T0, T1, T2) ReaderIOEither[C, error, R], T0, T1, T2, C, R any](f F) func(C, T0, T1, T2) (R, error) {
return G.Uneitherize3[ReaderIOEither[C, error, R], func(C, T0, T1, T2)(R, error)](f)
return G.Uneitherize3[ReaderIOEither[C, error, R], func(C, T0, T1, T2) (R, error)](f)
}
// From4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [ReaderIOEither[R]]
// The first parameter is considered to be the context [C].
func From4[F ~func(C, T0, T1, T2, T3) func() (R, error), T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) ReaderIOEither[C, error, R] {
return G.From4[ReaderIOEither[C, error, R]](f)
return G.From4[ReaderIOEither[C, error, R]](f)
}
// Eitherize4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [ReaderIOEither[C, error, R]]
// The first parameter is considered to be the context [C].
func Eitherize4[F ~func(C, T0, T1, T2, T3) (R, error), T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) ReaderIOEither[C, error, R] {
return G.Eitherize4[ReaderIOEither[C, error, R]](f)
return G.Eitherize4[ReaderIOEither[C, error, R]](f)
}
// Uneitherize4 converts a function with 5 parameters returning a [ReaderIOEither[C, error, R]] into a function with 4 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize4[F ~func(T0, T1, T2, T3) ReaderIOEither[C, error, R], T0, T1, T2, T3, C, R any](f F) func(C, T0, T1, T2, T3) (R, error) {
return G.Uneitherize4[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3)(R, error)](f)
return G.Uneitherize4[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3) (R, error)](f)
}
// From5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [ReaderIOEither[R]]
// The first parameter is considered to be the context [C].
func From5[F ~func(C, T0, T1, T2, T3, T4) func() (R, error), T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) ReaderIOEither[C, error, R] {
return G.From5[ReaderIOEither[C, error, R]](f)
return G.From5[ReaderIOEither[C, error, R]](f)
}
// Eitherize5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [ReaderIOEither[C, error, R]]
// The first parameter is considered to be the context [C].
func Eitherize5[F ~func(C, T0, T1, T2, T3, T4) (R, error), T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) ReaderIOEither[C, error, R] {
return G.Eitherize5[ReaderIOEither[C, error, R]](f)
return G.Eitherize5[ReaderIOEither[C, error, R]](f)
}
// Uneitherize5 converts a function with 6 parameters returning a [ReaderIOEither[C, error, R]] into a function with 5 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize5[F ~func(T0, T1, T2, T3, T4) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, C, R any](f F) func(C, T0, T1, T2, T3, T4) (R, error) {
return G.Uneitherize5[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4)(R, error)](f)
return G.Uneitherize5[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4) (R, error)](f)
}
// From6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [ReaderIOEither[R]]
// The first parameter is considered to be the context [C].
func From6[F ~func(C, T0, T1, T2, T3, T4, T5) func() (R, error), T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) ReaderIOEither[C, error, R] {
return G.From6[ReaderIOEither[C, error, R]](f)
return G.From6[ReaderIOEither[C, error, R]](f)
}
// Eitherize6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [ReaderIOEither[C, error, R]]
// The first parameter is considered to be the context [C].
func Eitherize6[F ~func(C, T0, T1, T2, T3, T4, T5) (R, error), T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) ReaderIOEither[C, error, R] {
return G.Eitherize6[ReaderIOEither[C, error, R]](f)
return G.Eitherize6[ReaderIOEither[C, error, R]](f)
}
// Uneitherize6 converts a function with 7 parameters returning a [ReaderIOEither[C, error, R]] into a function with 6 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize6[F ~func(T0, T1, T2, T3, T4, T5) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5) (R, error) {
return G.Uneitherize6[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5)(R, error)](f)
return G.Uneitherize6[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5) (R, error)](f)
}
// From7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [ReaderIOEither[R]]
// The first parameter is considered to be the context [C].
func From7[F ~func(C, T0, T1, T2, T3, T4, T5, T6) func() (R, error), T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) ReaderIOEither[C, error, R] {
return G.From7[ReaderIOEither[C, error, R]](f)
return G.From7[ReaderIOEither[C, error, R]](f)
}
// Eitherize7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [ReaderIOEither[C, error, R]]
// The first parameter is considered to be the context [C].
func Eitherize7[F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R, error), T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) ReaderIOEither[C, error, R] {
return G.Eitherize7[ReaderIOEither[C, error, R]](f)
return G.Eitherize7[ReaderIOEither[C, error, R]](f)
}
// Uneitherize7 converts a function with 8 parameters returning a [ReaderIOEither[C, error, R]] into a function with 7 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize7[F ~func(T0, T1, T2, T3, T4, T5, T6) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5, T6) (R, error) {
return G.Uneitherize7[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6)(R, error)](f)
return G.Uneitherize7[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6) (R, error)](f)
}
// From8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [ReaderIOEither[R]]
// The first parameter is considered to be the context [C].
func From8[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) func() (R, error), T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) ReaderIOEither[C, error, R] {
return G.From8[ReaderIOEither[C, error, R]](f)
return G.From8[ReaderIOEither[C, error, R]](f)
}
// Eitherize8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [ReaderIOEither[C, error, R]]
// The first parameter is considered to be the context [C].
func Eitherize8[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) ReaderIOEither[C, error, R] {
return G.Eitherize8[ReaderIOEither[C, error, R]](f)
return G.Eitherize8[ReaderIOEither[C, error, R]](f)
}
// Uneitherize8 converts a function with 9 parameters returning a [ReaderIOEither[C, error, R]] into a function with 8 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error) {
return G.Uneitherize8[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6, T7)(R, error)](f)
return G.Uneitherize8[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error)](f)
}
// From9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [ReaderIOEither[R]]
// The first parameter is considered to be the context [C].
func From9[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) func() (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) ReaderIOEither[C, error, R] {
return G.From9[ReaderIOEither[C, error, R]](f)
return G.From9[ReaderIOEither[C, error, R]](f)
}
// Eitherize9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [ReaderIOEither[C, error, R]]
// The first parameter is considered to be the context [C].
func Eitherize9[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) ReaderIOEither[C, error, R] {
return G.Eitherize9[ReaderIOEither[C, error, R]](f)
return G.Eitherize9[ReaderIOEither[C, error, R]](f)
}
// Uneitherize9 converts a function with 10 parameters returning a [ReaderIOEither[C, error, R]] into a function with 9 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error) {
return G.Uneitherize9[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8)(R, error)](f)
return G.Uneitherize9[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error)](f)
}
// From10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [ReaderIOEither[R]]
// The first parameter is considered to be the context [C].
func From10[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) func() (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[C, error, R] {
return G.From10[ReaderIOEither[C, error, R]](f)
return G.From10[ReaderIOEither[C, error, R]](f)
}
// Eitherize10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [ReaderIOEither[C, error, R]]
// The first parameter is considered to be the context [C].
func Eitherize10[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[C, error, R] {
return G.Eitherize10[ReaderIOEither[C, error, R]](f)
return G.Eitherize10[ReaderIOEither[C, error, R]](f)
}
// Uneitherize10 converts a function with 11 parameters returning a [ReaderIOEither[C, error, R]] into a function with 10 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error) {
return G.Uneitherize10[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)(R, error)](f)
return G.Uneitherize10[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error)](f)
}

232
v2/readerioeither/generic/gen.go
View File

@ -3,7 +3,6 @@
// 2025-03-07 23:16:11.0357415 +0100 CET m=+0.045725301
package generic
import (
E "github.com/IBM/fp-go/v2/either"
RD "github.com/IBM/fp-go/v2/reader/generic"
@ -12,274 +11,285 @@ import (
// From0 converts a function with 1 parameters returning a tuple into a function with 0 parameters returning a [GRA]
// The first parameter is considerd to be the context [C].
func From0[GRA ~func(C) GIOA, F ~func(C) func() (R, error), GIOA ~func() E.Either[error, R], C, R any](f F) func() GRA {
return RD.From0[GRA](func(r C) GIOA {
return E.Eitherize0(f(r))
})
return RD.From0[GRA](func(r C) GIOA {
return E.Eitherize0(f(r))
})
}
// Eitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func Eitherize0[GRA ~func(C) GIOA, F ~func(C) (R, error), GIOA ~func() E.Either[error, R], C, R any](f F) func() GRA {
return From0[GRA](func(r C) func() (R, error) {
return func() (R, error) {
return f(r)
}})
return From0[GRA](func(r C) func() (R, error) {
return func() (R, error) {
return f(r)
}
})
}
// Uneitherize0 converts a function with 0 parameters returning a [GRA] into a function with 0 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize0[GRA ~func(C) GIOA, F ~func(C) (R, error), GIOA ~func() E.Either[error, R], C, R any](f func() GRA) F {
return func(c C) (R, error) {
return E.UnwrapError(f()(c)())
}
return func(c C) (R, error) {
return E.UnwrapError(f()(c)())
}
}
// From1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [GRA]
// The first parameter is considerd to be the context [C].
func From1[GRA ~func(C) GIOA, F ~func(C, T0) func() (R, error), GIOA ~func() E.Either[error, R], T0, C, R any](f F) func(T0) GRA {
return RD.From1[GRA](func(r C, t0 T0) GIOA {
return E.Eitherize0(f(r, t0))
})
return RD.From1[GRA](func(r C, t0 T0) GIOA {
return E.Eitherize0(f(r, t0))
})
}
// Eitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func Eitherize1[GRA ~func(C) GIOA, F ~func(C, T0) (R, error), GIOA ~func() E.Either[error, R], T0, C, R any](f F) func(T0) GRA {
return From1[GRA](func(r C, t0 T0) func() (R, error) {
return func() (R, error) {
return f(r, t0)
}})
return From1[GRA](func(r C, t0 T0) func() (R, error) {
return func() (R, error) {
return f(r, t0)
}
})
}
// Uneitherize1 converts a function with 1 parameters returning a [GRA] into a function with 1 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize1[GRA ~func(C) GIOA, F ~func(C, T0) (R, error), GIOA ~func() E.Either[error, R], T0, C, R any](f func(T0) GRA) F {
return func(c C, t0 T0) (R, error) {
return E.UnwrapError(f(t0)(c)())
}
return func(c C, t0 T0) (R, error) {
return E.UnwrapError(f(t0)(c)())
}
}
// From2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [GRA]
// The first parameter is considerd to be the context [C].
func From2[GRA ~func(C) GIOA, F ~func(C, T0, T1) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, C, R any](f F) func(T0, T1) GRA {
return RD.From2[GRA](func(r C, t0 T0, t1 T1) GIOA {
return E.Eitherize0(f(r, t0, t1))
})
return RD.From2[GRA](func(r C, t0 T0, t1 T1) GIOA {
return E.Eitherize0(f(r, t0, t1))
})
}
// Eitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func Eitherize2[GRA ~func(C) GIOA, F ~func(C, T0, T1) (R, error), GIOA ~func() E.Either[error, R], T0, T1, C, R any](f F) func(T0, T1) GRA {
return From2[GRA](func(r C, t0 T0, t1 T1) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1)
}})
return From2[GRA](func(r C, t0 T0, t1 T1) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1)
}
})
}
// Uneitherize2 converts a function with 2 parameters returning a [GRA] into a function with 2 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize2[GRA ~func(C) GIOA, F ~func(C, T0, T1) (R, error), GIOA ~func() E.Either[error, R], T0, T1, C, R any](f func(T0, T1) GRA) F {
return func(c C, t0 T0, t1 T1) (R, error) {
return E.UnwrapError(f(t0, t1)(c)())
}
return func(c C, t0 T0, t1 T1) (R, error) {
return E.UnwrapError(f(t0, t1)(c)())
}
}
// From3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [GRA]
// The first parameter is considerd to be the context [C].
func From3[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, C, R any](f F) func(T0, T1, T2) GRA {
return RD.From3[GRA](func(r C, t0 T0, t1 T1, t2 T2) GIOA {
return E.Eitherize0(f(r, t0, t1, t2))
})
return RD.From3[GRA](func(r C, t0 T0, t1 T1, t2 T2) GIOA {
return E.Eitherize0(f(r, t0, t1, t2))
})
}
// Eitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func Eitherize3[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, C, R any](f F) func(T0, T1, T2) GRA {
return From3[GRA](func(r C, t0 T0, t1 T1, t2 T2) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2)
}})
return From3[GRA](func(r C, t0 T0, t1 T1, t2 T2) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2)
}
})
}
// Uneitherize3 converts a function with 3 parameters returning a [GRA] into a function with 3 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize3[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, C, R any](f func(T0, T1, T2) GRA) F {
return func(c C, t0 T0, t1 T1, t2 T2) (R, error) {
return E.UnwrapError(f(t0, t1, t2)(c)())
}
return func(c C, t0 T0, t1 T1, t2 T2) (R, error) {
return E.UnwrapError(f(t0, t1, t2)(c)())
}
}
// From4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [GRA]
// The first parameter is considerd to be the context [C].
func From4[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) GRA {
return RD.From4[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3) GIOA {
return E.Eitherize0(f(r, t0, t1, t2, t3))
})
return RD.From4[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3) GIOA {
return E.Eitherize0(f(r, t0, t1, t2, t3))
})
}
// Eitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func Eitherize4[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) GRA {
return From4[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3)
}})
return From4[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3)
}
})
}
// Uneitherize4 converts a function with 4 parameters returning a [GRA] into a function with 4 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize4[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, C, R any](f func(T0, T1, T2, T3) GRA) F {
return func(c C, t0 T0, t1 T1, t2 T2, t3 T3) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3)(c)())
}
return func(c C, t0 T0, t1 T1, t2 T2, t3 T3) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3)(c)())
}
}
// From5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [GRA]
// The first parameter is considerd to be the context [C].
func From5[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) GRA {
return RD.From5[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) GIOA {
return E.Eitherize0(f(r, t0, t1, t2, t3, t4))
})
return RD.From5[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) GIOA {
return E.Eitherize0(f(r, t0, t1, t2, t3, t4))
})
}
// Eitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func Eitherize5[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) GRA {
return From5[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4)
}})
return From5[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4)
}
})
}
// Uneitherize5 converts a function with 5 parameters returning a [GRA] into a function with 5 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize5[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, C, R any](f func(T0, T1, T2, T3, T4) GRA) F {
return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4)(c)())
}
return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4)(c)())
}
}
// From6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [GRA]
// The first parameter is considerd to be the context [C].
func From6[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) GRA {
return RD.From6[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GIOA {
return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5))
})
return RD.From6[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GIOA {
return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5))
})
}
// Eitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func Eitherize6[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) GRA {
return From6[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4, t5)
}})
return From6[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4, t5)
}
})
}
// Uneitherize6 converts a function with 6 parameters returning a [GRA] into a function with 6 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize6[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, C, R any](f func(T0, T1, T2, T3, T4, T5) GRA) F {
return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5)(c)())
}
return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5)(c)())
}
}
// From7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [GRA]
// The first parameter is considerd to be the context [C].
func From7[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) GRA {
return RD.From7[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GIOA {
return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6))
})
return RD.From7[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GIOA {
return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6))
})
}
// Eitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func Eitherize7[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) GRA {
return From7[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4, t5, t6)
}})
return From7[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4, t5, t6)
}
})
}
// Uneitherize7 converts a function with 7 parameters returning a [GRA] into a function with 7 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize7[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, C, R any](f func(T0, T1, T2, T3, T4, T5, T6) GRA) F {
return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6)(c)())
}
return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6)(c)())
}
}
// From8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [GRA]
// The first parameter is considerd to be the context [C].
func From8[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) GRA {
return RD.From8[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GIOA {
return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6, t7))
})
return RD.From8[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GIOA {
return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6, t7))
})
}
// Eitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func Eitherize8[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) GRA {
return From8[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4, t5, t6, t7)
}})
return From8[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4, t5, t6, t7)
}
})
}
// Uneitherize8 converts a function with 8 parameters returning a [GRA] into a function with 8 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize8[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7) GRA) F {
return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7)(c)())
}
return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7)(c)())
}
}
// From9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [GRA]
// The first parameter is considerd to be the context [C].
func From9[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA {
return RD.From9[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GIOA {
return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8))
})
return RD.From9[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GIOA {
return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8))
})
}
// Eitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func Eitherize9[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA {
return From9[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8)
}})
return From9[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8)
}
})
}
// Uneitherize9 converts a function with 9 parameters returning a [GRA] into a function with 9 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize9[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA) F {
return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8)(c)())
}
return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8)(c)())
}
}
// From10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [GRA]
// The first parameter is considerd to be the context [C].
func From10[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA {
return RD.From10[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GIOA {
return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9))
})
return RD.From10[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GIOA {
return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9))
})
}
// Eitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func Eitherize10[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA {
return From10[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
}})
return From10[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
}
})
}
// Uneitherize10 converts a function with 10 parameters returning a [GRA] into a function with 10 parameters returning a tuple.
// The first parameter is considered to be the context [C].
func Uneitherize10[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA) F {
return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)(c)())
}
return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, error) {
return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)(c)())
}
}

8
v2/retry/retry.go
View File

@ -31,14 +31,14 @@ type RetryStatus struct {
// Delay incurred so far from retries
CumulativeDelay time.Duration
// Latest attempt's delay. Will always be `none` on first run.
PreviousDelay O.Option[time.Duration]
PreviousDelay Option[time.Duration]
}
// RetryPolicy is a function that takes an `RetryStatus` and
// possibly returns a delay in milliseconds. Iteration numbers start
// at zero and increase by one on each retry. A //None// return value from
// the function implies we have reached the retry limit.
type RetryPolicy = func(RetryStatus) O.Option[time.Duration]
type RetryPolicy = func(RetryStatus) Option[time.Duration]
const emptyDuration = time.Duration(0)
@ -63,7 +63,7 @@ func LimitRetries(i uint) RetryPolicy {
return value < i
}
empty := F.Constant1[uint](emptyDuration)
return func(status RetryStatus) O.Option[time.Duration] {
return func(status RetryStatus) Option[time.Duration] {
return F.Pipe2(
status.IterNumber,
O.FromPredicate(pred),
@ -93,7 +93,7 @@ func CapDelay(maxDelay time.Duration, policy RetryPolicy) RetryPolicy {
// ExponentialBackoff grows delay exponentially each iteration.
// Each delay will increase by a factor of two.
func ExponentialBackoff(delay time.Duration) RetryPolicy {
return func(status RetryStatus) O.Option[time.Duration] {
return func(status RetryStatus) Option[time.Duration] {
return O.Some(delay * time.Duration(math.Pow(2, float64(status.IterNumber))))
}
}

4
v2/iooption/generic/types.go → v2/retry/types.go
View File

@ -1,4 +1,4 @@
// Copyright (c) 2025 IBM Corp.
// Copyright (c) 2023 IBM Corp.
// All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package generic
package retry
import "github.com/IBM/fp-go/v2/option"

10
v2/semigroup/ord/semigroup.go
View File

@ -16,16 +16,16 @@
package ord
import (
O "github.com/IBM/fp-go/v2/ord"
"github.com/IBM/fp-go/v2/ord"
S "github.com/IBM/fp-go/v2/semigroup"
)
// Max gets a semigroup where `concat` will return the maximum, based on the provided order.
func Max[A any](o O.Ord[A]) S.Semigroup[A] {
return S.MakeSemigroup(O.Max(o))
func Max[A any](o ord.Ord[A]) S.Semigroup[A] {
return S.MakeSemigroup(ord.Max(o))
}
// Min gets a semigroup where `concat` will return the minimum, based on the provided order.
func Min[A any](o O.Ord[A]) S.Semigroup[A] {
return S.MakeSemigroup(O.Min(o))
func Min[A any](o ord.Ord[A]) S.Semigroup[A] {
return S.MakeSemigroup(ord.Min(o))
}

92
v2/state/state.go
View File

@ -16,82 +16,118 @@
package state
import (
P "github.com/IBM/fp-go/v2/pair"
R "github.com/IBM/fp-go/v2/reader"
G "github.com/IBM/fp-go/v2/state/generic"
"github.com/IBM/fp-go/v2/function"
"github.com/IBM/fp-go/v2/internal/chain"
"github.com/IBM/fp-go/v2/internal/functor"
"github.com/IBM/fp-go/v2/pair"
)
// State represents an operation on top of a current [State] that produces a value and a new [State]
type State[S, A any] R.Reader[S, P.Pair[A, S]]
var (
undefined any = struct{}{}
)
func Get[S any]() State[S, S] {
return G.Get[State[S, S]]()
return pair.Of[S]
}
func Gets[FCT ~func(S) A, A, S any](f FCT) State[S, A] {
return G.Gets[State[S, A]](f)
return func(s S) Pair[A, S] {
return pair.MakePair(f(s), s)
}
}
func Put[S any]() State[S, any] {
return G.Put[State[S, any]]()
return function.Bind1st(pair.MakePair[any, S], undefined)
}
func Modify[FCT ~func(S) S, S any](f FCT) State[S, any] {
return G.Modify[State[S, any]](f)
return function.Flow2(
f,
function.Bind1st(pair.MakePair[any, S], undefined),
)
}
func Of[S, A any](a A) State[S, A] {
return G.Of[State[S, A]](a)
return function.Bind1st(pair.MakePair[A, S], a)
}
func MonadMap[S any, FCT ~func(A) B, A, B any](fa State[S, A], f FCT) State[S, B] {
return G.MonadMap[State[S, B], State[S, A]](fa, f)
return func(s S) Pair[B, S] {
p2 := fa(s)
return pair.MakePair(f(pair.Head(p2)), pair.Tail(p2))
}
}
func Map[S any, FCT ~func(A) B, A, B any](f FCT) func(State[S, A]) State[S, B] {
return G.Map[State[S, B], State[S, A]](f)
func Map[S any, FCT ~func(A) B, A, B any](f FCT) Operator[S, A, B] {
return function.Bind2nd(MonadMap[S, FCT, A, B], f)
}
func MonadChain[S any, FCT ~func(A) State[S, B], A, B any](fa State[S, A], f FCT) State[S, B] {
return G.MonadChain[State[S, B], State[S, A]](fa, f)
return func(s S) Pair[B, S] {
a := fa(s)
return f(pair.Head(a))(pair.Tail(a))
}
}
func Chain[S any, FCT ~func(A) State[S, B], A, B any](f FCT) func(State[S, A]) State[S, B] {
return G.Chain[State[S, B], State[S, A]](f)
func Chain[S any, FCT ~func(A) State[S, B], A, B any](f FCT) Operator[S, A, B] {
return function.Bind2nd(MonadChain[S, FCT, A, B], f)
}
func MonadAp[S, A, B any](fab State[S, func(A) B], fa State[S, A]) State[S, B] {
return G.MonadAp[State[S, B], State[S, func(A) B], State[S, A]](fab, fa)
return func(s S) Pair[B, S] {
f := fab(s)
a := fa(pair.Tail(f))
return pair.MakePair(pair.Head(f)(pair.Head(a)), pair.Tail(a))
}
}
func Ap[S, A, B any](ga State[S, A]) func(State[S, func(A) B]) State[S, B] {
return G.Ap[State[S, B], State[S, func(A) B], State[S, A]](ga)
func Ap[S, A, B any](ga State[S, A]) Operator[S, func(A) B, B] {
return function.Bind2nd(MonadAp[S, A, B], ga)
}
func MonadChainFirst[S any, FCT ~func(A) State[S, B], A, B any](ma State[S, A], f FCT) State[S, A] {
return G.MonadChainFirst[State[S, B], State[S, A]](ma, f)
return chain.MonadChainFirst(
MonadChain[S, func(A) State[S, A], A, A],
MonadMap[S, func(B) A],
ma,
f,
)
}
func ChainFirst[S any, FCT ~func(A) State[S, B], A, B any](f FCT) func(State[S, A]) State[S, A] {
return G.ChainFirst[State[S, B], State[S, A]](f)
func ChainFirst[S any, FCT ~func(A) State[S, B], A, B any](f FCT) Operator[S, A, A] {
return chain.ChainFirst(
Chain[S, func(A) State[S, A], A, A],
Map[S, func(B) A],
f,
)
}
func Flatten[S, A any](mma State[S, State[S, A]]) State[S, A] {
return G.Flatten[State[S, State[S, A]], State[S, A]](mma)
return MonadChain(mma, function.Identity[State[S, A]])
}
func Execute[A, S any](s S) func(State[S, A]) S {
return G.Execute[State[S, A]](s)
return func(fa State[S, A]) S {
return pair.Tail(fa(s))
}
}
func Evaluate[A, S any](s S) func(State[S, A]) A {
return G.Evaluate[State[S, A]](s)
return func(fa State[S, A]) A {
return pair.Head(fa(s))
}
}
func MonadFlap[FAB ~func(A) B, S, A, B any](fab State[S, FAB], a A) State[S, B] {
return G.MonadFlap[FAB, State[S, FAB], State[S, B], S, A, B](fab, a)
return functor.MonadFlap(
MonadMap[S, func(FAB) B],
fab,
a)
}
func Flap[S, A, B any](a A) func(State[S, func(A) B]) State[S, B] {
return G.Flap[func(A) B, State[S, func(A) B], State[S, B]](a)
func Flap[S, A, B any](a A) Operator[S, func(A) B, B] {
return functor.Flap(
Map[S, func(func(A) B) B],
a)
}

32
v2/state/types.go Normal file
View File

@ -0,0 +1,32 @@
// Copyright (c) 2024 IBM Corp.
// All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package state
import (
"github.com/IBM/fp-go/v2/pair"
"github.com/IBM/fp-go/v2/reader"
)
type (
// some type aliases
Reader[R, A any] = reader.Reader[R, A]
Pair[L, R any] = pair.Pair[L, R]
// State represents an operation on top of a current [State] that produces a value and a new [State]
State[S, A any] = Reader[S, pair.Pair[A, S]]
Operator[S, A, B any] = Reader[State[S, A], State[S, B]]
)

2
v2/statereaderioeither/type.go
View File

@ -21,4 +21,4 @@ import (
RIOE "github.com/IBM/fp-go/v2/readerioeither"
)
type StateReaderIOEither[S, R, E, A any] RD.Reader[S, RIOE.ReaderIOEither[R, E, P.Pair[A, S]]]
type StateReaderIOEither[S, R, E, A any] = RD.Reader[S, RIOE.ReaderIOEither[R, E, P.Pair[A, S]]]

2457
v2/tuple/gen.go
View File

File diff suppressed because it is too large Load Diff