either

func AltSemigroup ¶

func AltSemigroup[E, A any]() S.Semigroup[Either[E, A]]

AltSemigroup creates a semigroup for Either that uses the Alt operation for combining values. When combining two Either values, it returns the first Right value, or the second value if the first is Left.

Example:

sg := either.AltSemigroup[error, int]()
result := sg.Concat(either.Left[int](errors.New("error")), either.Right[error](42))
// result is Right(42)
result2 := sg.Concat(either.Right[error](1), either.Right[error](2))
// result2 is Right(1) - first Right wins

func AltW ¶

func AltW[E, E1, A any](that Lazy[Either[E1, A]]) func(Either[E, A]) Either[E1, A]

AltW provides an alternative Either if the first is Left, allowing different error types. The 'W' suffix indicates "widening" of the error type.

Example:

alternative := either.AltW[error, string](func() either.Either[string, int] {
    return either.Right[string](99)
})
result := alternative(either.Left[int](errors.New("fail"))) // Right(99)

func ApV ¶

func ApV[B, A, E any](sg S.Semigroup[E]) func(Either[E, A]) Operator[E, func(A) B, B]

ApV is the curried version of MonadApV that combines errors using a semigroup.

This function provides a more convenient API for validation scenarios by currying the arguments. It first takes the value to validate, then returns a function that takes the validation function. This allows for a more natural composition style.

Like MonadApV, this accumulates all errors using the provided semigroup instead of short-circuiting on the first error. This is the key difference from the standard Ap function.

Type Parameters:

• B: The result type after applying the function
• E: The error type (must support the semigroup operation)
• A: The input type to the function

Parameters:

• sg: A semigroup that defines how to combine two error values

Returns:

• A function that takes a value Either[E, A] and returns an Operator that applies validation functions while accumulating errors

Example:

// Define a semigroup for combining validation errors
type ValidationError struct {
    Errors []string
}
errorSemigroup := semigroup.MakeSemigroup(func(e1, e2 ValidationError) ValidationError {
    return ValidationError{Errors: append(e1.Errors, e2.Errors...)}
})

// Create validators
validatePositive := func(x int) either.Either[ValidationError, int] {
    if x > 0 {
        return either.Right[ValidationError](x)
    }
    return either.Left[int](ValidationError{Errors: []string{"must be positive"}})
}

// Use ApV for validation
applyValidation := either.ApV[int](errorSemigroup)
value := either.Left[int](ValidationError{Errors: []string{"invalid input"}})
validator := either.Left[func(int) int](ValidationError{Errors: []string{"invalid validator"}})

result := applyValidation(value)(validator)
// Left(ValidationError{Errors: []string{"invalid validator", "invalid input"}})

func Applicative ¶

func Applicative[E, A, B any]() applicative.Applicative[A, B, Either[E, A], Either[E, B], Either[E, func(A) B]]

Applicative creates a standard Applicative instance for Either with fail-fast error handling.

This returns a lawful Applicative that satisfies all applicative laws:

• Identity: Ap(Of(identity))(v) == v
• Homomorphism: Ap(Of(f))(Of(x)) == Of(f(x))
• Interchange: Ap(Of(f))(u) == Ap(Map(f => f(y))(u))(Of(y))
• Composition: Ap(Ap(Map(compose)(f))(g))(x) == Ap(f)(Ap(g)(x))

The Applicative operations behave as follows:

• Of: lifts a value into Right
• Map: transforms Right values, preserves Left (standard functor)
• Ap: fails fast - if either operand is Left, returns the first Left encountered

This is the standard Either applicative that stops at the first error, making it suitable for computations where you want to short-circuit on failure.

Example - Fail-Fast Behavior:

app := either.Applicative[error, int, string]()

// Both succeed - function application works
value := either.Right[error](42)
fn := either.Right[error](strconv.Itoa)
result := app.Ap(value)(fn)
// result is Right("42")

// First error stops computation
err1 := either.Left[func(int) string](errors.New("error 1"))
err2 := either.Left[int](errors.New("error 2"))
result2 := app.Ap(err2)(err1)
// result2 is Left(error 1) - only first error is returned

Type Parameters:

• E: The error type (Left value)
• A: The input value type (Right value)
• B: The output value type after transformation

func ApplicativeMonoid ¶

func ApplicativeMonoid[E, A any](m M.Monoid[A]) M.Monoid[Either[E, A]]

