result

func MonadBiMap ¶

func MonadBiMap[E, A, B any](fa Result[A], f func(error) E, g func(a A) B) Either[E, B]

MonadBiMap applies two functions: one to transform a Left value, another to transform a Right value. This allows transforming both channels of the Either simultaneously.

Example:

result := either.MonadBiMap(
    either.Left[int](errors.New("error")),
    error.Error,
    func(n int) string { return fmt.Sprint(n) },
) // Left("error")

func MonadMapLeft ¶

func MonadMapLeft[A, E any](fa Result[A], f func(error) E) Either[E, A]

MonadMapLeft applies a transformation function to the Left (error) value. If the Either is Right, returns Right unchanged.

Example:

result := either.MonadMapLeft(
    either.Left[int](errors.New("error")),
    error.Error,
) // Left("error")

func Swap ¶

func Swap[A any](val Result[A]) Either[A, error]

Swap exchanges the Left and Right type parameters.

Example:

result := either.Swap(either.Right[error](42)) // Left(42)
result := either.Swap(either.Left[int](errors.New("err"))) // Right(error)

func FromError ¶

func FromError[A any](f func(a A) error) Kleisli[A, 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 FromPredicate ¶

func FromPredicate[A any](pred func(A) bool, onFalse func(A) error) Kleisli[A, 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(
    N.MoreThan(0),
    func(x int) error { return errors.New("not positive") },
)
result := isPositive(42) // Right(42)
result := isPositive(-1) // Left(error)

func TailRec ¶

func TailRec[A, B any](f Kleisli[A, tailrec.Trampoline[A, B]]) Kleisli[A, B]

func ToType ¶

func ToType[A any](onError func(any) error) Kleisli[any, 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 TraverseArray ¶

func TraverseArray[A, B any](f Kleisli[A, B]) Kleisli[[]A, []B]

TraverseArray transforms an array by applying a function that returns an Either to each element. If any element produces a Left, the entire result is that Left (short-circuits). Otherwise, returns Right containing the array of all Right values.

Example:

parse := func(s string) either.Result[int] {
    v, err := strconv.Atoi(s)
    return either.FromError(v, err)
}
result := either.TraverseArray(parse)([]string{"1", "2", "3"})
// result is Right([]int{1, 2, 3})

package main

import (
	"fmt"
	"strconv"

	F "github.com/IBM/fp-go/v2/function"
	R "github.com/IBM/fp-go/v2/result"
)

func main() {
	parse := R.Eitherize1(strconv.Atoi)
	result := R.TraverseArray(parse)([]string{"1", "2", "3"})
	fmt.Println(R.GetOrElse(F.Constant1[error]([]int{}))(result))
}

Output:

[1 2 3]

func TraverseArrayG ¶

func TraverseArrayG[GA ~[]A, GB ~[]B, A, B any](f Kleisli[A, B]) Kleisli[GA, GB]

TraverseArrayG transforms an array by applying a function that returns an Either to each element. If any element produces a Left, the entire result is that Left (short-circuits). Otherwise, returns Right containing the array of all Right values. The G suffix indicates support for generic slice types.

Example:

parse := func(s string) either.Result[int] {
    v, err := strconv.Atoi(s)
    return either.FromError(v, err)
}
result := either.TraverseArrayG[[]string, []int](parse)([]string{"1", "2", "3"})
// result is Right([]int{1, 2, 3})

func TraverseArrayWithIndex ¶

func TraverseArrayWithIndex[A, B any](f func(int, A) Result[B]) Kleisli[[]A, []B]

TraverseArrayWithIndex transforms an array by applying an indexed function that returns an Either. The function receives both the index and the element. If any element produces a Left, the entire result is that Left (short-circuits).

Example:

validate := func(i int, s string) either.Result[string] {
    if S.IsNonEmpty(s) {
        return either.Right[error](fmt.Sprintf("%d:%s", i, s))
    }
    return either.Left[string](fmt.Errorf("empty at index %d", i))
}
result := either.TraverseArrayWithIndex(validate)([]string{"a", "b"})
// result is Right([]string{"0:a", "1:b"})

package main

import (
	"fmt"

	F "github.com/IBM/fp-go/v2/function"
	R "github.com/IBM/fp-go/v2/result"

	S "github.com/IBM/fp-go/v2/string"
)

func main() {
	validate := func(i int, s string) R.Result[string] {
		if S.IsNonEmpty(s) {
			return R.Of(fmt.Sprintf("%d:%s", i, s))
		}
		return R.Left[string](fmt.Errorf("empty at index %d", i))
	}
	result := R.TraverseArrayWithIndex(validate)([]string{"a", "b"})
	fmt.Println(R.GetOrElse(F.Constant1[error]([]string{}))(result))
}

Output:

[0:a 1:b]

func TraverseArrayWithIndexG ¶

func TraverseArrayWithIndexG[GA ~[]A, GB ~[]B, A, B any](f func(int, A) Result[B]) Kleisli[GA, GB]

TraverseArrayWithIndexG transforms an array by applying an indexed function that returns an Either. The function receives both the index and the element. If any element produces a Left, the entire result is that Left (short-circuits). The G suffix indicates support for generic slice types.

Example:

validate := func(i int, s string) either.Result[string] {
    if S.IsNonEmpty(s) {
        return either.Right[error](fmt.Sprintf("%d:%s", i, s))
    }
    return either.Left[string](fmt.Errorf("empty at index %d", i))
}
result := either.TraverseArrayWithIndexG[[]string, []string](validate)([]string{"a", "b"})
// result is Right([]string{"0:a", "1:b"})

func TraverseRecord ¶

func TraverseRecord[K comparable, A, B any](f Kleisli[A, B]) Kleisli[map[K]A, map[K]B]

TraverseRecord transforms a map by applying a function that returns an Either to each value. If any value produces a Left, the entire result is that Left (short-circuits). Otherwise, returns Right containing the map of all Right values.

Example:

parse := func(s string) either.Result[int] {
    v, err := strconv.Atoi(s)
    return either.FromError(v, err)
}
result := either.TraverseRecord[string](parse)(map[string]string{"a": "1", "b": "2"})
// result is Right(map[string]int{"a": 1, "b": 2})

func TraverseRecordG ¶

func TraverseRecordG[GA ~map[K]A, GB ~map[K]B, K comparable, A, B any](f Kleisli[A, B]) Kleisli[GA, GB]

TraverseRecordG transforms a map by applying a function that returns an Either to each value. If any value produces a Left, the entire result is that Left (short-circuits). Otherwise, returns Right containing the map of all Right values. The G suffix indicates support for generic map types.

Example:

parse := func(s string) either.Result[int] {
    v, err := strconv.Atoi(s)
    return either.FromError(v, err)
}
result := either.TraverseRecordG[map[string]string, map[string]int](parse)(map[string]string{"a": "1", "b": "2"})
// result is Right(map[string]int{"a": 1, "b": 2})

func TraverseRecordWithIndex ¶

func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) Result[B]) Kleisli[map[K]A, map[K]B]

TraverseRecordWithIndex transforms a map by applying an indexed function that returns an Either. The function receives both the key and the value. If any value produces a Left, the entire result is that Left (short-circuits).

Example:

validate := func(k string, v string) either.Result[string] {
    if len(v) > 0 {
        return either.Right[error](k + ":" + v)
    }
    return either.Left[string](fmt.Errorf("empty value for key %s", k))
}
result := either.TraverseRecordWithIndex[string](validate)(map[string]string{"a": "1"})
// result is Right(map[string]string{"a": "a:1"})

func TraverseRecordWithIndexG ¶

func TraverseRecordWithIndexG[GA ~map[K]A, GB ~map[K]B, K comparable, A, B any](f func(K, A) Result[B]) Kleisli[GA, GB]

TraverseRecordWithIndexG transforms a map by applying an indexed function that returns an Either. The function receives both the key and the value. If any value produces a Left, the entire result is that Left (short-circuits). The G suffix indicates support for generic map types.

Example:

validate := func(k string, v string) either.Result[string] {
    if len(v) > 0 {
        return either.Right[error](k + ":" + v)
    }
    return either.Left[string](fmt.Errorf("empty value for key %s", k))
}
result := either.TraverseRecordWithIndexG[map[string]string, map[string]string](validate)(map[string]string{"a": "1"})
// result is Right(map[string]string{"a": "a:1"})

func WithResource ¶

func WithResource[A, R, ANY any](
	onCreate func() Result[R],
	onRelease Kleisli[R, ANY],
) Kleisli[Kleisli[R, A], A]

WithResource constructs a function that creates a resource, operates on it, and then releases it. This ensures proper resource cleanup even if operations fail. The resource is released immediately after the operation completes.

Parameters:

• onCreate: Function to create/acquire the resource
• onRelease: Function to release/cleanup the resource

Returns a function that takes an operation to perform on the resource.

Example:

withFile := either.WithResource(
    func() either.Result[*os.File] {
        return either.TryCatchError(os.Open("file.txt"))
    },
    func(f *os.File) either.Result[any] {
        return either.TryCatchError(f.Close())
    },
)
result := withFile(func(f *os.File) either.Result[string] {
    // Use file here
    return either.Right[error]("data")
})

func AltMonoid ¶

func AltMonoid[A any](zero Lazy[Result[A]]) Monoid[A]

AltMonoid creates a monoid for Either using the Alt operation. The empty value is provided as a lazy computation. When combining, returns the first Right value, or the second if the first is Left.

Example:

zero := func() either.Result[int] { return either.Left[int](errors.New("empty")) }
m := either.AltMonoid[error, int](zero)
result := m.Concat(either.Left[int](errors.New("err1")), either.Right[error](42))
// result is Right(42)

func AlternativeMonoid ¶

func AlternativeMonoid[A any](m M.Monoid[A]) Monoid[A]

AlternativeMonoid creates a monoid for Either using applicative semantics. The empty value is Right with the monoid's empty value. Combines values using applicative operations.

Example:

import "github.com/IBM/fp-go/v2/monoid"
intAdd := monoid.MakeMonoid(0, func(a, b int) int { return a + b })
m := either.AlternativeMonoid[error](intAdd)
result := m.Concat(either.Right[error](1), either.Right[error](2))
// result is Right(3)

func Alt ¶

func Alt[A any](that Lazy[Result[A]]) Operator[A, A]

Alt provides an alternative Either if the first is Left.

Example:

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

func Ap ¶

func Ap[B, A any](fa Result[A]) Operator[func(A) B, B]

Ap is the curried version of MonadAp. Returns a function that applies a wrapped function to the given wrapped value.

func ApS ¶

func ApS[S1, S2, T any](
	setter func(T) func(S1) S2,
	fa Result[T],
) Operator[S1, S2]

ApS attaches a value to a context S1 to produce a context S2 by considering the context and the value concurrently. Uses applicative semantics rather than monadic sequencing.

Example:

type State struct { x, y int }
result := F.Pipe2(
    either.Right[error](State{x: 10}),
    either.ApS(
        func(y int) func(State) State {
            return func(s State) State { return State{x: s.x, y: y} }
        },
        either.Right[error](32),
    ),
) // Right(State{x: 10, y: 32})

package main

import (
	"fmt"

	F "github.com/IBM/fp-go/v2/function"

	R "github.com/IBM/fp-go/v2/result"
)

func main() {
	type State struct {
		x, y int
	}
	result := F.Pipe1(
		R.Of(State{x: 10}),
		R.ApS(
			func(y int) func(State) State {
				return func(s State) State { return State{x: s.x, y: y} }
			},
			R.Of(32),
		),
	)
	fmt.Println(R.GetOrElse(F.Constant1[error](State{}))(result))
}

Output:

{10 32}

func ApSL ¶

func ApSL[S, T any](
	lens Lens[S, T],
	fa Result[T],
) Operator[S, S]

ApSL attaches a value to a context using a lens-based setter. This is a convenience function that combines ApS with a lens, allowing you to use optics to update nested structures in a more composable way.

The lens parameter provides both the getter and setter for a field within the structure S. This eliminates the need to manually write setter functions and enables working with nested fields in a type-safe manner.

Unlike BindL, ApSL uses applicative semantics, meaning the computation fa is independent of the current state and can be evaluated concurrently.

Type Parameters:

• E: Error type for the Either
• S: Structure type containing the field to update
• T: Type of the field being updated

Parameters:

• lens: A Lens[S, T] that focuses on a field of type T within structure S
• fa: An Result[T] computation that produces the value to set

Returns:

• An endomorphism that updates the focused field in the Either context

Example:

type Person struct {
    Name string
    Age  int
}

ageLens := lens.MakeLens(
    func(p Person) int { return p.Age },
    func(p Person, a int) Person { p.Age = a; return p },
)

result := F.Pipe2(
    either.Right[error](Person{Name: "Alice", Age: 25}),
    either.ApSL(ageLens, either.Right[error](30)),
) // Right(Person{Name: "Alice", Age: 30})

package main

import (
	"fmt"

	F "github.com/IBM/fp-go/v2/function"
	"github.com/IBM/fp-go/v2/optics/lens"

	R "github.com/IBM/fp-go/v2/result"
)

func main() {
	type Person struct {
		Name string
		Age  int
	}

	ageLens := lens.MakeLens(
		func(p Person) int { return p.Age },
		func(p Person, a int) Person { p.Age = a; return p },
	)

	result := F.Pipe1(
		R.Of(Person{Name: "Alice", Age: 25}),
		R.ApSL(ageLens, R.Of(30)),
	)
	fmt.Println(R.GetOrElse(F.Constant1[error](Person{}))(result))
}

Output:

{Alice 30}

func Bind ¶

func Bind[S1, S2, T any](
	setter func(T) func(S1) S2,
	f Kleisli[S1, T],
) Operator[S1, S2]

Bind attaches the result of a computation to a context S1 to produce a context S2. This enables building up complex computations in a pipeline.

Example:

type State struct { value int }
result := F.Pipe2(
    either.Do[error](State{}),
    either.Bind(
        func(v int) func(State) State {
            return func(s State) State { return State{value: v} }
        },
        func(s State) either.Result[int] {
            return either.Right[error](42)
        },
    ),
)

package main

import (
	"fmt"

	F "github.com/IBM/fp-go/v2/function"

	R "github.com/IBM/fp-go/v2/result"
)

func main() {
	type State struct {
		value int
	}
	result := F.Pipe1(
		R.Do(State{}),
		R.Bind(
			func(v int) func(State) State {
				return func(s State) State { return State{value: v} }
			},
			func(s State) R.Result[int] {
				return R.Of(42)
			},
		),
	)
	fmt.Println(R.GetOrElse(F.Constant1[error](State{}))(result))
}

Output:

{42}

func BindL ¶

func BindL[S, T any](
	lens Lens[S, T],
	f Kleisli[T, T],
) Operator[S, S]

BindL attaches the result of a computation to a context using a lens-based setter. This is a convenience function that combines Bind with a lens, allowing you to use optics to update nested structures based on their current values.

The lens parameter provides both the getter and setter for a field within the structure S. The computation function f receives the current value of the focused field and returns an Either that produces the new value.

Unlike ApSL, BindL uses monadic sequencing, meaning the computation f can depend on the current value of the focused field.

Type Parameters:

• E: Error type for the Either
• S: Structure type containing the field to update
• T: Type of the field being updated

Parameters:

• lens: A Lens[S, T] that focuses on a field of type T within structure S
• f: A function that takes the current field value and returns an Result[T]

Returns:

• An endomorphism that updates the focused field based on its current value

Example:

type Counter struct {
    Value int
}

valueLens := lens.MakeLens(
    func(c Counter) int { return c.Value },
    func(c Counter, v int) Counter { c.Value = v; return c },
)

// Increment the counter, but fail if it would exceed 100
increment := func(v int) either.Result[int] {
    if v >= 100 {
        return either.Left[int](errors.New("counter overflow"))
    }
    return either.Right[error](v + 1)
}

result := F.Pipe1(
    either.Right[error](Counter{Value: 42}),
    either.BindL(valueLens, increment),
) // Right(Counter{Value: 43})

package main

import (
	"errors"
	"fmt"

	F "github.com/IBM/fp-go/v2/function"
	"github.com/IBM/fp-go/v2/optics/lens"

	R "github.com/IBM/fp-go/v2/result"
)

func main() {
	type Counter struct {
		Value int
	}

	valueLens := lens.MakeLens(
		func(c Counter) int { return c.Value },
		func(c Counter, v int) Counter { c.Value = v; return c },
	)

	// Increment the counter, but fail if it would exceed 100
	increment := func(v int) R.Result[int] {
		if v >= 100 {
			return R.Left[int](errors.New("counter overflow"))
		}
		return R.Of(v + 1)
	}

	result := F.Pipe1(
		R.Of(Counter{Value: 42}),
		R.BindL(valueLens, increment),
	)
	fmt.Println(R.GetOrElse(F.Constant1[error](Counter{}))(result))
}

Output:

{43}

func BindTo ¶

func BindTo[S1, T any](
	setter func(T) S1,
) Operator[T, S1]

BindTo initializes a new state S1 from a value T. This is typically used to start a bind chain.

Example:

type State struct { value int }
result := F.Pipe2(
    either.Right[error](42),
    either.BindTo(func(v int) State { return State{value: v} }),
) // Right(State{value: 42})

package main

import (
	"fmt"

	F "github.com/IBM/fp-go/v2/function"

	R "github.com/IBM/fp-go/v2/result"
)

func main() {
	type State struct {
		value int
	}
	result := F.Pipe1(
		R.Of(42),
		R.BindTo(func(v int) State { return State{value: v} }),
	)
	fmt.Println(R.GetOrElse(F.Constant1[error](State{}))(result))
}

Output:

{42}

func Chain ¶

func Chain[A, B any](f Kleisli[A, B]) Operator[A, B]

Chain is the curried version of MonadChain. Sequences two computations where the second depends on the first.

func ChainFirst ¶

func ChainFirst[A, B any](f Kleisli[A, B]) Operator[A, A]

ChainFirst is the curried version of MonadChainFirst.

func ChainTo ¶

func ChainTo[A, B any](mb Result[B]) Operator[A, B]

ChainTo is the curried version of MonadChainTo.

func FilterOrElse ¶ added in v2.1.0

func FilterOrElse[A any](pred Predicate[A], onFalse func(A) error) Operator[A, A]

FilterOrElse filters a Result value based on a predicate. If the Result is Ok (Right) and the predicate returns true, returns the original Ok. If the Result is Ok (Right) and the predicate returns false, returns Error (Left) with the error from onFalse. If the Result is Error (Left), returns the original Error without applying the predicate.

This is useful for adding validation to successful results, converting them to errors if they don't meet certain criteria. Result[T] is an alias for Either[error, T], so this function delegates to either.FilterOrElse.

Example:

isPositive := N.MoreThan(0)
onNegative := func(x int) error { return fmt.Errorf("%d is not positive", x) }
filter := result.FilterOrElse(isPositive, onNegative)

result1 := filter(result.Of(5))  // Ok(5)
result2 := filter(result.Of(-3)) // Error(error: "-3 is not positive")
result3 := filter(result.Error[int](someError)) // Error(someError)

func Flap ¶

func Flap[B, A any](a A) Operator[func(A) B, B]

Flap is the curried version of MonadFlap.

func Let ¶

func Let[S1, S2, T any](
	key func(T) func(S1) S2,
	f func(S1) T,
) Operator[S1, S2]

Let attaches the result of a pure computation to a context S1 to produce a context S2. Similar to Bind but for pure (non-Either) computations.

Example:

type State struct { value int }
result := F.Pipe2(
    either.Right[error](State{value: 10}),
    either.Let(
        func(v int) func(State) State {
            return func(s State) State { return State{value: s.value + v} }
        },
        func(s State) int { return 32 },
    ),
) // Right(State{value: 42})

package main

import (
	"fmt"

	F "github.com/IBM/fp-go/v2/function"

	R "github.com/IBM/fp-go/v2/result"
)

func main() {
	type State struct {
		value int
	}
	result := F.Pipe1(
		R.Of(State{value: 10}),
		R.Let(
			func(v int) func(State) State {
				return func(s State) State { return State{value: s.value + v} }
			},
			func(s State) int { return 32 },
		),
	)
	fmt.Println(R.GetOrElse(F.Constant1[error](State{}))(result))
}

Output:

{42}

func LetL ¶

func LetL[S, T any](
	lens Lens[S, T],
	f Endomorphism[T],
) Operator[S, S]

LetL attaches the result of a pure computation to a context using a lens-based setter. This is a convenience function that combines Let with a lens, allowing you to use optics to update nested structures with pure transformations.

The lens parameter provides both the getter and setter for a field within the structure S. The transformation function f receives the current value of the focused field and returns the new value directly (not wrapped in Either).

This is useful for pure transformations that cannot fail, such as mathematical operations, string manipulations, or other deterministic updates.

Type Parameters:

• E: Error type for the Either
• S: Structure type containing the field to update
• T: Type of the field being updated

Parameters:

• lens: A Lens[S, T] that focuses on a field of type T within structure S
• f: An endomorphism (T → T) that transforms the current field value

Returns:

• An endomorphism that updates the focused field with the transformed value

Example:

type Counter struct {
    Value int
}

valueLens := lens.MakeLens(
    func(c Counter) int { return c.Value },
    func(c Counter, v int) Counter { c.Value = v; return c },
)

// Double the counter value
double := func(v int) int { return v * 2 }

result := F.Pipe1(
    either.Right[error](Counter{Value: 21}),
    either.LetL(valueLens, double),
) // Right(Counter{Value: 42})

package main

import (
	"fmt"

	F "github.com/IBM/fp-go/v2/function"
	"github.com/IBM/fp-go/v2/optics/lens"

	R "github.com/IBM/fp-go/v2/result"
)

func main() {
	type Counter struct {
		Value int
	}

	valueLens := lens.MakeLens(
		func(c Counter) int { return c.Value },
		func(c Counter, v int) Counter { c.Value = v; return c },
	)

	// Double the counter value
	double := func(v int) int { return v * 2 }

	result := F.Pipe1(
		R.Of(Counter{Value: 21}),
		R.LetL(valueLens, double),
	)
	fmt.Println(R.GetOrElse(F.Constant1[error](Counter{}))(result))
}

Output:

{42}

func LetTo ¶

func LetTo[S1, S2, T any](
	key func(T) func(S1) S2,
	b T,
) Operator[S1, S2]

LetTo attaches a constant value to a context S1 to produce a context S2.

Example:

type State struct { name string }
result := F.Pipe2(
    either.Right[error](State{}),
    either.LetTo(
        func(n string) func(State) State {
            return func(s State) State { return State{name: n} }
        },
        "Alice",
    ),
) // Right(State{name: "Alice"})

package main

import (
	"fmt"

	F "github.com/IBM/fp-go/v2/function"

	R "github.com/IBM/fp-go/v2/result"
)

func main() {
	type State struct {
		name string
	}
	result := F.Pipe1(
		R.Of(State{}),
		R.LetTo(
			func(n string) func(State) State {
				return func(s State) State { return State{name: n} }
			},
			"Alice",
		),
	)
	fmt.Println(R.GetOrElse(F.Constant1[error](State{}))(result))
}

Output:

{Alice}

func LetToL ¶

func LetToL[S, T any](
	lens Lens[S, T],
	b T,
) Operator[S, S]

LetToL attaches a constant value to a context using a lens-based setter. This is a convenience function that combines LetTo with a lens, allowing you to use optics to set nested fields to specific values.

The lens parameter provides the setter for a field within the structure S. Unlike LetL which transforms the current value, LetToL simply replaces it with the provided constant value b.

This is useful for resetting fields, initializing values, or setting fields to predetermined constants.

Type Parameters:

• E: Error type for the Either
• S: Structure type containing the field to update
• T: Type of the field being updated

Parameters:

• lens: A Lens[S, T] that focuses on a field of type T within structure S
• b: The constant value to set the field to

Returns:

• An endomorphism that sets the focused field to the constant value

Example:

type Config struct {
    Debug   bool
    Timeout int
}

debugLens := lens.MakeLens(
    func(c Config) bool { return c.Debug },
    func(c Config, d bool) Config { c.Debug = d; return c },
)

result := F.Pipe1(
    either.Right[error](Config{Debug: true, Timeout: 30}),
    either.LetToL(debugLens, false),
) // Right(Config{Debug: false, Timeout: 30})

package main

import (
	"fmt"

	F "github.com/IBM/fp-go/v2/function"
	"github.com/IBM/fp-go/v2/optics/lens"

	R "github.com/IBM/fp-go/v2/result"
)

func main() {
	type Config struct {
		Debug   bool
		Timeout int
	}

	debugLens := lens.MakeLens(
		func(c Config) bool { return c.Debug },
		func(c Config, d bool) Config { c.Debug = d; return c },
	)

	result := F.Pipe1(
		R.Of(Config{Debug: true, Timeout: 30}),
		R.LetToL(debugLens, false),
	)
	fmt.Println(R.GetOrElse(F.Constant1[error](Config{}))(result))
}

Output:

{false 30}

func Map ¶

func Map[A, B any](f func(a A) B) Operator[A, B]

Map is the curried version of MonadMap. Transforms the Right value using the provided function.

func MapTo ¶

func MapTo[A, B any](b B) Operator[A, B]

MapTo is the curried version of MonadMapTo.

func OrElse ¶

func OrElse[A any](onLeft Kleisli[error, A]) Operator[A, A]

OrElse recovers from a Left (error) by providing an alternative computation. If the Result is Right, it returns the value unchanged. If the Result is Left, it applies the provided function to the error value, which returns a new Result that replaces the original.

This is useful for error recovery, fallback logic, or chaining alternative computations.

Example:

// Recover from specific errors with fallback values
recover := either.OrElse(func(err error) either.Result[int] {
    if err.Error() == "not found" {
        return either.Right[error](0) // default value
    }
    return either.Left[int](err) // propagate other errors
})
result := recover(either.Left[int](errors.New("not found"))) // Right(0)
result := recover(either.Right[error](42)) // Right(42) - unchanged

func ToOption ¶

func ToOption[A any](ma Result[A]) Option[A]

ToOption converts an Either to an Option, discarding the Left value.

Example:

result := either.ToOption(either.Right[error](42)) // Some(42)
result := either.ToOption(either.Left[int](errors.New("err"))) // None

func Do ¶

func Do[S any](
	empty S,
) Result[S]

Do creates an empty context of type S to be used with the Bind operation. This is the starting point for do-notation style computations.

Example:

type State struct { x, y int }
result := either.Do[error](State{})

package main

import (
	"fmt"

	R "github.com/IBM/fp-go/v2/result"
)

func main() {
	type State struct {
		x, y int
	}
	result := R.Do(State{})
	fmt.Println(R.IsRight(result))
}

Output:

true

func Flatten ¶

func Flatten[A any](mma Result[Result[A]]) Result[A]

Flatten removes one level of nesting from a nested Either.

Example:

nested := either.Right[error](either.Right[error](42))
result := either.Flatten(nested) // Right(42)

func FromIO ¶

func FromIO[IO ~func() A, A any](f IO) Result[A]

FromIO executes an IO operation and wraps the result in a Right value. This is useful for lifting pure IO operations into the Either context.

Example:

getValue := func() int { return 42 }
result := either.FromIO[error](getValue) // Right(42)

func Left ¶

func Left[A any](value error) Result[A]

Left creates a new Either representing a Left (error/failure) value. By convention, Left represents the error case.

Example:

result := either.Left[int](errors.New("something went wrong"))

func Memoize ¶

func Memoize[A any](val Result[A]) Result[A]

Memoize returns the Either unchanged (Either values are already memoized).

func MonadAlt ¶

func MonadAlt[A any](fa Result[A], that Lazy[Result[A]]) Result[A]

MonadAlt provides an alternative Either if the first is Left. This is the monadic version of Alt.

func MonadAp ¶

func MonadAp[B, A any](fab Result[func(a A) B], fa Result[A]) Result[B]

MonadAp applies a function wrapped in Either to a value wrapped in Either. If either the function or the value is Left, returns Left. This is the applicative apply operation.

Example:

fab := either.Right[error](N.Mul(2))
fa := either.Right[error](21)
result := either.MonadAp(fab, fa) // Right(42)

func MonadChain ¶

func MonadChain[A, B any](fa Result[A], f Kleisli[A, B]) Result[B]

MonadChain sequences two computations, where the second depends on the result of the first. If the first Either is Left, returns Left without executing the second computation. This is the monadic bind operation (also known as flatMap).

Example:

result := either.MonadChain(
    either.Right[error](21),
    func(x int) either.Result[int] {
        return either.Right[error](x * 2)
    },
) // Right(42)

func MonadChainFirst ¶

func MonadChainFirst[A, B any](ma Result[A], f Kleisli[A, B]) Result[A]

MonadChainFirst executes a side-effect computation but returns the original value. Useful for performing actions (like logging) without changing the value.

Example:

result := either.MonadChainFirst(
    either.Right[error](42),
    func(x int) either.Result[string] {
        fmt.Println(x) // side effect
        return either.Right[error]("logged")
    },
) // Right(42) - original value preserved

func MonadChainOptionK ¶

func MonadChainOptionK[A, B any](onNone func() error, ma Result[A], f option.Kleisli[A, B]) Result[B]

MonadChainOptionK chains a function that returns an Option, converting None to Left.

Example:

result := either.MonadChainOptionK(
    func() error { return errors.New("not found") },
    either.Right[error](42),
    func(x int) option.Option[string] {
        if x > 0 { return option.Some("positive") }
        return option.None[string]()
    },
) // Right("positive")

func MonadChainTo ¶

func MonadChainTo[A, B any](ma Result[A], mb Result[B]) Result[B]

MonadChainTo ignores the first Either and returns the second. Useful for sequencing operations where you don't need the first result.

func MonadFlap ¶

func MonadFlap[B, A any](fab Result[func(A) B], a A) Result[B]

MonadFlap applies a value to a function wrapped in Either. This is the reverse of MonadAp.

func MonadMap ¶

func MonadMap[A, B any](fa Result[A], f func(a A) B) Result[B]

MonadMap transforms the Right value using the provided function. If the Either is Left, returns Left unchanged. This is the functor map operation.

Example:

result := either.MonadMap(
    either.Right[error](21),
    N.Mul(2),
) // Right(42)

func MonadMapTo ¶

func MonadMapTo[A, B any](fa Result[A], b B) Result[B]

MonadMapTo replaces the Right value with a constant value. If the Either is Left, returns Left unchanged.

Example:

result := either.MonadMapTo(either.Right[error](21), "success") // Right("success")

func MonadSequence2 ¶

func MonadSequence2[T1, T2, R any](e1 Result[T1], e2 Result[T2], f func(T1, T2) Result[R]) Result[R]

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

func MonadSequence3 ¶

func MonadSequence3[T1, T2, T3, R any](e1 Result[T1], e2 Result[T2], e3 Result[T3], f func(T1, T2, T3) Result[R]) Result[R]

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

func Of ¶

func Of[A any](value A) Result[A]

Of constructs a Right value containing the given value. This is the monadic return/pure operation for Either. Equivalent to Right.

Example:

result := either.Of[error](42) // Right(42)

func Right ¶

func Right[A any](value A) Result[A]

Right creates a new Either representing a Right (success) value. By convention, Right represents the success case.

Example:

result := either.Right[error](42)

func SequenceArray ¶

func SequenceArray[A any](ma []Result[A]) Result[[]A]

SequenceArray converts a homogeneous sequence of Either into an Either of sequence. If any element is Left, returns that Left (short-circuits). Otherwise, returns Right containing all the Right values.

Example:

eithers := []either.Result[int]{
    either.Right[error](1),
    either.Right[error](2),
    either.Right[error](3),
}
result := either.SequenceArray(eithers)
// result is Right([]int{1, 2, 3})

package main

import (
	"fmt"

	F "github.com/IBM/fp-go/v2/function"
	R "github.com/IBM/fp-go/v2/result"
)

func main() {
	eithers := []R.Result[int]{
		R.Of(1),
		R.Of(2),
		R.Of(3),
	}
	result := R.SequenceArray(eithers)
	fmt.Println(R.GetOrElse(F.Constant1[error]([]int{}))(result))
}

Output:

[1 2 3]

func SequenceArrayG ¶

func SequenceArrayG[GA ~[]A, GOA ~[]Result[A], A any](ma GOA) Result[GA]

func SequenceRecord ¶

func SequenceRecord[K comparable, A any](ma map[K]Result[A]) Result[map[K]A]

SequenceRecord converts a map of Either values into an Either of a map. If any value is Left, returns that Left (short-circuits). Otherwise, returns Right containing a map of all the Right values.

Example:

eithers := map[string]either.Result[int]{
    "a": either.Right[error](1),
    "b": either.Right[error](2),
}
result := either.SequenceRecord(eithers)
// result is Right(map[string]int{"a": 1, "b": 2})

func SequenceRecordG ¶

func SequenceRecordG[GA ~map[K]A, GOA ~map[K]Result[A], K comparable, A any](ma GOA) Result[GA]

func SequenceT1 ¶

func SequenceT1[T1 any](t1 Result[T1]) Result[T.Tuple1[T1]]

SequenceT1 converts 1 parameters of [Result[T]] into a [Result[Tuple1]].

func SequenceT10 ¶

func SequenceT10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t1 Result[T1], t2 Result[T2], t3 Result[T3], t4 Result[T4], t5 Result[T5], t6 Result[T6], t7 Result[T7], t8 Result[T8], t9 Result[T9], t10 Result[T10]) Result[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]