ApplicativeMonoid returns a Monoid that concatenates Either instances via their applicative. Provides an empty Either (Right with monoid's empty value) and combines Right values using the monoid.

Example:

intAddMonoid := monoid.MakeMonoid(0, func(a, b int) int { return a + b })
eitherMon := either.ApplicativeMonoid[error](intAddMonoid)
empty := eitherMon.Empty() // Right(0)

func ApplicativeV ¶

func ApplicativeV[E, A, B any](sg S.Semigroup[E]) applicative.Applicative[A, B, Either[E, A], Either[E, B], Either[E, func(A) B]]

ApplicativeV creates an Applicative with validation-style error accumulation.

This returns a lawful Applicative that accumulates errors using a Semigroup when combining independent computations with Ap. This is the "validation" pattern commonly used for form validation, configuration validation, and parallel error collection.

The returned instance satisfies all applicative laws:

• Identity: Ap(Of(identity))(v) == v
• Homomorphism: Ap(Of(f))(Of(x)) == Of(f(x))
• Interchange: Ap(Of(f))(u) == Ap(Map(f => f(y))(u))(Of(y))
• Composition: Ap(Ap(Map(compose)(f))(g))(x) == Ap(f)(Ap(g)(x))

Key behaviors:

• Of: lifts a value into Right
• Map: transforms Right values, preserves Left (standard functor)
• Ap: when both operands are Left, combines errors using the Semigroup

Comparison with standard Applicative:

• Applicative: Ap fails fast (returns first error)
• ApplicativeV: Ap accumulates errors (combines all errors via Semigroup)

Use cases:

• Form validation: collect all validation errors at once
• Configuration validation: report all configuration problems
• Parallel independent checks: accumulate all failures

Example - Error Accumulation for Form Validation:

type ValidationErrors []string

// Define how to combine error lists
sg := semigroup.MakeSemigroup(func(a, b ValidationErrors) ValidationErrors {
    return append(append(ValidationErrors{}, a...), b...)
})

app := either.ApplicativeV[ValidationErrors, User, User](sg)

// Validate multiple fields independently
validateName := func(name string) Either[ValidationErrors, string] {
    if len(name) < 3 {
        return Left[string](ValidationErrors{"Name must be at least 3 characters"})
    }
    return Right[ValidationErrors](name)
}

validateAge := func(age int) Either[ValidationErrors, int] {
    if age < 18 {
        return Left[int](ValidationErrors{"Must be 18 or older"})
    }
    return Right[ValidationErrors](age)
}

validateEmail := func(email string) Either[ValidationErrors, string] {
    if !strings.Contains(email, "@") {
        return Left[string](ValidationErrors{"Invalid email format"})
    }
    return Right[ValidationErrors](email)
}

// Create a constructor function lifted into Either
makeUser := func(name string) func(int) func(string) User {
    return func(age int) func(string) User {
        return func(email string) User {
            return User{Name: name, Age: age, Email: email}
        }
    }
}

// Apply validations - all errors are collected
name := validateName("ab")          // Left: name too short
age := validateAge(16)              // Left: age too low
email := validateEmail("invalid")    // Left: invalid email

// Combine all validations using ApV
result := app.Ap(name)(
    app.Ap(age)(
        app.Ap(email)(
            app.Of(makeUser),
        ),
    ),
)
// result is Left(ValidationErrors{
//     "Name must be at least 3 characters",
//     "Must be 18 or older",
//     "Invalid email format"
// })
// All three errors are collected!

Type Parameters:

• E: The error type that must have a Semigroup for combining errors
• A: The input value type (Right value)
• B: The output value type after transformation
• sg: Semigroup instance for combining Left values when both operands of Ap are Left

func ApplySemigroup ¶

func ApplySemigroup[E, A any](s S.Semigroup[A]) S.Semigroup[Either[E, A]]

ApplySemigroup lifts a Semigroup over the Right values of Either. Combines two Right values using the provided Semigroup. If either value is Left, returns the first Left encountered.

Example:

intAdd := semigroup.MakeSemigroup(func(a, b int) int { return a + b })
eitherSemi := either.ApplySemigroup[error](intAdd)
result := eitherSemi.Concat(either.Right[error](2), either.Right[error](3)) // Right(5)

func BiMap ¶

func BiMap[E1, E2, A, B any](f func(E1) E2, g func(a A) B) func(Either[E1, A]) Either[E2, B]

BiMap is the curried version of MonadBiMap. Maps a pair of functions over the two type arguments of the bifunctor.

func ChainOptionK ¶

func ChainOptionK[A, B, E any](onNone func() E) func(func(A) Option[B]) Operator[E, A, B]

ChainOptionK is the curried version of MonadChainOptionK.

func CompactArray ¶

func CompactArray[E, A any](fa []Either[E, A]) []A

CompactArray discards all Left values and keeps only the Right values.

Example:

eithers := []either.Either[error, int]{
    either.Right[error](1),
    either.Left[int](errors.New("error")),
    either.Right[error](3),
}
result := either.CompactArray(eithers)
// result is []int{1, 3}

func CompactArrayG ¶

func CompactArrayG[A1 ~[]Either[E, A], A2 ~[]A, E, A any](fa A1) A2

CompactArrayG discards all Left values and keeps only the Right values. The G suffix indicates support for generic slice types.

Example:

eithers := []either.Either[error, int]{
    either.Right[error](1),
    either.Left[int](errors.New("error")),
    either.Right[error](3),
}
result := either.CompactArrayG[[]either.Either[error, int], []int](eithers)
// result is []int{1, 3}

func CompactRecord ¶

func CompactRecord[K comparable, E, A any](m map[K]Either[E, A]) map[K]A

CompactRecord discards all Left values and keeps only the Right values.

Example:

eithers := map[string]either.Either[error, int]{
    "a": either.Right[error](1),
    "b": either.Left[int](errors.New("error")),
    "c": either.Right[error](3),
}
result := either.CompactRecord(eithers)
// result is map[string]int{"a": 1, "c": 3}

func CompactRecordG ¶

func CompactRecordG[M1 ~map[K]Either[E, A], M2 ~map[K]A, K comparable, E, A any](m M1) M2

CompactRecordG discards all Left values and keeps only the Right values. The G suffix indicates support for generic map types.

Example:

eithers := map[string]either.Either[error, int]{
    "a": either.Right[error](1),
    "b": either.Left[int](errors.New("error")),
    "c": either.Right[error](3),
}
result := either.CompactRecordG[map[string]either.Either[error, int], map[string]int](eithers)
// result is map[string]int{"a": 1, "c": 3}

func Curry0 ¶

func Curry0[R any](f func() (R, error)) func() Either[error, R]

Curry0 converts a Go function that returns (R, error) into a curried version that returns Either[error, R].

Example:

getConfig := func() (string, error) { return "config", nil }
curried := either.Curry0(getConfig)
result := curried() // Right("config")

func Curry1 ¶

func Curry1[T1, R any](f func(T1) (R, error)) func(T1) Either[error, R]

Curry1 converts a Go function that returns (R, error) into a curried version that returns Either[error, R].

Example:

parse := strconv.Atoi
curried := either.Curry1(parse)
result := curried("42") // Right(42)

func Curry2 ¶

func Curry2[T1, T2, R any](f func(T1, T2) (R, error)) func(T1) func(T2) Either[error, R]

Curry2 converts a 2-argument Go function that returns (R, error) into a curried version.

Example:

divide := func(a, b int) (int, error) {
    if b == 0 { return 0, errors.New("div by zero") }
    return a / b, nil
}
curried := either.Curry2(divide)
result := curried(10)(2) // Right(5)

func Curry3 ¶

func Curry3[T1, T2, T3, R any](f func(T1, T2, T3) (R, error)) func(T1) func(T2) func(T3) Either[error, R]

Curry3 converts a 3-argument Go function that returns (R, error) into a curried version.

func Curry4 ¶

func Curry4[T1, T2, T3, T4, R any](f func(T1, T2, T3, T4) (R, error)) func(T1) func(T2) func(T3) func(T4) Either[error, R]

Curry4 converts a 4-argument Go function that returns (R, error) into a curried version.

func Eitherize0 ¶

func Eitherize0[F ~func() (R, error), R any](f F) func() Either[error, R]

Eitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning an Either The inverse function is Uneitherize0

func Eitherize1 ¶

func Eitherize1[F ~func(T0) (R, error), T0, R any](f F) func(T0) Either[error, R]

Eitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning an Either The inverse function is Uneitherize1

func Eitherize10 ¶

func Eitherize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) Either[error, R]

Eitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning an Either The inverse function is Uneitherize10

func Eitherize11 ¶

func Eitherize11[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) Either[error, R]

Eitherize11 converts a function with 11 parameters returning a tuple into a function with 11 parameters returning an Either The inverse function is Uneitherize11

func Eitherize12 ¶

func Eitherize12[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) Either[error, R]

Eitherize12 converts a function with 12 parameters returning a tuple into a function with 12 parameters returning an Either The inverse function is Uneitherize12

func Eitherize13 ¶

func Eitherize13[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) Either[error, R]

Eitherize13 converts a function with 13 parameters returning a tuple into a function with 13 parameters returning an Either The inverse function is Uneitherize13

func Eitherize14 ¶

func Eitherize14[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) Either[error, R]

Eitherize14 converts a function with 14 parameters returning a tuple into a function with 14 parameters returning an Either The inverse function is Uneitherize14

func Eitherize15 ¶

func Eitherize15[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) Either[error, R]

Eitherize15 converts a function with 15 parameters returning a tuple into a function with 15 parameters returning an Either The inverse function is Uneitherize15

func Eitherize2 ¶

func Eitherize2[F ~func(T0, T1) (R, error), T0, T1, R any](f F) func(T0, T1) Either[error, R]

Eitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning an Either The inverse function is Uneitherize2

func Eitherize3 ¶

func Eitherize3[F ~func(T0, T1, T2) (R, error), T0, T1, T2, R any](f F) func(T0, T1, T2) Either[error, R]

Eitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning an Either The inverse function is Uneitherize3

func Eitherize4 ¶

func Eitherize4[F ~func(T0, T1, T2, T3) (R, error), T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) Either[error, R]

Eitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning an Either The inverse function is Uneitherize4

func Eitherize5 ¶

func Eitherize5[F ~func(T0, T1, T2, T3, T4) (R, error), T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) Either[error, R]

Eitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning an Either The inverse function is Uneitherize5

func Eitherize6 ¶

func Eitherize6[F ~func(T0, T1, T2, T3, T4, T5) (R, error), T0, T1, T2, T3, T4, T5, R any](f F) func(T0, T1, T2, T3, T4, T5) Either[error, R]

Eitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning an Either The inverse function is Uneitherize6

func Eitherize7 ¶

func Eitherize7[F ~func(T0, T1, T2, T3, T4, T5, T6) (R, error), T0, T1, T2, T3, T4, T5, T6, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) Either[error, R]

Eitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning an Either The inverse function is Uneitherize7

func Eitherize8 ¶

func Eitherize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) Either[error, R]

Eitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning an Either The inverse function is Uneitherize8

func Eitherize9 ¶

func Eitherize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) Either[error, R]

Eitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning an Either The inverse function is Uneitherize9

func Eq ¶

func Eq[E, A any](e EQ.Eq[E], a EQ.Eq[A]) EQ.Eq[Either[E, A]]

Eq constructs an equality predicate for Either values. Two Either values are equal if they are both Left with equal error values, or both Right with equal success values.

Parameters:

• e: Equality predicate for the Left (error) type
• a: Equality predicate for the Right (success) type

Example:

eq := either.Eq(eq.FromStrictEquals[error](), eq.FromStrictEquals[int]())
result := eq.Equals(either.Right[error](42), either.Right[error](42)) // true
result2 := eq.Equals(either.Right[error](42), either.Right[error](43)) // false

func Fold ¶

func Fold[E, A, B any](onLeft func(E) B, onRight func(A) B) func(Either[E, A]) B

Fold is the curried version of MonadFold. Extracts the value from an Either by providing handlers for both cases.

Example:

result := either.Fold(
    func(err error) string { return "Error: " + err.Error() },
    func(n int) string { return fmt.Sprintf("Value: %d", n) },
)(either.Right[error](42)) // "Value: 42"

func FromError ¶

func FromError[A any](f func(a A) error) func(A) Either[error, A]

FromError creates an Either from a function that may return an error.

Example:

validate := func(x int) error {
    if x < 0 { return errors.New("negative") }
    return nil
}
toEither := either.FromError(validate)
result := toEither(42) // Right(42)

func FromNillable ¶

func FromNillable[A, E any](e E) func(*A) Either[E, *A]

FromNillable creates an Either from a pointer, using the provided error for nil pointers.

Example:

var ptr *int = nil
result := either.FromNillable[int](errors.New("nil"))(ptr) // Left(error)
val := 42
result := either.FromNillable[int](errors.New("nil"))(&val) // Right(&42)