SequenceT10 converts 10 parameters of [Result[T]] into a [Result[Tuple10]].

func SequenceT11 ¶

func SequenceT11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](t1 Result[T1], t2 Result[T2], t3 Result[T3], t4 Result[T4], t5 Result[T5], t6 Result[T6], t7 Result[T7], t8 Result[T8], t9 Result[T9], t10 Result[T10], t11 Result[T11]) Result[T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]

SequenceT11 converts 11 parameters of [Result[T]] into a [Result[Tuple11]].

func SequenceT12 ¶

func SequenceT12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](t1 Result[T1], t2 Result[T2], t3 Result[T3], t4 Result[T4], t5 Result[T5], t6 Result[T6], t7 Result[T7], t8 Result[T8], t9 Result[T9], t10 Result[T10], t11 Result[T11], t12 Result[T12]) Result[T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]

SequenceT12 converts 12 parameters of [Result[T]] into a [Result[Tuple12]].

func SequenceT13 ¶

func SequenceT13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](t1 Result[T1], t2 Result[T2], t3 Result[T3], t4 Result[T4], t5 Result[T5], t6 Result[T6], t7 Result[T7], t8 Result[T8], t9 Result[T9], t10 Result[T10], t11 Result[T11], t12 Result[T12], t13 Result[T13]) Result[T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]