func FromOption ¶

func FromOption[A, E any](onNone func() E) func(Option[A]) Either[E, A]

FromOption converts an Option to an Either, using the provided function to generate a Left value for None.

Example:

opt := option.Some(42)
result := either.FromOption[int](func() error { return errors.New("none") })(opt) // Right(42)

func FromPredicate ¶

func FromPredicate[E, A any](pred func(A) bool, onFalse func(A) E) func(A) Either[E, A]

FromPredicate creates an Either based on a predicate. If the predicate returns true, creates a Right; otherwise creates a Left using onFalse.

Example:

isPositive := either.FromPredicate(
    func(x int) bool { return x > 0 },
    func(x int) error { return errors.New("not positive") },
)
result := isPositive(42) // Right(42)
result := isPositive(-1) // Left(error)

func FromStrictEquals ¶

func FromStrictEquals[E, A comparable]() EQ.Eq[Either[E, A]]

FromStrictEquals constructs an equality predicate using Go's == operator. Both the Left and Right types must be comparable.

Example:

eq := either.FromStrictEquals[error, int]()
result := eq.Equals(either.Right[error](42), either.Right[error](42)) // true

func Functor ¶

func Functor[E, A, B any]() functor.Functor[A, B, Either[E, A], Either[E, B]]

Functor implements the functoric operations for Either. A functor provides the Map operation that transforms values inside a context while preserving the structure.

Example:

f := either.Functor[error, int, string]()
result := f.Map(strconv.Itoa)(either.Right[error](42))
// result is Right("42")

func GetOrElse ¶

func GetOrElse[E, A any](onLeft func(E) A) func(Either[E, A]) A

GetOrElse extracts the Right value or computes a default from the Left value.

Example:

result := either.GetOrElse(func(err error) int { return 0 })(either.Right[error](42)) // 42
result := either.GetOrElse(func(err error) int { return 0 })(either.Left[int](err)) // 0

func IsLeft ¶

func IsLeft[E, A any](val Either[E, A]) bool

IsLeft tests if the Either is a Left value. Rather use Fold or MonadFold if you need to access the values. Inverse is IsRight.

Example:

either.IsLeft(either.Left[int](errors.New("err"))) // true
either.IsLeft(either.Right[error](42)) // false

func IsRight ¶

func IsRight[E, A any](val Either[E, A]) bool

IsRight tests if the Either is a Right value. Rather use Fold or MonadFold if you need to access the values. Inverse is IsLeft.

Example:

either.IsRight(either.Right[error](42)) // true
either.IsRight(either.Left[int](errors.New("err"))) // false

func Logger ¶

func Logger[E, A any](loggers ...*log.Logger) func(string) Operator[E, A, A]

Logger creates a logging function for Either values that logs both Left and Right cases. The function logs the value and then returns the original Either unchanged.

Parameters:

• loggers: Optional log.Logger instances. If none provided, uses default logger.

Example:

logger := either.Logger[error, int]()
result := F.Pipe2(
    either.Right[error](42),
    logger("Processing"),
    either.Map(N.Mul(2)),
)
// Logs: "Processing: 42"
// result is Right(84)

func MapLeft ¶

func MapLeft[A, E1, E2 any](f func(E1) E2) func(fa Either[E1, A]) Either[E2, A]

MapLeft is the curried version of MonadMapLeft. Applies a mapping function to the Left (error) channel.

func Monad ¶

func Monad[E, A, B any]() monad.Monad[A, B, Either[E, A], Either[E, B], Either[E, func(A) B]]

Monad creates a lawful Monad instance for Either with fail-fast error handling.

A monad combines the capabilities of four type classes:

• Functor (Map): transform the Right value
• Pointed (Of): lift a pure value into a Right
• Applicative (Ap): apply wrapped functions (fails fast on first Left)
• Chainable (Chain): sequence dependent computations (fails fast on first Left)

The Either monad is left-biased and fails fast: once a Left is encountered, no further computations are performed and the Left is propagated immediately. This makes it ideal for error handling where you want to stop at the first error.

This implementation satisfies all monad laws:

Monad Laws:

• Left Identity: Chain(f)(Of(a)) == f(a)
• Right Identity: Chain(Of)(m) == m
• Associativity: Chain(g)(Chain(f)(m)) == Chain(x => Chain(g)(f(x)))(m)

Additionally, it satisfies all prerequisite laws from Functor, Apply, and Applicative.

Relationship to Applicative:

This Monad uses the standard fail-fast Applicative (see Applicative function). In a lawful monad, Ap can be derived from Chain and Of:

Ap(fa)(ff) == Chain(f => Chain(a => Of(f(a)))(fa))(ff)

The Either monad satisfies this property, making it a true lawful monad.

When to use Monad vs Applicative:

• Use Monad when you need sequential dependent operations (Chain)
• Use Applicative when you only need independent operations (Ap, Map)
• Both fail fast on the first error

When to use Monad vs ApplicativeV:

• Use Monad for sequential error handling (fail-fast)
• Use ApplicativeV for parallel validation (error accumulation)
• Note: There is no "MonadV" because Chain inherently fails fast

Example - Sequential Dependent Operations:

m := either.Monad[error, int, string]()

// Chain allows each step to depend on the previous result
result := m.Chain(func(x int) either.Either[error, string] {
    if x > 0 {
        return either.Right[error](strconv.Itoa(x))
    }
    return either.Left[string](errors.New("value must be positive"))
})(either.Right[error](42))
// result is Right("42")

// Fails fast on first error
result2 := m.Chain(func(x int) either.Either[error, string] {
    return either.Right[error](strconv.Itoa(x))
})(either.Left[int](errors.New("initial error")))
// result2 is Left("initial error") - Chain never executes

Example - Combining with Applicative operations:

m := either.Monad[error, int, int]()

// Map transforms the value
value := m.Map(N.Mul(2))(either.Right[error](21))
// value is Right(42)

// Ap applies wrapped functions (also fails fast)
fn := either.Right[error](N.Add(1))
result := m.Ap(value)(fn)
// result is Right(43)

Example - Real-world usage with error handling:

m := either.Monad[error, User, SavedUser]()

// Pipeline of operations that can fail
result := m.Chain(func(user User) either.Either[error, SavedUser] {
    // Save to database
    return saveToDatabase(user)
})(m.Chain(func(user User) either.Either[error, User] {
    // Validate user
    return validateUser(user)
})(either.Right[error](inputUser)))

// If any step fails, the error propagates immediately

Type Parameters:

• E: The error type (Left value)
• A: The input value type (Right value)
• B: The output value type after transformation

func MonadApV ¶

func MonadApV[B, A, E any](sg S.Semigroup[E]) func(fab Either[E, func(a A) B], fa Either[E, A]) Either[E, B]

MonadApV is the applicative validation functor that combines errors using a semigroup.

Unlike the standard MonadAp which short-circuits on the first Left (error), MonadApV accumulates all errors using the provided semigroup's Concat operation. This is particularly useful for validation scenarios where you want to collect all validation errors rather than stopping at the first one.

The function takes a semigroup for combining errors and returns a function that applies a wrapped function to a wrapped value, accumulating errors if both are Left.

Behavior:

• If both fab and fa are Left, combines their errors using sg.Concat
• If only fab is Left, returns Left with fab's error
• If only fa is Left, returns Left with fa's error
• If both are Right, applies the function and returns Right with the result

Type Parameters:

• B: The result type after applying the function
• E: The error type (must support the semigroup operation)
• A: The input type to the function

Parameters:

• sg: A semigroup that defines how to combine two error values

Returns:

• A function that takes a wrapped function and a wrapped value, returning Either[E, B] with accumulated errors or the computed result

Example:

// Define a semigroup that concatenates error messages
errorSemigroup := semigroup.MakeSemigroup(func(e1, e2 string) string {
    return e1 + "; " + e2
})

// Create the validation applicative
applyV := either.MonadApV[int](errorSemigroup)

// Both are errors - errors get combined
fab := either.Left[func(int) int]("error1")
fa := either.Left[int]("error2")
result := applyV(fab, fa) // Left("error1; error2")

// One error - returns that error
fab2 := either.Right[string](N.Mul(2))
fa2 := either.Left[int]("validation failed")
result2 := applyV(fab2, fa2) // Left("validation failed")

// Both success - applies function
fab3 := either.Right[string](N.Mul(2))
fa3 := either.Right[string](21)
result3 := applyV(fab3, fa3) // Right(42)

func MonadFold ¶

func MonadFold[E, A, B any](ma Either[E, A], onLeft func(e E) B, onRight func(a A) B) B

MonadFold extracts the value from an Either by providing handlers for both cases. This is the fundamental pattern matching operation for Either.

Example:

result := either.MonadFold(
    either.Right[error](42),
    func(err error) string { return "Error: " + err.Error() },
    func(n int) string { return fmt.Sprintf("Value: %d", n) },
) // "Value: 42"

func Pointed ¶

func Pointed[E, A any]() pointed.Pointed[A, Either[E, A]]

Pointed implements the pointed functor operations for Either. A pointed functor provides the Of operation to lift a value into the Either context.

Example:

p := either.Pointed[error, int]()
result := p.Of(42) // Right(42)

func Reduce ¶

func Reduce[E, A, B any](f func(B, A) B, initial B) func(Either[E, A]) B

Reduce folds an Either into a single value using a reducer function. Returns the initial value for Left, or applies the reducer to the Right value.

func Sequence ¶

func Sequence[E, A, HKTA, HKTRA any](
	mof func(Either[E, A]) HKTRA,
	mmap func(Kleisli[E, A, A]) func(HKTA) HKTRA,
) func(Either[E, HKTA]) HKTRA

Sequence converts an Either of some higher kinded type into the higher kinded type of an Either. This is the identity version of Traverse - it doesn't transform the values, just swaps the type constructors.

Parameters:

• mof: Lifts an Either into the target higher-kinded type
• mmap: Maps over the target higher-kinded type

Example (conceptual - requires understanding of higher-kinded types):

// Sequence an Either[error, Option[int]] to Option[Either[error, int]]
result := either.Sequence[error, int, option.Option[int], option.Option[either.Either[error, int]]](
    option.Of[either.Either[error, int]],
    option.Map[int, either.Either[error, int]],
)(eitherOfOption)

func Sequence2 ¶

func Sequence2[E, T1, T2, R any](f func(T1, T2) Either[E, R]) func(Either[E, T1], Either[E, T2]) Either[E, R]

Sequence2 sequences two Either values using a combining function. Short-circuits on the first Left encountered.

func Sequence3 ¶

func Sequence3[E, T1, T2, T3, R any](f func(T1, T2, T3) Either[E, R]) func(Either[E, T1], Either[E, T2], Either[E, T3]) Either[E, R]

Sequence3 sequences three Either values using a combining function. Short-circuits on the first Left encountered.

func ToError ¶

func ToError[A any](e Either[error, A]) error

ToError converts an Either[error, A] to an error, returning nil for Right values.

Example:

err := either.ToError(either.Left[int](errors.New("fail"))) // error
err := either.ToError(either.Right[error](42)) // nil

func ToSLogAttr ¶

func ToSLogAttr[E, A any]() func(Either[E, A]) slog.Attr

ToSLogAttr converts an Either value to a structured logging attribute (slog.Attr).

This function creates a converter that transforms Either values into slog.Attr for use with Go's structured logging (log/slog). It maps:

• Left values to an "error" attribute
• Right values to a "value" attribute

This is particularly useful when integrating Either-based error handling with structured logging systems, allowing you to log both successful values and errors in a consistent, structured format.