SequenceT13 converts 13 parameters of [Result[T]] into a [Result[Tuple13]].

func SequenceT14 ¶

func SequenceT14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](t1 Result[T1], t2 Result[T2], t3 Result[T3], t4 Result[T4], t5 Result[T5], t6 Result[T6], t7 Result[T7], t8 Result[T8], t9 Result[T9], t10 Result[T10], t11 Result[T11], t12 Result[T12], t13 Result[T13], t14 Result[T14]) Result[T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]

SequenceT14 converts 14 parameters of [Result[T]] into a [Result[Tuple14]].

func SequenceT15 ¶

func SequenceT15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](t1 Result[T1], t2 Result[T2], t3 Result[T3], t4 Result[T4], t5 Result[T5], t6 Result[T6], t7 Result[T7], t8 Result[T8], t9 Result[T9], t10 Result[T10], t11 Result[T11], t12 Result[T12], t13 Result[T13], t14 Result[T14], t15 Result[T15]) Result[T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]

SequenceT15 converts 15 parameters of [Result[T]] into a [Result[Tuple15]].

func SequenceT2 ¶

func SequenceT2[T1, T2 any](t1 Result[T1], t2 Result[T2]) Result[T.Tuple2[T1, T2]]

SequenceT2 converts 2 parameters of [Result[T]] into a [Result[Tuple2]].