Type Parameters:

• E: The Left (error) type of the Either
• A: The Right (success) type of the Either

Returns:

• A function that converts Either[E, A] to slog.Attr

Example with Left (error):

converter := either.ToSLogAttr[error, int]()
leftValue := either.Left[int](errors.New("connection failed"))
attr := converter(leftValue)
// attr is: slog.Any("error", errors.New("connection failed"))

logger.LogAttrs(ctx, slog.LevelError, "Operation failed", attr)
// Logs: {"level":"error","msg":"Operation failed","error":"connection failed"}

Example with Right (success):

converter := either.ToSLogAttr[error, User]()
rightValue := either.Right[error](User{ID: 123, Name: "Alice"})
attr := converter(rightValue)
// attr is: slog.Any("value", User{ID: 123, Name: "Alice"})

logger.LogAttrs(ctx, slog.LevelInfo, "User fetched", attr)
// Logs: {"level":"info","msg":"User fetched","value":{"ID":123,"Name":"Alice"}}

Example in a pipeline with structured logging:

toAttr := either.ToSLogAttr[error, Data]()

result := F.Pipe2(
    fetchData(id),
    either.Map(processData),
    either.Map(validateData),
)

attr := toAttr(result)
logger.LogAttrs(ctx, slog.LevelInfo, "Data processing complete", attr)
// Logs success: {"level":"info","msg":"Data processing complete","value":{...}}
// Or error: {"level":"info","msg":"Data processing complete","error":"validation failed"}

Example with custom log levels based on Either:

toAttr := either.ToSLogAttr[error, Response]()
result := callAPI(endpoint)

level := either.Fold(
    func(error) slog.Level { return slog.LevelError },
    func(Response) slog.Level { return slog.LevelInfo },
)(result)

logger.LogAttrs(ctx, level, "API call completed", toAttr(result))

Use Cases:

• Structured logging: Convert Either results to structured log attributes
• Error tracking: Log errors with consistent "error" key in structured logs
• Success monitoring: Log successful values with consistent "value" key
• Observability: Integrate Either-based error handling with logging systems
• Debugging: Inspect Either values in logs with proper structure
• Metrics: Extract Either values for metrics collection in logging pipelines

Note: The returned slog.Attr uses "error" for Left values and "value" for Right values. These keys are consistent with common structured logging conventions.

func ToType ¶

func ToType[A, E any](onError func(any) E) func(any) Either[E, A]

ToType attempts to convert an any value to a specific type, returning Either.

Example:

convert := either.ToType[int](func(v any) error {
    return fmt.Errorf("cannot convert %v to int", v)
})
result := convert(42) // Right(42)
result := convert("string") // Left(error)

func Traverse ¶

func Traverse[A, E, B, HKTB, HKTRB any](
	mof func(Either[E, B]) HKTRB,
	mmap func(Kleisli[E, B, B]) func(HKTB) HKTRB,
) func(func(A) HKTB) func(Either[E, A]) HKTRB

Traverse converts an Either of some higher kinded type into the higher kinded type of an Either. This is a generic traversal operation that works with any applicative functor.

Parameters:

• mof: Lifts an Either into the target higher-kinded type
• mmap: Maps over the target higher-kinded type

Example (conceptual - requires understanding of higher-kinded types):

// Traverse an Either[error, Option[int]] to Option[Either[error, int]]
result := either.Traverse[int, error, int, option.Option[int], option.Option[either.Either[error, int]]](
    option.Of[either.Either[error, int]],
    option.Map[int, either.Either[error, int]],
)(f)(eitherOfOption)

func TraverseTuple1 ¶

func TraverseTuple1[F1 ~func(A1) Either[E, T1], E, A1, T1 any](f1 F1) func(T.Tuple1[A1]) Either[E, T.Tuple1[T1]]

TraverseTuple1 converts a [Tuple1] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple1]].

func TraverseTuple10 ¶

func TraverseTuple10[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], E, 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]) Either[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]

TraverseTuple10 converts a [Tuple10] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple10]].

func TraverseTuple11 ¶

func TraverseTuple11[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], F11 ~func(A11) Either[E, T11], E, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10, A11, T11 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11) func(T.Tuple11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Either[E, T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]

TraverseTuple11 converts a [Tuple11] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple11]].

func TraverseTuple12 ¶

func TraverseTuple12[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], F11 ~func(A11) Either[E, T11], F12 ~func(A12) Either[E, T12], E, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10, A11, T11, A12, T12 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12) func(T.Tuple12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Either[E, T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]

TraverseTuple12 converts a [Tuple12] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple12]].

func TraverseTuple13 ¶

func TraverseTuple13[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], F11 ~func(A11) Either[E, T11], F12 ~func(A12) Either[E, T12], F13 ~func(A13) Either[E, T13], E, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10, A11, T11, A12, T12, A13, T13 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13) func(T.Tuple13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Either[E, T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]

TraverseTuple13 converts a [Tuple13] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple13]].

func TraverseTuple14 ¶

func TraverseTuple14[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], F11 ~func(A11) Either[E, T11], F12 ~func(A12) Either[E, T12], F13 ~func(A13) Either[E, T13], F14 ~func(A14) Either[E, T14], E, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10, A11, T11, A12, T12, A13, T13, A14, T14 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14) func(T.Tuple14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Either[E, T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]

TraverseTuple14 converts a [Tuple14] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple14]].

func TraverseTuple15 ¶

func TraverseTuple15[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], F10 ~func(A10) Either[E, T10], F11 ~func(A11) Either[E, T11], F12 ~func(A12) Either[E, T12], F13 ~func(A13) Either[E, T13], F14 ~func(A14) Either[E, T14], F15 ~func(A15) Either[E, T15], E, A1, T1, A2, T2, A3, T3, A4, T4, A5, T5, A6, T6, A7, T7, A8, T8, A9, T9, A10, T10, A11, T11, A12, T12, A13, T13, A14, T14, A15, T15 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15) func(T.Tuple15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Either[E, T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]

TraverseTuple15 converts a [Tuple15] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple15]].