func SequenceT3 ¶

func SequenceT3[T1, T2, T3 any](t1 Result[T1], t2 Result[T2], t3 Result[T3]) Result[T.Tuple3[T1, T2, T3]]

SequenceT3 converts 3 parameters of [Result[T]] into a [Result[Tuple3]].

func SequenceT4 ¶

func SequenceT4[T1, T2, T3, T4 any](t1 Result[T1], t2 Result[T2], t3 Result[T3], t4 Result[T4]) Result[T.Tuple4[T1, T2, T3, T4]]

SequenceT4 converts 4 parameters of [Result[T]] into a [Result[Tuple4]].

func SequenceT5 ¶

func SequenceT5[T1, T2, T3, T4, T5 any](t1 Result[T1], t2 Result[T2], t3 Result[T3], t4 Result[T4], t5 Result[T5]) Result[T.Tuple5[T1, T2, T3, T4, T5]]

SequenceT5 converts 5 parameters of [Result[T]] into a [Result[Tuple5]].

func SequenceT6 ¶

func SequenceT6[T1, T2, T3, T4, T5, T6 any](t1 Result[T1], t2 Result[T2], t3 Result[T3], t4 Result[T4], t5 Result[T5], t6 Result[T6]) Result[T.Tuple6[T1, T2, T3, T4, T5, T6]]

SequenceT6 converts 6 parameters of [Result[T]] into a [Result[Tuple6]].

func SequenceT7 ¶

func SequenceT7[T1, T2, T3, T4, T5, T6, T7 any](t1 Result[T1], t2 Result[T2], t3 Result[T3], t4 Result[T4], t5 Result[T5], t6 Result[T6], t7 Result[T7]) Result[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]

SequenceT7 converts 7 parameters of [Result[T]] into a [Result[Tuple7]].

func SequenceT8 ¶

func SequenceT8[T1, T2, T3, T4, T5, T6, T7, T8 any](t1 Result[T1], t2 Result[T2], t3 Result[T3], t4 Result[T4], t5 Result[T5], t6 Result[T6], t7 Result[T7], t8 Result[T8]) Result[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]

SequenceT8 converts 8 parameters of [Result[T]] into a [Result[Tuple8]].

func SequenceT9 ¶

func SequenceT9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t1 Result[T1], t2 Result[T2], t3 Result[T3], t4 Result[T4], t5 Result[T5], t6 Result[T6], t7 Result[T7], t8 Result[T8], t9 Result[T9]) Result[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]

SequenceT9 converts 9 parameters of [Result[T]] into a [Result[Tuple9]].

func SequenceTuple1 ¶

func SequenceTuple1[T1 any](t T.Tuple1[Result[T1]]) Result[T.Tuple1[T1]]