func TraverseTuple2 ¶

func TraverseTuple2[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], E, A1, T1, A2, T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) Either[E, T.Tuple2[T1, T2]]

TraverseTuple2 converts a [Tuple2] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple2]].

func TraverseTuple3 ¶

func TraverseTuple3[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], E, A1, T1, A2, T2, A3, T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) Either[E, T.Tuple3[T1, T2, T3]]

TraverseTuple3 converts a [Tuple3] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple3]].

func TraverseTuple4 ¶

func TraverseTuple4[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], E, A1, T1, A2, T2, A3, T3, A4, T4 any](f1 F1, f2 F2, f3 F3, f4 F4) func(T.Tuple4[A1, A2, A3, A4]) Either[E, T.Tuple4[T1, T2, T3, T4]]

TraverseTuple4 converts a [Tuple4] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple4]].

func TraverseTuple5 ¶

func TraverseTuple5[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], E, 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]) Either[E, T.Tuple5[T1, T2, T3, T4, T5]]

TraverseTuple5 converts a [Tuple5] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple5]].

func TraverseTuple6 ¶

func TraverseTuple6[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], E, 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]) Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]]

TraverseTuple6 converts a [Tuple6] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple6]].

func TraverseTuple7 ¶

func TraverseTuple7[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], E, 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]) Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]

TraverseTuple7 converts a [Tuple7] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple7]].

func TraverseTuple8 ¶

func TraverseTuple8[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], E, 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]) Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]

TraverseTuple8 converts a [Tuple8] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple8]].

func TraverseTuple9 ¶

func TraverseTuple9[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~func(A3) Either[E, T3], F4 ~func(A4) Either[E, T4], F5 ~func(A5) Either[E, T5], F6 ~func(A6) Either[E, T6], F7 ~func(A7) Either[E, T7], F8 ~func(A8) Either[E, T8], F9 ~func(A9) Either[E, T9], E, 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]) Either[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]

TraverseTuple9 converts a [Tuple9] of [A] via transformation functions transforming [A] to [Either[E, A]] into a [Either[E, Tuple9]].

func Uncurry0 ¶

func Uncurry0[R any](f func() Either[error, R]) func() (R, error)

Uncurry0 converts a function returning Either[error, R] back to Go's (R, error) style.

Example:

curried := func() either.Either[error, string] { return either.Right[error]("value") }
uncurried := either.Uncurry0(curried)
result, err := uncurried() // "value", nil

func Uncurry1 ¶

func Uncurry1[T1, R any](f func(T1) Either[error, R]) func(T1) (R, error)

Uncurry1 converts a function returning Either[error, R] back to Go's (R, error) style.

Example:

curried := func(x int) either.Either[error, string] { return either.Right[error](strconv.Itoa(x)) }
uncurried := either.Uncurry1(curried)
result, err := uncurried(42) // "42", nil

func Uncurry2 ¶

func Uncurry2[T1, T2, R any](f func(T1) func(T2) Either[error, R]) func(T1, T2) (R, error)

Uncurry2 converts a curried function returning Either[error, R] back to Go's (R, error) style.

func Uncurry3 ¶

func Uncurry3[T1, T2, T3, R any](f func(T1) func(T2) func(T3) Either[error, R]) func(T1, T2, T3) (R, error)

Uncurry3 converts a curried function returning Either[error, R] back to Go's (R, error) style.

func Uncurry4 ¶

func Uncurry4[T1, T2, T3, T4, R any](f func(T1) func(T2) func(T3) func(T4) Either[error, R]) func(T1, T2, T3, T4) (R, error)

Uncurry4 converts a curried function returning Either[error, R] back to Go's (R, error) style.

func Uneitherize0 ¶

func Uneitherize0[F ~func() Either[error, R], R any](f F) func() (R, error)

Uneitherize0 converts a function with 0 parameters returning an Either into a function with 0 parameters returning a tuple The inverse function is Eitherize0

func Uneitherize1 ¶

func Uneitherize1[F ~func(T0) Either[error, R], T0, R any](f F) func(T0) (R, error)

Uneitherize1 converts a function with 1 parameters returning an Either into a function with 1 parameters returning a tuple The inverse function is Eitherize1

func Uneitherize10 ¶

func Uneitherize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) 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) (R, error)

Uneitherize10 converts a function with 10 parameters returning an Either into a function with 10 parameters returning a tuple The inverse function is Eitherize10

func Uneitherize11 ¶

func Uneitherize11[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) (R, error)

Uneitherize11 converts a function with 11 parameters returning an Either into a function with 11 parameters returning a tuple The inverse function is Eitherize11

func Uneitherize12 ¶

func Uneitherize12[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) (R, error)

Uneitherize12 converts a function with 12 parameters returning an Either into a function with 12 parameters returning a tuple The inverse function is Eitherize12

func Uneitherize13 ¶

func Uneitherize13[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) (R, error)

Uneitherize13 converts a function with 13 parameters returning an Either into a function with 13 parameters returning a tuple The inverse function is Eitherize13

func Uneitherize14 ¶

func Uneitherize14[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) (R, error)

Uneitherize14 converts a function with 14 parameters returning an Either into a function with 14 parameters returning a tuple The inverse function is Eitherize14

func Uneitherize15 ¶

func Uneitherize15[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) (R, error)

Uneitherize15 converts a function with 15 parameters returning an Either into a function with 15 parameters returning a tuple The inverse function is Eitherize15

func Uneitherize2 ¶

func Uneitherize2[F ~func(T0, T1) Either[error, R], T0, T1, R any](f F) func(T0, T1) (R, error)