SequenceTuple1 converts a [Tuple1] of [Result[T]] into an [Result[Tuple1]].

func SequenceTuple10 ¶

func SequenceTuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t T.Tuple10[Result[T1], Result[T2], Result[T3], Result[T4], Result[T5], Result[T6], Result[T7], Result[T8], Result[T9], Result[T10]]) Result[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]

SequenceTuple10 converts a [Tuple10] of [Result[T]] into an [Result[Tuple10]].

func SequenceTuple11 ¶

func SequenceTuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](t T.Tuple11[Result[T1], Result[T2], Result[T3], Result[T4], Result[T5], Result[T6], Result[T7], Result[T8], Result[T9], Result[T10], Result[T11]]) Result[T.Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]

SequenceTuple11 converts a [Tuple11] of [Result[T]] into an [Result[Tuple11]].

func SequenceTuple12 ¶

func SequenceTuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](t T.Tuple12[Result[T1], Result[T2], Result[T3], Result[T4], Result[T5], Result[T6], Result[T7], Result[T8], Result[T9], Result[T10], Result[T11], Result[T12]]) Result[T.Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]

SequenceTuple12 converts a [Tuple12] of [Result[T]] into an [Result[Tuple12]].

func SequenceTuple13 ¶

func SequenceTuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](t T.Tuple13[Result[T1], Result[T2], Result[T3], Result[T4], Result[T5], Result[T6], Result[T7], Result[T8], Result[T9], Result[T10], Result[T11], Result[T12], Result[T13]]) Result[T.Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]

SequenceTuple13 converts a [Tuple13] of [Result[T]] into an [Result[Tuple13]].

func SequenceTuple14 ¶

func SequenceTuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](t T.Tuple14[Result[T1], Result[T2], Result[T3], Result[T4], Result[T5], Result[T6], Result[T7], Result[T8], Result[T9], Result[T10], Result[T11], Result[T12], Result[T13], Result[T14]]) Result[T.Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]

SequenceTuple14 converts a [Tuple14] of [Result[T]] into an [Result[Tuple14]].

func SequenceTuple15 ¶

func SequenceTuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](t T.Tuple15[Result[T1], Result[T2], Result[T3], Result[T4], Result[T5], Result[T6], Result[T7], Result[T8], Result[T9], Result[T10], Result[T11], Result[T12], Result[T13], Result[T14], Result[T15]]) Result[T.Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]

SequenceTuple15 converts a [Tuple15] of [Result[T]] into an [Result[Tuple15]].

func SequenceTuple2 ¶

func SequenceTuple2[T1, T2 any](t T.Tuple2[Result[T1], Result[T2]]) Result[T.Tuple2[T1, T2]]

SequenceTuple2 converts a [Tuple2] of [Result[T]] into an [Result[Tuple2]].

func SequenceTuple3 ¶

func SequenceTuple3[T1, T2, T3 any](t T.Tuple3[Result[T1], Result[T2], Result[T3]]) Result[T.Tuple3[T1, T2, T3]]