Uneitherize2 converts a function with 2 parameters returning an Either into a function with 2 parameters returning a tuple The inverse function is Eitherize2

func Uneitherize3 ¶

func Uneitherize3[F ~func(T0, T1, T2) Either[error, R], T0, T1, T2, R any](f F) func(T0, T1, T2) (R, error)

Uneitherize3 converts a function with 3 parameters returning an Either into a function with 3 parameters returning a tuple The inverse function is Eitherize3

func Uneitherize4 ¶

func Uneitherize4[F ~func(T0, T1, T2, T3) Either[error, R], T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) (R, error)

Uneitherize4 converts a function with 4 parameters returning an Either into a function with 4 parameters returning a tuple The inverse function is Eitherize4

func Uneitherize5 ¶

func Uneitherize5[F ~func(T0, T1, T2, T3, T4) Either[error, R], T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) (R, error)

Uneitherize5 converts a function with 5 parameters returning an Either into a function with 5 parameters returning a tuple The inverse function is Eitherize5

func Uneitherize6 ¶

func Uneitherize6[F ~func(T0, T1, T2, T3, T4, T5) Either[error, R], T0, T1, T2, T3, T4, T5, R any](f F) func(T0, T1, T2, T3, T4, T5) (R, error)

Uneitherize6 converts a function with 6 parameters returning an Either into a function with 6 parameters returning a tuple The inverse function is Eitherize6

func Uneitherize7 ¶

func Uneitherize7[F ~func(T0, T1, T2, T3, T4, T5, T6) Either[error, R], T0, T1, T2, T3, T4, T5, T6, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) (R, error)

Uneitherize7 converts a function with 7 parameters returning an Either into a function with 7 parameters returning a tuple The inverse function is Eitherize7

func Uneitherize8 ¶

func Uneitherize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) (R, error)

Uneitherize8 converts a function with 8 parameters returning an Either into a function with 8 parameters returning a tuple The inverse function is Eitherize8

func Uneitherize9 ¶

func Uneitherize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) 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) (R, error)

Uneitherize9 converts a function with 9 parameters returning an Either into a function with 9 parameters returning a tuple The inverse function is Eitherize9

func Unvariadic0 ¶

func Unvariadic0[V, R any](f func(...V) (R, error)) func([]V) Either[error, R]

Unvariadic0 converts a variadic function returning (R, error) into a function taking a slice and returning Either.

func Unvariadic1 ¶

func Unvariadic1[T1, V, R any](f func(T1, ...V) (R, error)) func(T1, []V) Either[error, R]

Unvariadic1 converts a variadic function with 1 fixed parameter into a function taking a slice and returning Either.

func Unvariadic2 ¶

func Unvariadic2[T1, T2, V, R any](f func(T1, T2, ...V) (R, error)) func(T1, T2, []V) Either[error, R]

Unvariadic2 converts a variadic function with 2 fixed parameters into a function taking a slice and returning Either.

func Unvariadic3 ¶

func Unvariadic3[T1, T2, T3, V, R any](f func(T1, T2, T3, ...V) (R, error)) func(T1, T2, T3, []V) Either[error, R]

Unvariadic3 converts a variadic function with 3 fixed parameters into a function taking a slice and returning Either.

func Unvariadic4 ¶

func Unvariadic4[T1, T2, T3, T4, V, R any](f func(T1, T2, T3, T4, ...V) (R, error)) func(T1, T2, T3, T4, []V) Either[error, R]

Unvariadic4 converts a variadic function with 4 fixed parameters into a function taking a slice and returning Either.

func Unwrap ¶

func Unwrap[E, A any](ma Either[E, A]) (A, E)

Unwrap converts an Either into the idiomatic Go tuple (value, error). For Right values, returns (value, zero-error). For Left values, returns (zero-value, error).

Example:

val, err := either.Unwrap(either.Right[error](42)) // 42, nil
val, err := either.Unwrap(either.Left[int](errors.New("fail"))) // 0, error

func UnwrapError ¶

func UnwrapError[A any](ma Either[error, A]) (A, error)

UnwrapError converts an Either[error, A] into the idiomatic Go tuple (A, error).

Example:

val, err := either.UnwrapError(either.Right[error](42)) // 42, nil
val, err := either.UnwrapError(either.Left[int](errors.New("fail"))) // zero, error

func Variadic0 ¶

func Variadic0[V, R any](f func([]V) (R, error)) func(...V) Either[error, R]

Variadic0 converts a function taking a slice and returning (R, error) into a variadic function returning Either.

Example:

sum := func(nums []int) (int, error) {
    total := 0
    for _, n := range nums { total += n }
    return total, nil
}
variadicSum := either.Variadic0(sum)
result := variadicSum(1, 2, 3) // Right(6)

func Variadic1 ¶

func Variadic1[T1, V, R any](f func(T1, []V) (R, error)) func(T1, ...V) Either[error, R]

Variadic1 converts a function with 1 fixed parameter and a slice into a variadic function returning Either.

func Variadic2 ¶

func Variadic2[T1, T2, V, R any](f func(T1, T2, []V) (R, error)) func(T1, T2, ...V) Either[error, R]

Variadic2 converts a function with 2 fixed parameters and a slice into a variadic function returning Either.

func Variadic3 ¶

func Variadic3[T1, T2, T3, V, R any](f func(T1, T2, T3, []V) (R, error)) func(T1, T2, T3, ...V) Either[error, R]

Variadic3 converts a function with 3 fixed parameters and a slice into a variadic function returning Either.

func Variadic4 ¶

func Variadic4[T1, T2, T3, T4, V, R any](f func(T1, T2, T3, T4, []V) (R, error)) func(T1, T2, T3, T4, ...V) Either[error, R]

Variadic4 converts a function with 4 fixed parameters and a slice into a variadic function returning Either.