SequenceTuple3 converts a [Tuple3] of [Result[T]] into an [Result[Tuple3]].

func SequenceTuple4 ¶

func SequenceTuple4[T1, T2, T3, T4 any](t T.Tuple4[Result[T1], Result[T2], Result[T3], Result[T4]]) Result[T.Tuple4[T1, T2, T3, T4]]

SequenceTuple4 converts a [Tuple4] of [Result[T]] into an [Result[Tuple4]].

func SequenceTuple5 ¶

func SequenceTuple5[T1, T2, T3, T4, T5 any](t T.Tuple5[Result[T1], Result[T2], Result[T3], Result[T4], Result[T5]]) Result[T.Tuple5[T1, T2, T3, T4, T5]]

SequenceTuple5 converts a [Tuple5] of [Result[T]] into an [Result[Tuple5]].

func SequenceTuple6 ¶

func SequenceTuple6[T1, T2, T3, T4, T5, T6 any](t T.Tuple6[Result[T1], Result[T2], Result[T3], Result[T4], Result[T5], Result[T6]]) Result[T.Tuple6[T1, T2, T3, T4, T5, T6]]

SequenceTuple6 converts a [Tuple6] of [Result[T]] into an [Result[Tuple6]].

func SequenceTuple7 ¶

func SequenceTuple7[T1, T2, T3, T4, T5, T6, T7 any](t T.Tuple7[Result[T1], Result[T2], Result[T3], Result[T4], Result[T5], Result[T6], Result[T7]]) Result[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]

SequenceTuple7 converts a [Tuple7] of [Result[T]] into an [Result[Tuple7]].

func SequenceTuple8 ¶

func SequenceTuple8[T1, T2, T3, T4, T5, T6, T7, T8 any](t T.Tuple8[Result[T1], Result[T2], Result[T3], Result[T4], Result[T5], Result[T6], Result[T7], Result[T8]]) Result[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]

SequenceTuple8 converts a [Tuple8] of [Result[T]] into an [Result[Tuple8]].

func SequenceTuple9 ¶

func SequenceTuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t T.Tuple9[Result[T1], Result[T2], Result[T3], Result[T4], Result[T5], Result[T6], Result[T7], Result[T8], Result[T9]]) Result[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]

SequenceTuple9 converts a [Tuple9] of [Result[T]] into an [Result[Tuple9]].

func TryCatch ¶

func TryCatch[FE Endomorphism[error], A any](val A, err error, onThrow FE) Result[A]

TryCatch converts a (value, error) tuple into an Either, applying a transformation to the error.

Example:

result := either.TryCatch(
    42, nil,
    func(err error) string { return err.Error() },
) // Right(42)

func TryCatchError ¶

func TryCatchError[A any](val A, err error) Result[A]

TryCatchError is a specialized version of TryCatch for error types. Converts a (value, error) tuple into Result[A].

Example:

result := either.TryCatchError(42, nil) // Right(42)
result := either.TryCatchError(0, errors.New("fail")) // Left(error)