readerreaderioeither

func FromReaderOption ¶

func FromReaderOption[R, C, A, E any](onNone Lazy[E]) Kleisli[R, C, E, ReaderOption[R, A], A]

FromReaderOption converts a ReaderOption to a ReaderReaderIOEither. If the ReaderOption is None, the provided function is called to produce the error.

fromRO := FromReaderOption[exCfg, exReq, int](lazy.Of("missing"))

fmt.Println(exRun(fromRO(RO.Of[exCfg](5))))
fmt.Println(exRun(fromRO(RO.None[exCfg, int]())))

Output:
Right[int](5)
Left[string](missing)

func Sequence ¶ added in v2.1.17

func Sequence[R1, R2, C, E, A any](ma ReaderReaderIOEither[R2, C, E, ReaderReaderIOEither[R1, C, E, A]]) Kleisli[R2, C, E, R1, A]

Sequence swaps the order of nested environment parameters in a ReaderReaderIOEither computation.

This function takes a ReaderReaderIOEither that produces another ReaderReaderIOEither and returns a Kleisli arrow that reverses the order of the outer environment parameters (R1 and R2). The result is a curried function that takes R1 first, then R2, and produces a ReaderIOEither[C, E, A].

Type Parameters:

• R1: The first outer environment type (becomes the outermost after sequence)
• R2: The second outer environment type (becomes inner after sequence)
• C: The inner context/environment type (for the ReaderIOEither layer)
• E: The error type
• A: The success value type

Parameters:

• ma: A ReaderReaderIOEither[R2, C, E, ReaderReaderIOEither[R1, C, E, A]]

Returns:

• A Kleisli[R2, C, E, R1, A], which is func(R1) ReaderReaderIOEither[R2, C, E, A]

The function preserves error handling and IO effects at all levels while reordering the outer environment dependencies. This is particularly useful when you need to change the order in which contexts are provided to a nested computation.

Example:

type OuterConfig struct {
    DatabaseURL string
}
type InnerConfig struct {
    APIKey string
}
type RequestContext struct {
    UserID int
}

// Original: takes OuterConfig, returns computation that may produce
// another computation depending on InnerConfig
original := func(outer OuterConfig) readerioeither.ReaderIOEither[RequestContext, error,
    readerreaderioeither.ReaderReaderIOEither[InnerConfig, RequestContext, error, string]] {
    return readerioeither.Of[RequestContext, error](
        readerreaderioeither.Of[InnerConfig, RequestContext, error]("result"),
    )
}

// Sequence swaps InnerConfig and OuterConfig order
sequenced := Sequence(original)

// Now provide InnerConfig first, then OuterConfig
result := sequenced(InnerConfig{APIKey: "key"})(OuterConfig{DatabaseURL: "db"})(RequestContext{UserID: 1})()

nested := Of[string, exReq, string](exScale(4))

fmt.Println(Sequence(nested)(exConfig)("unused")(exRequest)())

Output:
Right[int](40)

func SequenceReader ¶ added in v2.1.17

func SequenceReader[R1, R2, C, E, A any](ma ReaderReaderIOEither[R2, C, E, Reader[R1, A]]) Kleisli[R2, C, E, R1, A]

SequenceReader swaps the order of environment parameters when the inner computation is a pure Reader.

This function is similar to Sequence but specialized for the case where the innermost computation is a pure Reader (without IO or error handling) rather than another ReaderReaderIOEither. It takes a ReaderReaderIOEither that produces a Reader and returns a Kleisli arrow that reverses the order of the outer environment parameters.

Type Parameters:

• R1: The first environment type (becomes outermost after sequence)
• R2: The second environment type (becomes inner after sequence)
• C: The inner context/environment type (for the ReaderIOEither layer)
• E: The error type (only present in the ReaderReaderIOEither layer)
• A: The success value type

Parameters:

• ma: A ReaderReaderIOEither[R2, C, E, Reader[R1, A]]

Returns:

• A Kleisli[R2, C, E, R1, A], which is func(R1) ReaderReaderIOEither[R2, C, E, A]

The function lifts the pure Reader computation into the ReaderIOEither context while reordering the environment dependencies.

Example:

type Config struct {
    Multiplier int
}
type Database struct {
    ConnectionString string
}
type Context struct {
    RequestID string
}

// Original: takes Config, may produce a Reader[Database, int]
original := func(cfg Config) readerioeither.ReaderIOEither[Context, error, reader.Reader[Database, int]] {
    return readerioeither.Of[Context, error](func(db Database) int {
        return len(db.ConnectionString) * cfg.Multiplier
    })
}

// Sequence to provide Database first, then Config
sequenced := SequenceReader(original)
result := sequenced(Database{ConnectionString: "localhost"})(Config{Multiplier: 2})(Context{RequestID: "123"})()

nested := Of[string, exReq, string](RD.Reader[exCfg, int](exFactor))

fmt.Println(SequenceReader(nested)(exConfig)("unused")(exRequest)())

Output:
Right[int](10)

func SequenceReaderIO ¶ added in v2.1.17

func SequenceReaderIO[R1, R2, C, E, A any](ma ReaderReaderIOEither[R2, C, E, ReaderIO[R1, A]]) Kleisli[R2, C, E, R1, A]

SequenceReaderIO swaps the order of environment parameters when the inner computation is a ReaderIO.

This function is specialized for the case where the innermost computation is a ReaderIO (with IO effects but no error handling) rather than another ReaderReaderIOEither. It takes a ReaderReaderIOEither that produces a ReaderIO and returns a Kleisli arrow that reverses the order of the outer environment parameters.

Type Parameters:

• R1: The first environment type (becomes outermost after sequence)
• R2: The second environment type (becomes inner after sequence)
• C: The inner context/environment type (for the ReaderIOEither layer)
• E: The error type (only present in the outer ReaderReaderIOEither layer)
• A: The success value type

Parameters:

• ma: A ReaderReaderIOEither[R2, C, E, ReaderIO[R1, A]]

Returns:

• A Kleisli[R2, C, E, R1, A], which is func(R1) ReaderReaderIOEither[R2, C, E, A]

The function lifts the ReaderIO computation (which has IO effects but no error handling) into the ReaderIOEither context while reordering the environment dependencies.

Example:

type Config struct {
    FilePath string
}
type Logger struct {
    Level string
}
type Context struct {
    TraceID string
}

// Original: takes Config, may produce a ReaderIO[Logger, string]
original := func(cfg Config) readerioeither.ReaderIOEither[Context, error, readerio.ReaderIO[Logger, string]] {
    return readerioeither.Of[Context, error](func(logger Logger) io.IO[string] {
        return func() string {
            return fmt.Sprintf("[%s] Reading from %s", logger.Level, cfg.FilePath)
        }
    })
}

// Sequence to provide Logger first, then Config
sequenced := SequenceReaderIO(original)
result := sequenced(Logger{Level: "INFO"})(Config{FilePath: "/data"})(Context{TraceID: "abc"})()

nested := Of[string, exReq, string](RIO.Asks(exFactor))

fmt.Println(SequenceReaderIO(nested)(exConfig)("unused")(exRequest)())

Output:
Right[int](10)

func TailRec ¶ added in v2.4.0

func TailRec[R, C, E, A, B any](f Kleisli[R, C, E, A, Trampoline[A, B]]) Kleisli[R, C, E, A, B]

TailRec implements stack-safe tail recursion for the ReaderReaderIOEither monad.

The step function f maps the current state to a computation that produces a Trampoline:

• Bounce(A): continue the recursion with the new state A
• Land(B): stop the recursion with the final result B

A Left value produced by any step stops the recursion and is returned as is.

The recursion runs in a loop, so the stack does not grow with the number of steps. The step function is only called when the resulting IO runs, and both environments R and C are passed unchanged to every step.

Type Parameters:

• R: The outer environment type
• C: The inner environment type
• E: The error type
• A: The state type that changes during the recursion
• B: The final result type

Parameters:

• f: A Kleisli arrow that computes the next step from the current state

Returns:

• Kleisli[R, C, E, A, B]: A Kleisli arrow that runs the recursion from an initial state

See Also:

• readerioeither.TailRec: Tail recursion with a single environment
• Chain: Sequences computations without loop semantics

countdown := TailRec(func(n int) exRRIOE[Trampoline[int, string]] {
	if n <= 0 {
		return Of[exCfg, exReq, string](tailrec.Land[int]("liftoff"))
	}
	return Asks[exReq, string](func(c exCfg) Trampoline[int, string] {
		return tailrec.Bounce[string](n - c.Factor)
	})
})

fmt.Println(exRun(countdown(1_000_000)))

Output:
Right[string](liftoff)

func TraverseArray ¶ added in v2.2.1

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

TraverseArray transforms an array by applying a function that returns a ReaderReaderIOEither to each element, collecting the results. The first Left short-circuits the traversal.

For an empty input array the resulting array is nil, the canonical empty array.

fmt.Println(exRun(TraverseArray(exScale)([]int{1, 2, 3})))
fmt.Println(exRun(TraverseArray(F.Flow2(exPositive, FromEither[exCfg, exReq, string, int]))([]int{1, -2, 3})))

Output:
Right[[]int]([10 20 30])
Left[string](not positive)

func AltMonoid ¶

func AltMonoid[R, C, E, A any](zero Lazy[ReaderReaderIOEither[R, C, E, A]]) Monoid[R, C, E, A]

m := AltMonoid(lazy.Of(Left[exCfg, exReq, string]("none")))

fmt.Println(exRun(m.Concat(Left[exCfg, exReq, string]("boom"), exGreet(1))))
fmt.Println(exRun(m.Concat(m.Empty(), F.Pipe1(exScale(1), Map[exCfg, exReq, string](strconv.Itoa)))))

Output:
Right[string](hi alice )
Right[string](10)

func AlternativeMonoid ¶

func AlternativeMonoid[R, C, E, A any](m monoid.Monoid[A]) Monoid[R, C, E, A]

m := AlternativeMonoid[exCfg, exReq, string](N.MonoidSum[int]())

fmt.Println(exRun(m.Concat(exScale(1), exScale(2))))
fmt.Println(exRun(m.Concat(Left[exCfg, exReq, int]("boom"), exScale(2))))

Output:
Right[int](30)
Right[int](20)

func ApplicativeMonoid ¶

func ApplicativeMonoid[R, C, E, A any](m monoid.Monoid[A]) Monoid[R, C, E, A]

m := ApplicativeMonoid[exCfg, exReq, string](N.MonoidSum[int]())

fmt.Println(exRun(m.Concat(exScale(1), exScale(2))))
fmt.Println(exRun(m.Empty()))

Output:
Right[int](30)
Right[int](0)

func ApplicativeMonoidPar ¶

func ApplicativeMonoidPar[R, C, E, A any](m monoid.Monoid[A]) Monoid[R, C, E, A]

m := ApplicativeMonoidPar[exCfg, exReq, string](N.MonoidSum[int]())

fmt.Println(exRun(m.Concat(exScale(1), exScale(2))))

Output:
Right[int](30)

func ApplicativeMonoidSeq ¶

func ApplicativeMonoidSeq[R, C, E, A any](m monoid.Monoid[A]) Monoid[R, C, E, A]

m := ApplicativeMonoidSeq[exCfg, exReq, string](N.MonoidSum[int]())

fmt.Println(exRun(m.Concat(exScale(1), Left[exCfg, exReq, int]("boom"))))

Output:
Left[string](boom)

func After ¶

func After[R, C, E, A any](timestamp time.Time) Operator[R, C, E, A, A]

After creates an operation that passes after the given time.Time.

delayed := F.Pipe1(
	Of[exCfg, exReq, string](42),
	After[exCfg, exReq, string, int](time.Now().Add(time.Millisecond)),
)

fmt.Println(exRun(delayed))

Output:
Right[int](42)

func Alt ¶

func Alt[R, C, E, A any](second Lazy[ReaderReaderIOEither[R, C, E, A]]) Operator[R, C, E, A, A]

Alt returns a function that tries an alternative computation if the first fails. This is the curried version of MonadAlt.

fallback := Alt(lazy.Of(Of[exCfg, exReq, string](0)))

fmt.Println(exRun(fallback(Of[exCfg, exReq, string](42))))
fmt.Println(exRun(fallback(Left[exCfg, exReq, int]("boom"))))

Output:
Right[int](42)
Right[int](0)

func Ap ¶

func Ap[B, R, C, E, A any](fa ReaderReaderIOEither[R, C, E, A]) Operator[R, C, E, func(A) B, B]

Ap returns a function that applies a function in a context to a value in a context. This is the curried version of MonadAp.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](N.Mul(2)),
	Ap[int](Of[exCfg, exReq, string](21)),
)))

Output:
Right[int](42)

func ApEitherS ¶

func ApEitherS[R, C, E, S1, S2, T any](
	setter func(T) func(S1) S2,
	fa Either[E, T],
) Operator[R, C, E, S1, S2]

ApEitherS applies an Either computation and attaches its result to the context.

fmt.Println(exRun(F.Pipe1(
	exDo,
	ApEitherS[exCfg, exReq](exSetX, E.Right[string](7)),
)))

Output:
Right[readerreaderioeither.exState]({7 })

func ApEitherSL ¶

func ApEitherSL[R, C, E, S, T any](
	lens Lens[S, T],
	fa Either[E, T],
) Operator[R, C, E, S, S]

ApEitherSL is a lens-based version of ApEitherS.

fmt.Println(exRun(F.Pipe1(
	exDo,
	ApEitherSL[exCfg, exReq](exXLens, E.Left[int]("invalid")),
)))

Output:
Left[string](invalid)

func ApIOEitherS ¶

func ApIOEitherS[R, C, E, S1, S2, T any](
	setter func(T) func(S1) S2,
	fa IOEither[E, T],
) Operator[R, C, E, S1, S2]

ApIOEitherS applies an IOEither computation and attaches its result to the context.

fmt.Println(exRun(F.Pipe1(
	exDo,
	ApIOEitherS[exCfg, exReq](exSetX, IOE.Of[string](7)),
)))

Output:
Right[readerreaderioeither.exState]({7 })

func ApIOEitherSL ¶

func ApIOEitherSL[R, C, E, S, T any](
	lens Lens[S, T],
	fa IOEither[E, T],
) Operator[R, C, E, S, S]

ApIOEitherSL is a lens-based version of ApIOEitherS.

fmt.Println(exRun(F.Pipe1(
	exDo,
	ApIOEitherSL[exCfg, exReq](exXLens, IOE.Of[string](7)),
)))

Output:
Right[readerreaderioeither.exState]({7 })

func ApIOS ¶

func ApIOS[R, C, E, S1, S2, T any](
	setter func(T) func(S1) S2,
	fa IO[T],
) Operator[R, C, E, S1, S2]

ApIOS applies an IO computation and attaches its result to the context.

fmt.Println(exRun(F.Pipe1(
	exDo,
	ApIOS[exCfg, exReq, string](exSetName, io.Of("bob")),
)))

Output:
Right[readerreaderioeither.exState]({0 bob})

func ApIOSL ¶

func ApIOSL[R, C, E, S, T any](
	lens Lens[S, T],
	fa IO[T],
) Operator[R, C, E, S, S]

ApIOSL is a lens-based version of ApIOS.

fmt.Println(exRun(F.Pipe1(
	exDo,
	ApIOSL[exCfg, exReq, string](exXLens, io.Of(7)),
)))

Output:
Right[readerreaderioeither.exState]({7 })

func ApReaderIOS ¶

func ApReaderIOS[C, E, R, S1, S2, T any](
	setter func(T) func(S1) S2,
	fa ReaderIO[R, T],
) Operator[R, C, E, S1, S2]

ApReaderIOS applies a ReaderIO computation and attaches its result to the context.

fmt.Println(exRun(F.Pipe1(
	exDo,
	ApReaderIOS[exReq, string](exSetX, RIO.Asks(exFactor)),
)))

Output:
Right[readerreaderioeither.exState]({10 })

func ApReaderIOSL ¶

func ApReaderIOSL[C, E, R, S, T any](
	lens Lens[S, T],
	fa ReaderIO[R, T],
) Operator[R, C, E, S, S]

ApReaderIOSL is a lens-based version of ApReaderIOS.

fmt.Println(exRun(F.Pipe1(
	exDo,
	ApReaderIOSL[exReq, string](exXLens, RIO.Asks(exFactor)),
)))

Output:
Right[readerreaderioeither.exState]({10 })

func ApReaderS ¶

func ApReaderS[C, E, R, S1, S2, T any](
	setter func(T) func(S1) S2,
	fa Reader[R, T],
) Operator[R, C, E, S1, S2]

ApReaderS applies a Reader computation and attaches its result to the context.

fmt.Println(exRun(F.Pipe1(
	exDo,
	ApReaderS[exReq, string](exSetX, exFactor),
)))

Output:
Right[readerreaderioeither.exState]({10 })

func ApReaderSL ¶

func ApReaderSL[C, E, R, S, T any](
	lens Lens[S, T],
	fa Reader[R, T],
) Operator[R, C, E, S, S]

ApReaderSL is a lens-based version of ApReaderS.

fmt.Println(exRun(F.Pipe1(
	exDo,
	ApReaderSL[exReq, string](exXLens, exFactor),
)))

Output:
Right[readerreaderioeither.exState]({10 })

func ApS ¶

func ApS[R, C, E, S1, S2, T any](
	setter func(T) func(S1) S2,
	fa ReaderReaderIOEither[R, C, E, T],
) Operator[R, C, E, S1, S2]

ApS applies a computation in parallel (applicative style) and attaches its result to the context. Unlike Bind, this doesn't allow the computation to depend on the current context state.

Example:

readerreaderioeither.ApS(
    func(count int) func(State) State {
        return func(s State) State { s.Count = count; return s }
    },
    getCount, // ReaderReaderIOEither[OuterEnv, InnerEnv, error, int]
)

fmt.Println(exRun(F.Pipe2(
	exDo,
	ApS(exSetX, exScale(3)),
	ApS(exSetName, exGreet(1)),
)))

Output:
Right[readerreaderioeither.exState]({30 hi alice })

func ApSL ¶

func ApSL[R, C, E, S, T any](
	lens Lens[S, T],
	fa ReaderReaderIOEither[R, C, E, T],
) Operator[R, C, E, S, S]

ApSL is a lens-based version of ApS that uses a lens to focus on a specific field in the context.

fmt.Println(exRun(F.Pipe1(
	exDo,
	ApSL(exXLens, exScale(3)),
)))

Output:
Right[readerreaderioeither.exState]({30 })

func Bind ¶

func Bind[R, C, E, S1, S2, T any](
	setter func(T) func(S1) S2,
	f func(S1) ReaderReaderIOEither[R, C, E, T],
) Operator[R, C, E, S1, S2]

Bind attaches the result of a computation to a context [S1] to produce a context [S2]. This enables sequential composition where each step can depend on the results of previous steps and access both the outer (R) and inner (C) reader environments.

The setter function takes the result of the computation and returns a function that updates the context from S1 to S2.

Example:

type State struct {
    User   User
    Posts  []Post
}
type OuterEnv struct {
    Database string
}
type InnerEnv struct {
    UserRepo UserRepository
    PostRepo PostRepository
}

result := F.Pipe2(
    readerreaderioeither.Do[OuterEnv, InnerEnv, error](State{}),
    readerreaderioeither.Bind(
        func(user User) func(State) State {
            return func(s State) State { s.User = user; return s }
        },
        func(s State) readerreaderioeither.ReaderReaderIOEither[OuterEnv, InnerEnv, error, User] {
            return func(outer OuterEnv) readerioeither.ReaderIOEither[InnerEnv, error, User] {
                return readerioeither.Asks(func(inner InnerEnv) ioeither.IOEither[error, User] {
                    return inner.UserRepo.FindUser(outer.Database)
                })
            }
        },
    ),
    readerreaderioeither.Bind(
        func(posts []Post) func(State) State {
            return func(s State) State { s.Posts = posts; return s }
        },
        func(s State) readerreaderioeither.ReaderReaderIOEither[OuterEnv, InnerEnv, error, []Post] {
            return func(outer OuterEnv) readerioeither.ReaderIOEither[InnerEnv, error, []Post] {
                return readerioeither.Asks(func(inner InnerEnv) ioeither.IOEither[error, []Post] {
                    return inner.PostRepo.FindPostsByUser(outer.Database, s.User.ID)
                })
            }
        },
    ),
)

fmt.Println(exRun(F.Pipe2(
	exDo,
	Bind(exSetX, F.Constant1[exState](exScale(4))),
	Bind(exSetName, F.Flow3(exGetX, S.Format[int]("x=%d"), Of[exCfg, exReq, string, string])),
)))

Output:
Right[readerreaderioeither.exState]({40 x=40})

func BindEitherK ¶

func BindEitherK[R, C, E, S1, S2, T any](
	setter func(T) func(S1) S2,
	f either.Kleisli[E, S1, T],
) Operator[R, C, E, S1, S2]

BindEitherK binds a computation that returns an Either to the context. The Kleisli function is automatically lifted into ReaderReaderIOEither.

fmt.Println(exRun(F.Pipe2(
	exDo,
	LetToL[exCfg, exReq, string](exXLens, -1),
	BindEitherK[exCfg, exReq](exSetX, F.Flow2(exGetX, exPositive)),
)))

Output:
Left[string](not positive)

func BindIOEitherK ¶

func BindIOEitherK[R, C, E, S1, S2, T any](
	setter func(T) func(S1) S2,
	f ioeither.Kleisli[E, S1, T],
) Operator[R, C, E, S1, S2]

BindIOEitherK binds a computation that returns an IOEither to the context. The Kleisli function is automatically lifted into ReaderReaderIOEither.

fmt.Println(exRun(F.Pipe1(
	exDo,
	BindIOEitherK[exCfg, exReq](exSetX, func(_ exState) IOEither[string, int] {
		return IOE.Left[int]("failed")
	}),
)))

Output:
Left[string](failed)

func BindIOEitherKL ¶

func BindIOEitherKL[R, C, E, S, T any](
	lens Lens[S, T],
	f ioeither.Kleisli[E, T, T],
) Operator[R, C, E, S, S]

BindIOEitherKL is a lens-based version of BindIOEitherK.

fmt.Println(exRun(F.Pipe2(
	exDo,
	LetToL[exCfg, exReq, string](exXLens, 3),
	BindIOEitherKL[exCfg, exReq](exXLens, F.Flow2(exPositive, IOE.FromEither[string, int])),
)))

Output:
Right[readerreaderioeither.exState]({3 })

func BindIOK ¶

func BindIOK[R, C, E, S1, S2, T any](
	setter func(T) func(S1) S2,
	f io.Kleisli[S1, T],
) Operator[R, C, E, S1, S2]

BindIOK binds a computation that returns an IO to the context. The Kleisli function is automatically lifted into ReaderReaderIOEither.

fmt.Println(exRun(F.Pipe1(
	exDo,
	BindIOK[exCfg, exReq, string](exSetX, F.Constant1[exState](io.Of(5))),
)))

Output:
Right[readerreaderioeither.exState]({5 })

func BindIOKL ¶

func BindIOKL[R, C, E, S, T any](
	lens Lens[S, T],
	f io.Kleisli[T, T],
) Operator[R, C, E, S, S]

BindIOKL is a lens-based version of BindIOK.

fmt.Println(exRun(F.Pipe2(
	exDo,
	LetToL[exCfg, exReq, string](exXLens, 3),
	BindIOKL[exCfg, exReq, string](exXLens, F.Flow2(N.Mul(2), io.Of[int])),
)))

Output:
Right[readerreaderioeither.exState]({6 })

func BindL ¶

func BindL[R, C, E, S, T any](
	lens Lens[S, T],
	f func(T) ReaderReaderIOEither[R, C, E, T],
) Operator[R, C, E, S, S]

BindL is a lens-based version of Bind that uses a lens to focus on a specific field in the context.

fmt.Println(exRun(F.Pipe2(
	exDo,
	LetToL[exCfg, exReq, string](exXLens, 4),
	BindL(exXLens, exScale),
)))

Output:
Right[readerreaderioeither.exState]({40 })

func BindReaderIOK ¶

func BindReaderIOK[C, E, R, S1, S2, T any](
	setter func(T) func(S1) S2,
	f readerio.Kleisli[R, S1, T],
) Operator[R, C, E, S1, S2]

BindReaderIOK binds a computation that returns a ReaderIO to the context. The Kleisli function is automatically lifted into ReaderReaderIOEither.

fmt.Println(exRun(F.Pipe1(
	exDo,
	BindReaderIOK[exReq, string](exSetX, F.Constant1[exState](RIO.Asks(exFactor))),
)))

Output:
Right[readerreaderioeither.exState]({10 })

func BindReaderIOKL ¶

func BindReaderIOKL[C, E, R, S, T any](
	lens Lens[S, T],
	f readerio.Kleisli[R, T, T],
) Operator[R, C, E, S, S]

BindReaderIOKL is a lens-based version of BindReaderIOK.

fmt.Println(exRun(F.Pipe2(
	exDo,
	LetToL[exCfg, exReq, string](exXLens, 3),
	BindReaderIOKL[exReq, string](exXLens, exScaleRIO),
)))

Output:
Right[readerreaderioeither.exState]({30 })

func BindReaderK ¶

func BindReaderK[C, E, R, S1, S2, T any](
	setter func(T) func(S1) S2,
	f reader.Kleisli[R, S1, T],
) Operator[R, C, E, S1, S2]

BindReaderK binds a computation that returns a Reader to the context. The Kleisli function is automatically lifted into ReaderReaderIOEither.

fmt.Println(exRun(F.Pipe1(
	exDo,
	BindReaderK[exReq, string](exSetX, F.Constant1[exState](RD.Reader[exCfg, int](exFactor))),
)))

Output:
Right[readerreaderioeither.exState]({10 })

func BindReaderKL ¶

func BindReaderKL[C, E, R, S, T any](
	lens Lens[S, T],
	f reader.Kleisli[R, T, T],
) Operator[R, C, E, S, S]

BindReaderKL is a lens-based version of BindReaderK.

fmt.Println(exRun(F.Pipe2(
	exDo,
	LetToL[exCfg, exReq, string](exXLens, 3),
	BindReaderKL[exReq, string](exXLens, exScaleR),
)))

Output:
Right[readerreaderioeither.exState]({30 })

func BindTo ¶

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

BindTo wraps a value of type T into a context S1 using the provided setter function. This is typically used as the first operation after Do to initialize the context.

Example:

F.Pipe1(
    readerreaderioeither.Of[OuterEnv, InnerEnv, error](42),
    readerreaderioeither.BindTo(func(n int) State { return State{Count: n} }),
)

fmt.Println(exRun(F.Pipe1(
	exScale(1),
	BindTo[exCfg, exReq, string](func(x int) exState { return exState{X: x} }),
)))

Output:
Right[readerreaderioeither.exState]({10 })

func Chain ¶

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

Chain returns a function that sequences computations where the second depends on the first. This is the curried version of MonadChain.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](2),
	Chain(exGreet),
)))

Output:
Right[string](hi alice hi alice )

func ChainEitherK ¶

func ChainEitherK[R, C, E, A, B any](f either.Kleisli[E, A, B]) Operator[R, C, E, A, B]

ChainEitherK returns a function that chains an Either-returning function into ReaderReaderIOEither. This is the curried version of MonadChainEitherK.

positive := ChainEitherK[exCfg, exReq](exPositive)

fmt.Println(exRun(positive(Of[exCfg, exReq, string](3))))
fmt.Println(exRun(positive(Of[exCfg, exReq, string](-3))))

Output:
Right[int](3)
Left[string](not positive)

func ChainFirst ¶

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

ChainFirst returns a function that sequences computations but keeps the first result. This is the curried version of MonadChainFirst.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](4),
	ChainFirst(exScale),
)))

Output:
Right[int](4)

func ChainFirstEitherK ¶

func ChainFirstEitherK[R, C, E, A, B any](f either.Kleisli[E, A, B]) Operator[R, C, E, A, A]

ChainFirstEitherK returns a function that chains an Either computation while preserving the original value. This is the curried version of MonadChainFirstEitherK.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](3),
	ChainFirstEitherK[exCfg, exReq](exPositive),
)))

Output:
Right[int](3)

func ChainFirstIOK ¶

func ChainFirstIOK[R, C, E, A, B any](f io.Kleisli[A, B]) Operator[R, C, E, A, A]

ChainFirstIOK returns a function that chains an IO computation while preserving the original value. This is the curried version of MonadChainFirstIOK.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](7),
	ChainFirstIOK[exCfg, exReq, string](exPrintInt),
)))

Output:
log: 7
Right[int](7)

func ChainFirstLeft ¶ added in v2.3.44

func ChainFirstLeft[A, R, C, EA, EB, B any](f Kleisli[R, C, EB, EA, B]) Operator[R, C, EA, A, A]

ChainFirstLeft chains a computation that depends on the Left value (error) but discards its result, preserving the original Left value.

This is useful for performing side effects or additional computations when an error occurs, while maintaining the original error in the result. The function executes only when the input is Left (error case).

Type Parameters:

• A: Success value type
• R: Outer reader environment type
• C: Inner reader environment type
• EA: Original error type
• EB: Error type of the chained computation
• B: Type of the chained computation's success value (discarded)

Parameters:

• f: Kleisli arrow that takes the error and returns a new ReaderReaderIOEither computation

Returns:

• An operator that transforms a ReaderReaderIOEither, executing f on Left values

Example:

type OuterCfg struct{ AppName string }
type InnerCfg struct{ LogLevel string }

logError := func(err error) ReaderReaderIOEither[OuterCfg, InnerCfg, error, F.Void] {
    return func(outer OuterCfg) ReaderIOEither[InnerCfg, error, F.Void] {
        return func(inner InnerCfg) func() IOE.IOEither[error, F.Void] {
            return func() IOE.IOEither[error, F.Void] {
                fmt.Printf("[%s][%s] Error: %v\n", outer.AppName, inner.LogLevel, err)
                return IOE.Of[error](F.VOID)
            }
        }
    }
}

computation := F.Pipe1(
    Left[OuterCfg, InnerCfg, int](errors.New("validation failed")),
    ChainFirstLeft[int](logError),
)

result := computation(OuterCfg{AppName: "MyApp"})(InnerCfg{LogLevel: "ERROR"})()
// Logs: [MyApp][ERROR] Error: validation failed
// Returns: Left(validation failed)

See Also:

• ChainFirst: Chains on Right values instead of Left
• TapLeft: Alias for ChainFirstLeft

logErr := func(e string) exRRIOE[F.Void] {
	return FromIO[exCfg, exReq, string](io.FromImpure(func() { fmt.Println("error:", e) }))
}

fmt.Println(exRun(F.Pipe1(
	Left[exCfg, exReq, int]("boom"),
	ChainFirstLeft[int](logErr),
)))

Output:
error: boom
Left[string](boom)

func ChainFirstLeftIOK ¶ added in v2.3.44

func ChainFirstLeftIOK[A, R, C, EA, B any](f io.Kleisli[EA, B]) Operator[R, C, EA, A, A]

ChainFirstLeftIOK chains an IO computation that depends on the Left value (error) but discards its result, preserving the original Left value.

This is useful for performing IO side effects (like logging to a file or sending metrics) when an error occurs, while maintaining the original error in the result. The IO computation executes only when the input is Left (error case).

Type Parameters:

• A: Success value type
• R: Outer reader environment type
• C: Inner reader environment type
• EA: Error type
• B: Type of the IO computation's result (discarded)

Parameters:

• f: IO Kleisli arrow that takes the error and returns an IO computation

Returns:

• An operator that transforms a ReaderReaderIOEither, executing f on Left values

Example:

logToFile := func(err error) io.IO[F.Void] {
    return func() F.Void {
        log.Printf("Error occurred: %v\n", err)
        return F.VOID
    }
}

computation := F.Pipe1(
    Left[OuterCfg, InnerCfg, int](errors.New("database error")),
    ChainFirstLeftIOK[int, OuterCfg, InnerCfg](logToFile),
)

result := computation(OuterCfg{})(InnerCfg{})()
// Logs: Error occurred: database error
// Returns: Left(database error)

See Also:

• ChainFirstLeft: Chains ReaderReaderIOEither computations on Left values
• TapLeftIOK: Alias for ChainFirstLeftIOK

fmt.Println(exRun(F.Pipe1(
	Left[exCfg, exReq, int]("boom"),
	ChainFirstLeftIOK[int, exCfg, exReq](exPrintErr),
)))

Output:
error: boom
Left[string](boom)

func ChainFirstReaderEitherK ¶

func ChainFirstReaderEitherK[C, E, R, A, B any](f RE.Kleisli[R, E, A, B]) Operator[R, C, E, A, A]

ChainFirstReaderEitherK returns a function that chains a ReaderEither computation while preserving the original value. This is the curried version of MonadChainFirstReaderEitherK.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](15),
	ChainFirstReaderEitherK[exReq](exAboveFactor),
)))

Output:
Right[int](15)

func ChainFirstReaderIOK ¶

func ChainFirstReaderIOK[C, E, R, A, B any](f readerio.Kleisli[R, A, B]) Operator[R, C, E, A, A]

ChainFirstReaderIOK returns a function that chains a ReaderIO computation while preserving the original value. This is the curried version of MonadChainFirstReaderIOK.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](4),
	ChainFirstReaderIOK[exReq, string](exScaleRIO),
)))

Output:
Right[int](4)

func ChainFirstReaderK ¶

func ChainFirstReaderK[C, E, R, A, B any](f reader.Kleisli[R, A, B]) Operator[R, C, E, A, A]

ChainFirstReaderK returns a function that chains a Reader computation while preserving the original value. This is the curried version of MonadChainFirstReaderK.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](4),
	ChainFirstReaderK[exReq, string](exScaleR),
)))

Output:
Right[int](4)

func ChainIOEitherK ¶

func ChainIOEitherK[R, C, E, A, B any](f IOE.Kleisli[E, A, B]) Operator[R, C, E, A, B]

ChainIOEitherK returns a function that chains an IOEither-returning function into ReaderReaderIOEither. This is the curried version of MonadChainIOEitherK.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](-1),
	ChainIOEitherK[exCfg, exReq](F.Flow2(exPositive, IOE.FromEither[string, int])),
)))

Output:
Left[string](not positive)

func ChainIOK ¶

func ChainIOK[R, C, E, A, B any](f io.Kleisli[A, B]) Operator[R, C, E, A, B]

ChainIOK returns a function that chains an IO-returning function into ReaderReaderIOEither. This is the curried version of MonadChainIOK.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](7),
	ChainIOK[exCfg, exReq, string](F.Flow2(strconv.Itoa, io.Of[string])),
)))

Output:
Right[string](7)

func ChainReaderEitherK ¶

func ChainReaderEitherK[C, E, R, A, B any](f RE.Kleisli[R, E, A, B]) Operator[R, C, E, A, B]

ChainReaderEitherK returns a function that chains a ReaderEither-returning function into ReaderReaderIOEither. This is the curried version of MonadChainReaderEitherK.

aboveFactor := ChainReaderEitherK[exReq](exAboveFactor)

fmt.Println(exRun(aboveFactor(Of[exCfg, exReq, string](15))))
fmt.Println(exRun(aboveFactor(Of[exCfg, exReq, string](5))))

Output:
Right[int](5)
Left[string](not positive)

func ChainReaderIOEitherK ¶ added in v2.2.1

func ChainReaderIOEitherK[C, R, E, A, B any](f RIOE.Kleisli[R, E, A, B]) Operator[R, C, E, A, B]

ChainReaderIOEitherK returns a function that chains a ReaderIOEither-returning function into ReaderReaderIOEither.

scale := func(n int) RIOE.ReaderIOEither[exCfg, string, int] {
	return RIOE.Asks[string](exScaleR(n))
}

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](4),
	ChainReaderIOEitherK[exReq](scale),
)))

Output:
Right[int](40)

func ChainReaderIOK ¶

func ChainReaderIOK[C, E, R, A, B any](f readerio.Kleisli[R, A, B]) Operator[R, C, E, A, B]

ChainReaderIOK returns a function that chains a ReaderIO-returning function into ReaderReaderIOEither. This is the curried version of MonadChainReaderIOK.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](4),
	ChainReaderIOK[exReq, string](exScaleRIO),
)))

Output:
Right[int](40)

func ChainReaderK ¶

func ChainReaderK[C, E, R, A, B any](f reader.Kleisli[R, A, B]) Operator[R, C, E, A, B]

ChainReaderK returns a function that chains a Reader-returning function into ReaderReaderIOEither. This is the curried version of MonadChainReaderK.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](4),
	ChainReaderK[exReq, string](exScaleR),
)))

Output:
Right[int](40)

func Delay ¶

func Delay[R, C, E, A any](delay time.Duration) Operator[R, C, E, A, A]

Delay creates an operation that passes in the value after some delay.

delayed := F.Pipe1(
	Of[exCfg, exReq, string](42),
	Delay[exCfg, exReq, string, int](time.Millisecond),
)

fmt.Println(exRun(delayed))

Output:
Right[int](42)

func Flap ¶

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

Flap returns a function that applies a fixed value to a function in a context. This is the curried version of MonadFlap.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](N.Mul(2)),
	Flap[exCfg, exReq, string, int](21),
)))

Output:
Right[int](42)

func Let ¶

func Let[R, C, E, S1, S2, T any](
	setter func(T) func(S1) S2,
	f func(S1) T,
) Operator[R, C, E, S1, S2]

Let attaches a pure computation result to a context [S1] to produce a context [S2]. Unlike Bind, the computation function f is pure (doesn't perform effects).

Example:

readerreaderioeither.Let(
    func(fullName string) func(State) State {
        return func(s State) State { s.FullName = fullName; return s }
    },
    func(s State) string {
        return s.FirstName + " " + s.LastName
    },
)

fmt.Println(exRun(F.Pipe2(
	exDo,
	LetTo[exCfg, exReq, string](exSetX, 2),
	Let[exCfg, exReq, string](exSetName, F.Flow2(exGetX, strconv.Itoa)),
)))

Output:
Right[readerreaderioeither.exState]({2 2})

func LetL ¶

func LetL[R, C, E, S, T any](
	lens Lens[S, T],
	f func(T) T,
) Operator[R, C, E, S, S]

LetL is a lens-based version of Let that uses a lens to focus on a specific field in the context.

fmt.Println(exRun(F.Pipe2(
	exDo,
	LetToL[exCfg, exReq, string](exXLens, 4),
	LetL[exCfg, exReq, string](exXLens, N.Mul(3)),
)))

Output:
Right[readerreaderioeither.exState]({12 })

func LetTo ¶

func LetTo[R, C, E, S1, S2, T any](
	setter func(T) func(S1) S2,
	b T,
) Operator[R, C, E, S1, S2]

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

Example:

readerreaderioeither.LetTo(
    func(status string) func(State) State {
        return func(s State) State { s.Status = status; return s }
    },
    "active",
)

fmt.Println(exRun(F.Pipe1(
	exDo,
	LetTo[exCfg, exReq, string](exSetName, "bob"),
)))

Output:
Right[readerreaderioeither.exState]({0 bob})

func LetToL ¶

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

LetToL is a lens-based version of LetTo that uses a lens to focus on a specific field in the context.

fmt.Println(exRun(F.Pipe1(
	exDo,
	LetToL[exCfg, exReq, string](exXLens, 4),
)))

Output:
Right[readerreaderioeither.exState]({4 })

func Map ¶

func Map[R, C, E, A, B any](f func(A) B) Operator[R, C, E, A, B]

Map returns a function that applies a transformation to the success value. This is the curried version of MonadMap.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](21),
	Map[exCfg, exReq, string](N.Mul(2)),
)))

Output:
Right[int](42)

func MapTo ¶

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

MapTo returns a function that replaces the success value with a constant. This is the curried version of MonadMapTo.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](21),
	MapTo[exCfg, exReq, string, int]("done"),
)))

Output:
Right[string](done)

func Tap ¶

func Tap[R, C, E, A, B any](f Kleisli[R, C, E, A, B]) Operator[R, C, E, A, A]

Tap is an alias for ChainFirst, executing a side effect while preserving the original value.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](4),
	Tap(exScale),
)))

Output:
Right[int](4)

func TapEitherK ¶

func TapEitherK[R, C, E, A, B any](f either.Kleisli[E, A, B]) Operator[R, C, E, A, A]

TapEitherK is an alias for ChainFirstEitherK, executing an Either side effect while preserving the original value.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](0),
	TapEitherK[exCfg, exReq](exPositive),
)))

Output:
Left[string](not positive)

func TapIOK ¶

func TapIOK[R, C, E, A, B any](f io.Kleisli[A, B]) Operator[R, C, E, A, A]

TapIOK is an alias for ChainFirstIOK, executing an IO side effect while preserving the original value.

fmt.Println(exRun(F.Pipe1(
	Left[exCfg, exReq, int]("boom"),
	TapIOK[exCfg, exReq, string](exPrintInt),
)))

Output:
Left[string](boom)

func TapLeft ¶ added in v2.3.44

func TapLeft[A, R, C, EA, EB, B any](f Kleisli[R, C, EB, EA, B]) Operator[R, C, EA, A, A]

TapLeft is an alias for ChainFirstLeft.

Chains a computation that depends on the Left value (error) but discards its result, preserving the original Left value. The name "Tap" emphasizes the side-effect nature of the operation.

This is useful for logging, metrics, or other side effects when an error occurs, without modifying the error value itself.

Type Parameters:

• A: Success value type
• R: Outer reader environment type
• C: Inner reader environment type
• EA: Original error type
• EB: Error type of the chained computation
• B: Type of the chained computation's success value (discarded)

Parameters:

• f: Kleisli arrow that takes the error and returns a new ReaderReaderIOEither computation

Returns:

• An operator that transforms a ReaderReaderIOEither, executing f on Left values

Example:

type OuterMetrics struct{ ErrorCount int }
type InnerMetrics struct{ LastError time.Time }

recordError := func(err error) ReaderReaderIOEither[OuterMetrics, InnerMetrics, error, F.Void] {
    return func(outer OuterMetrics) ReaderIOEither[InnerMetrics, error, F.Void] {
        return func(inner InnerMetrics) func() IOE.IOEither[error, F.Void] {
            return func() IOE.IOEither[error, F.Void] {
                outer.ErrorCount++
                inner.LastError = time.Now()
                return IOE.Of[error](F.VOID)
            }
        }
    }
}

pipeline := F.Pipe1(
    Left[OuterMetrics, InnerMetrics, int](errors.New("database error")),
    TapLeft[int](recordError),
)

result := pipeline(OuterMetrics{})(InnerMetrics{})()
// Increments error count and records timestamp
// Returns: Left(database error)

See Also:

• ChainFirstLeft: The underlying implementation
• Tap: Taps on Right values instead of Left

fmt.Println(exRun(F.Pipe1(
	Left[exCfg, exReq, int]("boom"),
	TapLeft[int](F.Flow2(exPrintErr, FromIO[exCfg, exReq, string, string])),
)))

Output:
error: boom
Left[string](boom)

func TapLeftIOK ¶ added in v2.3.44

func TapLeftIOK[A, R, C, EA, B any](f io.Kleisli[EA, B]) Operator[R, C, EA, A, A]

TapLeftIOK is an alias for ChainFirstLeftIOK.

Chains an IO computation that depends on the Left value (error) but discards its result, preserving the original Left value. The name "Tap" emphasizes the side-effect nature of the IO operation.

This is useful for IO side effects like logging to files, sending metrics to external services, or updating counters when an error occurs, without modifying the error value itself.

Type Parameters:

• A: Success value type
• R: Outer reader environment type
• C: Inner reader environment type
• EA: Error type
• B: Type of the IO computation's result (discarded)

Parameters:

• f: IO Kleisli arrow that takes the error and returns an IO computation

Returns:

• An operator that transforms a ReaderReaderIOEither, executing f on Left values

Example:

sendAlert := func(err error) io.IO[F.Void] {
    return func() F.Void {
        alertService.Send("Critical error: " + err.Error())
        return F.VOID
    }
}

pipeline := F.Pipe1(
    Left[OuterCfg, InnerCfg, int](errors.New("critical failure")),
    TapLeftIOK[int, OuterCfg, InnerCfg](sendAlert),
)

result := pipeline(OuterCfg{})(InnerCfg{})()
// Sends alert to external service
// Returns: Left(critical failure)

See Also:

• ChainFirstLeftIOK: The underlying implementation
• TapLeft: Taps with ReaderReaderIOEither computations

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](1),
	TapLeftIOK[int, exCfg, exReq](exPrintErr),
)))

Output:
Right[int](1)

func TapReaderEitherK ¶

func TapReaderEitherK[C, E, R, A, B any](f RE.Kleisli[R, E, A, B]) Operator[R, C, E, A, A]

TapReaderEitherK is an alias for ChainFirstReaderEitherK, executing a ReaderEither side effect while preserving the original value.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](15),
	TapReaderEitherK[exReq](exAboveFactor),
)))

Output:
Right[int](15)

func TapReaderIOK ¶

func TapReaderIOK[C, E, R, A, B any](f readerio.Kleisli[R, A, B]) Operator[R, C, E, A, A]

TapReaderIOK is an alias for ChainFirstReaderIOK, executing a ReaderIO side effect while preserving the original value.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](4),
	TapReaderIOK[exReq, string](exScaleRIO),
)))

Output:
Right[int](4)

func TapReaderK ¶

func TapReaderK[C, E, R, A, B any](f reader.Kleisli[R, A, B]) Operator[R, C, E, A, A]

TapReaderK is an alias for ChainFirstReaderK, executing a Reader side effect while preserving the original value.

fmt.Println(exRun(F.Pipe1(
	Of[exCfg, exReq, string](4),
	TapReaderK[exReq, string](exScaleR),
)))

Output:
Right[int](4)

func Ask ¶

func Ask[R, C, E any]() ReaderReaderIOEither[R, C, E, R]

Ask returns a ReaderReaderIOEither that retrieves the outer context.

fmt.Println(exRun(Ask[exCfg, exReq, string]()))

Output:
Right[readerreaderioeither.exCfg]({10})

func Asks ¶

func Asks[C, E, R, A any](r Reader[R, A]) ReaderReaderIOEither[R, C, E, A]

Asks returns a ReaderReaderIOEither that retrieves a value derived from the outer context.

fmt.Println(exRun(Asks[exReq, string](exFactor)))

Output:
Right[int](10)

func Bracket ¶

func Bracket[
	R, C, E, A, B, ANY any](
	acquire ReaderReaderIOEither[R, C, E, A],
	use Kleisli[R, C, E, A, B],
	release func(A, Either[E, B]) ReaderReaderIOEither[R, C, E, ANY],
) ReaderReaderIOEither[R, C, E, B]

Bracket safely acquires a resource, uses it, and releases it again, following the acquire-use-release pattern. All three steps run with access to both the outer (R) and the inner (C) environment.

Semantics:

1. acquire is executed. If it fails, its error is returned and neither use nor release is executed (there is nothing to release).
2. use is executed with the acquired resource.
3. release is executed with the resource and the outcome of use (an Either[E, B]). It runs no matter whether use succeeded or failed.
4. If release succeeds, the outcome of use is returned unchanged (a failed use stays failed). If release fails, its error is returned instead, even if use succeeded, and it replaces the error of a failed use.

The value produced by a successful release (of type ANY) is discarded.

Bracket is lazy: no step runs until both environments have been supplied and the resulting IO is executed. Every execution acquires and releases a fresh resource.

Bracket is implemented point-free on top of the generic bracket combinator: the resource is threaded through MonadChain, and the outcome of use, which may be a Left, is fed into release via a chain over the full Either.

Type Parameters:

• R: The outer environment type
• C: The inner environment type
• E: The error type
• A: The resource type
• B: The result type of use
• ANY: The (ignored) result type of release

Parameters:

• acquire: Produces the resource
• use: Computes the result from the resource
• release: Frees the resource; it receives the resource and the outcome of use

Returns:

• A ReaderReaderIOEither[R, C, E, B] that yields the result of use and guarantees that release runs whenever acquire succeeded

See Also:

• ExampleBracket: basic acquire/use/close pattern
• ExampleBracket_useFails: resource released even when use returns Left
• ExampleBracket_acquireFails: neither use nor release run when acquire returns Left
• ExampleBracket_transaction: release receives the outcome of use to commit or roll back

query := func(conn *exampleConn) ReaderReaderIOEither[exampleConfig, exampleRequest, error, string] {
	return func(_ exampleConfig) ReaderIOEither[exampleRequest, error, string] {
		return func(req exampleRequest) IOEither[error, string] {
			return IOE.Of[error](fmt.Sprintf("%s queried %s", req.user, conn.pool))
		}
	}
}

program := Bracket(openConn, query, closeConn[string])

// nothing has happened so far, the program only runs once both environments
// are provided and the resulting IO is executed
fmt.Println(program(exampleConfig{pool: "users-db"})(exampleRequest{user: "alice"})())

Output:
open users-db for alice
close users-db
Right[string](alice queried users-db)

acquire := Left[exampleConfig, exampleRequest, *exampleConn](errors.New("pool exhausted"))

query := func(conn *exampleConn) ReaderReaderIOEither[exampleConfig, exampleRequest, error, string] {
	fmt.Println("query")
	return Of[exampleConfig, exampleRequest, error](conn.pool)
}

program := Bracket(acquire, query, closeConn[string])

fmt.Println(program(exampleConfig{pool: "users-db"})(exampleRequest{user: "carol"})())

Output:
Left[*errors.errorString](pool exhausted)

type tx struct{ id int }

begin := FromIO[exampleConfig, exampleRequest, error](func() *tx {
	fmt.Println("begin")
	return &tx{id: 1}
})

commitOrRollback := func(t *tx, outcome Either[error, int]) ReaderReaderIOEither[exampleConfig, exampleRequest, error, F.Void] {
	return FromIO[exampleConfig, exampleRequest, error](func() F.Void {
		if E.IsRight(outcome) {
			fmt.Printf("commit %d\n", t.id)
		} else {
			fmt.Printf("rollback %d\n", t.id)
		}
		return F.VOID
	})
}

transfer := func(amount int) ReaderReaderIOEither[exampleConfig, exampleRequest, error, int] {
	return Bracket(
		begin,
		func(_ *tx) ReaderReaderIOEither[exampleConfig, exampleRequest, error, int] {
			if amount <= 0 {
				return Left[exampleConfig, exampleRequest, int](fmt.Errorf("invalid amount %d", amount))
			}
			return Of[exampleConfig, exampleRequest, error](amount)
		},
		commitOrRollback,
	)
}

cfg := exampleConfig{pool: "ledger"}
req := exampleRequest{user: "dave"}

fmt.Println(transfer(100)(cfg)(req)())
fmt.Println(transfer(-5)(cfg)(req)())

Output:
begin
commit 1
Right[int](100)
begin
rollback 1
Left[*errors.errorString](invalid amount -5)

query := func(_ *exampleConn) ReaderReaderIOEither[exampleConfig, exampleRequest, error, string] {
	return Left[exampleConfig, exampleRequest, string](errors.New("query failed"))
}

program := Bracket(openConn, query, closeConn[string])

fmt.Println(program(exampleConfig{pool: "users-db"})(exampleRequest{user: "bob"})())

Output:
open users-db for bob
close users-db
Left[*errors.errorString](query failed)

func Defer ¶ added in v2.2.1

func Defer[R, C, E, A any](fa Lazy[ReaderReaderIOEither[R, C, E, A]]) ReaderReaderIOEither[R, C, E, A]

Defer creates a ReaderReaderIOEither lazily via a generator function. The generator is called each time the ReaderReaderIOEither is executed.

// Defer creates a ReaderReaderIOEither lazily: the generator function is
// called every time the computation is executed, not when it is constructed.

callCount := 0
computation := Defer(func() ReaderReaderIOEither[OuterConfig, InnerConfig, error, int] {
	callCount++
	return Of[OuterConfig, InnerConfig, error](callCount * 10)
})

// Generator has not been called yet.
fmt.Println("before execution:", callCount)

r1 := computation(OuterConfig{})(InnerConfig{})()
fmt.Println("after first execution:", E.IsRight(r1), callCount)

r2 := computation(OuterConfig{})(InnerConfig{})()
fmt.Println("after second execution:", E.IsRight(r2), callCount)

Output:
before execution: 0
after first execution: true 1
after second execution: true 2

// Defer composes naturally with other operators in a pipeline.

computation := F.Pipe1(
	Defer(func() ReaderReaderIOEither[OuterConfig, InnerConfig, error, int] {
		return Of[OuterConfig, InnerConfig, error](21)
	}),
	Chain(func(n int) ReaderReaderIOEither[OuterConfig, InnerConfig, error, int] {
		return Of[OuterConfig, InnerConfig, error](n * 2)
	}),
)

result := computation(OuterConfig{})(InnerConfig{})()
fmt.Println(E.IsRight(result))

Output:
true

// Defer propagates the Left value produced by the deferred computation.

expectedErr := errors.New("something failed")
computation := Defer(func() ReaderReaderIOEither[OuterConfig, InnerConfig, error, int] {
	return Left[OuterConfig, InnerConfig, int](expectedErr)
})

result := computation(OuterConfig{})(InnerConfig{})()
fmt.Println(E.IsLeft(result))

Output:
true

func Do ¶

func Do[R, C, E, S any](
	empty S,
) ReaderReaderIOEither[R, C, E, 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 composition with two reader contexts.

Example:

type State struct {
    User   User
    Posts  []Post
}
type OuterEnv struct {
    Database string
}
type InnerEnv struct {
    UserRepo UserRepository
    PostRepo PostRepository
}
result := readerreaderioeither.Do[OuterEnv, InnerEnv, error](State{})

fmt.Println(exRun(Do[exCfg, exReq, string](exState{X: 1})))

Output:
Right[readerreaderioeither.exState]({1 })

func Flatten ¶

func Flatten[R, C, E, A any](mma ReaderReaderIOEither[R, C, E, ReaderReaderIOEither[R, C, E, A]]) ReaderReaderIOEither[R, C, E, A]

Flatten removes one level of nesting from a nested ReaderReaderIOEither.

nested := Of[exCfg, exReq, string](Of[exCfg, exReq, string](42))

fmt.Println(exRun(Flatten(nested)))

Output:
Right[int](42)

func FromEither ¶

func FromEither[R, C, E, A any](t Either[E, A]) ReaderReaderIOEither[R, C, E, A]

FromEither lifts an Either into a ReaderReaderIOEither context.

fmt.Println(exRun(FromEither[exCfg, exReq](exPositive(3))))
fmt.Println(exRun(FromEither[exCfg, exReq](exPositive(-3))))

Output:
Right[int](3)
Left[string](not positive)

func FromIO ¶

func FromIO[R, C, E, A any](ma IO[A]) ReaderReaderIOEither[R, C, E, A]

FromIO lifts an IO into a ReaderReaderIOEither context.

fmt.Println(exRun(FromIO[exCfg, exReq, string](func() int {
	fmt.Println("side effect")
	return 1
})))

Output:
side effect
Right[int](1)

func FromIOEither ¶

func FromIOEither[R, C, E, A any](ma IOEither[E, A]) ReaderReaderIOEither[R, C, E, A]

FromIOEither lifts an IOEither into a ReaderReaderIOEither context.

fmt.Println(exRun(FromIOEither[exCfg, exReq](IOE.Of[string](7))))

Output:
Right[int](7)

func FromReader ¶

func FromReader[C, E, R, A any](ma Reader[R, A]) ReaderReaderIOEither[R, C, E, A]

FromReader lifts a Reader into a ReaderReaderIOEither context.

fmt.Println(exRun(FromReader[exReq, string](exFactor)))

Output:
Right[int](10)

func FromReaderEither ¶

func FromReaderEither[R, C, E, A any](ma RE.ReaderEither[R, E, A]) ReaderReaderIOEither[R, C, E, A]

FromReaderEither lifts a ReaderEither into a ReaderReaderIOEither context.

fmt.Println(exRun(FromReaderEither[exCfg, exReq](RE.Of[exCfg, string](5))))

Output:
Right[int](5)

func FromReaderIO ¶

func FromReaderIO[C, E, R, A any](ma ReaderIO[R, A]) ReaderReaderIOEither[R, C, E, A]

FromReaderIO lifts a ReaderIO into a ReaderReaderIOEither, placing the result in the Right side.

fmt.Println(exRun(FromReaderIO[exReq, string](RIO.Asks(exFactor))))

Output:
Right[int](10)

func FromReaderIOEither ¶

func FromReaderIOEither[C, E, R, A any](ma ReaderIOEither[R, E, A]) ReaderReaderIOEither[R, C, E, A]

FromReaderIOEither lifts a ReaderIOEither into a ReaderReaderIOEither context.

fmt.Println(exRun(FromReaderIOEither[exReq](RIOE.Of[exCfg, string](5))))

Output:
Right[int](5)

func Left ¶

func Left[R, C, A, E any](e E) ReaderReaderIOEither[R, C, E, A]

Left creates a failed ReaderReaderIOEither with the given error.

fmt.Println(exRun(Left[exCfg, exReq, int]("boom")))

Output:
Left[string](boom)

func LeftIO ¶

func LeftIO[R, C, A, E any](ma IO[E]) ReaderReaderIOEither[R, C, E, A]

LeftIO lifts an IO into a ReaderReaderIOEither, placing the result in the Left (error) side.

fmt.Println(exRun(LeftIO[exCfg, exReq, int](lazy.Of("boom"))))

Output:
Left[string](boom)

func LeftReader ¶

func LeftReader[C, A, R, E any](ma Reader[R, E]) ReaderReaderIOEither[R, C, E, A]

LeftReader lifts a Reader into a ReaderReaderIOEither, placing the result in the Left (error) side.

fmt.Println(exRun(LeftReader[exReq, int](F.Flow2(exFactor, strconv.Itoa))))

Output:
Left[string](10)

func LeftReaderIO ¶

func LeftReaderIO[C, A, R, E any](me ReaderIO[R, E]) ReaderReaderIOEither[R, C, E, A]

LeftReaderIO lifts a ReaderIO into a ReaderReaderIOEither, placing the result in the Left (error) side.

fmt.Println(exRun(LeftReaderIO[exReq, int](RIO.Of[exCfg]("boom"))))

Output:
Left[string](boom)

func MonadAlt ¶

func MonadAlt[R, C, E, A any](first ReaderReaderIOEither[R, C, E, A], second Lazy[ReaderReaderIOEither[R, C, E, A]]) ReaderReaderIOEither[R, C, E, A]

MonadAlt tries the first computation, and if it fails, tries the second.

fmt.Println(exRun(MonadAlt(Left[exCfg, exReq, int]("boom"), lazy.Of(exScale(1)))))

Output:
Right[int](10)

func MonadAp ¶

func MonadAp[R, C, E, A, B any](fab ReaderReaderIOEither[R, C, E, func(A) B], fa ReaderReaderIOEither[R, C, E, A]) ReaderReaderIOEither[R, C, E, B]

MonadAp applies a function wrapped in a context to a value wrapped in a context.

fmt.Println(exRun(MonadAp(Of[exCfg, exReq, string](N.Mul(2)), exScale(2))))

Output:
Right[int](40)

func MonadApPar ¶

func MonadApPar[R, C, E, A, B any](fab ReaderReaderIOEither[R, C, E, func(A) B], fa ReaderReaderIOEither[R, C, E, A]) ReaderReaderIOEither[R, C, E, B]

MonadApPar applies a function in a context to a value in a context, executing them in parallel.

fmt.Println(exRun(MonadApPar(Of[exCfg, exReq, string](N.Mul(2)), Left[exCfg, exReq, int]("boom"))))

Output:
Left[string](boom)

func MonadApSeq ¶

func MonadApSeq[R, C, E, A, B any](fab ReaderReaderIOEither[R, C, E, func(A) B], fa ReaderReaderIOEither[R, C, E, A]) ReaderReaderIOEither[R, C, E, B]

MonadApSeq applies a function in a context to a value in a context, executing them sequentially.

fmt.Println(exRun(MonadApSeq(Of[exCfg, exReq, string](S.Format[int]("#%d")), exScale(2))))

Output:
Right[string](#20)

func MonadChain ¶

func MonadChain[R, C, E, A, B any](fa ReaderReaderIOEither[R, C, E, A], f Kleisli[R, C, E, A, B]) ReaderReaderIOEither[R, C, E, B]

MonadChain sequences two computations where the second depends on the result of the first.

fmt.Println(exRun(MonadChain(Of[exCfg, exReq, string](4), exScale)))

Output:
Right[int](40)

func MonadChainEitherK ¶

func MonadChainEitherK[R, C, E, A, B any](ma ReaderReaderIOEither[R, C, E, A], f either.Kleisli[E, A, B]) ReaderReaderIOEither[R, C, E, B]

MonadChainEitherK chains a computation that returns an Either into a ReaderReaderIOEither.

fmt.Println(exRun(MonadChainEitherK(Of[exCfg, exReq, string](-3), exPositive)))

Output:
Left[string](not positive)

func MonadChainFirst ¶

func MonadChainFirst[R, C, E, A, B any](fa ReaderReaderIOEither[R, C, E, A], f Kleisli[R, C, E, A, B]) ReaderReaderIOEither[R, C, E, A]

MonadChainFirst sequences two computations but keeps the result of the first. Useful for performing side effects while preserving the original value.

fmt.Println(exRun(MonadChainFirst(Of[exCfg, exReq, string](4), exGreet)))

Output:
Right[int](4)

func MonadChainFirstEitherK ¶

func MonadChainFirstEitherK[R, C, E, A, B any](ma ReaderReaderIOEither[R, C, E, A], f either.Kleisli[E, A, B]) ReaderReaderIOEither[R, C, E, A]

MonadChainFirstEitherK chains an Either-returning computation but keeps the original value.

fmt.Println(exRun(MonadChainFirstEitherK(Of[exCfg, exReq, string](0), exPositive)))

Output:
Left[string](not positive)

func MonadChainFirstIOK ¶

func MonadChainFirstIOK[R, C, E, A, B any](ma ReaderReaderIOEither[R, C, E, A], f io.Kleisli[A, B]) ReaderReaderIOEither[R, C, E, A]

MonadChainFirstIOK chains an IO computation but keeps the original value.

fmt.Println(exRun(MonadChainFirstIOK(Of[exCfg, exReq, string](7), exPrintInt)))

Output:
log: 7
Right[int](7)

func MonadChainFirstLeft ¶ added in v2.3.44

func MonadChainFirstLeft[R, C, EA, EB, A, B any](ma ReaderReaderIOEither[R, C, EA, A], f Kleisli[R, C, EB, EA, B]) ReaderReaderIOEither[R, C, EA, A]

MonadChainFirstLeft is the monadic version of ChainFirstLeft.

Chains a computation that depends on the Left value (error) but discards its result, preserving the original Left value. This is the uncurried version that takes both the ReaderReaderIOEither and the function as parameters.

Type Parameters:

• R: Outer reader environment type
• C: Inner reader environment type
• EA: Original error type
• EB: Error type of the chained computation
• A: Success value type
• B: Type of the chained computation's success value (discarded)

Parameters:

• ma: The input ReaderReaderIOEither computation
• f: Kleisli arrow that takes the error and returns a new ReaderReaderIOEither computation

Returns:

• A ReaderReaderIOEither that executes f on Left values but preserves the original error

Example:

type OuterCfg struct{ RetryCount int }
type InnerCfg struct{ Timeout time.Duration }

incrementRetry := func(err error) ReaderReaderIOEither[OuterCfg, InnerCfg, error, F.Void] {
    return func(outer OuterCfg) ReaderIOEither[InnerCfg, error, F.Void] {
        return func(inner InnerCfg) func() IOE.IOEither[error, F.Void] {
            return func() IOE.IOEither[error, F.Void] {
                outer.RetryCount++
                return IOE.Of[error](F.VOID)
            }
        }
    }
}

failedOp := Left[OuterCfg, InnerCfg, string](errors.New("network timeout"))
result := MonadChainFirstLeft(failedOp, incrementRetry)
// Increments retry count but returns: Left(network timeout)

See Also:

• ChainFirstLeft: Curried version
• MonadChainFirst: Chains on Right values instead of Left

fmt.Println(exRun(MonadChainFirstLeft(
	Of[exCfg, exReq, string](1),
	F.Flow2(strings.ToUpper, Left[exCfg, exReq, int, string]),
)))

Output:
Right[int](1)

func MonadChainFirstLeftIOK ¶ added in v2.3.44

func MonadChainFirstLeftIOK[R, C, EA, A, B any](ma ReaderReaderIOEither[R, C, EA, A], f io.Kleisli[EA, B]) ReaderReaderIOEither[R, C, EA, A]

MonadChainFirstLeftIOK is the monadic version of ChainFirstLeftIOK.

Chains an IO computation that depends on the Left value (error) but discards its result, preserving the original Left value. This is the uncurried version that takes both the ReaderReaderIOEither and the IO function as parameters.

Type Parameters:

• R: Outer reader environment type
• C: Inner reader environment type
• EA: Error type
• A: Success value type
• B: Type of the IO computation's result (discarded)

Parameters:

• ma: The input ReaderReaderIOEither computation
• f: IO Kleisli arrow that takes the error and returns an IO computation

Returns:

• A ReaderReaderIOEither that executes f on Left values but preserves the original error

Example:

incrementCounter := func(err error) io.IO[F.Void] {
    return func() F.Void {
        errorCounter++
        return F.VOID
    }
}

failedOp := Left[OuterCfg, InnerCfg, string](errors.New("timeout"))
result := MonadChainFirstLeftIOK(failedOp, incrementCounter)
// Increments counter but returns: Left(timeout)

See Also:

• ChainFirstLeftIOK: Curried version
• MonadChainFirstLeft: Chains ReaderReaderIOEither computations on Left values

fmt.Println(exRun(MonadChainFirstLeftIOK(Left[exCfg, exReq, int]("boom"), exPrintErr)))

Output:
error: boom
Left[string](boom)

func MonadChainFirstReaderEitherK ¶

func MonadChainFirstReaderEitherK[R, C, E, A, B any](ma ReaderReaderIOEither[R, C, E, A], f RE.Kleisli[R, E, A, B]) ReaderReaderIOEither[R, C, E, A]

MonadChainFirstReaderEitherK chains a ReaderEither computation but keeps the original value.

fmt.Println(exRun(MonadChainFirstReaderEitherK(Of[exCfg, exReq, string](5), exAboveFactor)))

Output:
Left[string](not positive)

func MonadChainFirstReaderIOK ¶

func MonadChainFirstReaderIOK[C, E, R, A, B any](ma ReaderReaderIOEither[R, C, E, A], f readerio.Kleisli[R, A, B]) ReaderReaderIOEither[R, C, E, A]

MonadChainFirstReaderIOK chains a ReaderIO computation but keeps the original value.

fmt.Println(exRun(MonadChainFirstReaderIOK(Of[exCfg, exReq, string](4), exScaleRIO)))

Output:
Right[int](4)

func MonadChainFirstReaderK ¶

func MonadChainFirstReaderK[C, E, R, A, B any](ma ReaderReaderIOEither[R, C, E, A], f reader.Kleisli[R, A, B]) ReaderReaderIOEither[R, C, E, A]

MonadChainFirstReaderK chains a Reader computation but keeps the original value.

fmt.Println(exRun(MonadChainFirstReaderK(Of[exCfg, exReq, string](4), exScaleR)))

Output:
Right[int](4)

func MonadChainIOEitherK ¶

func MonadChainIOEitherK[R, C, E, A, B any](ma ReaderReaderIOEither[R, C, E, A], f IOE.Kleisli[E, A, B]) ReaderReaderIOEither[R, C, E, B]

MonadChainIOEitherK chains an IOEither-returning computation into a ReaderReaderIOEither.

fmt.Println(exRun(MonadChainIOEitherK(
	Of[exCfg, exReq, string](1),
	F.Flow2(exPositive, IOE.FromEither[string, int]),
)))

Output:
Right[int](1)

func MonadChainIOK ¶

func MonadChainIOK[R, C, E, A, B any](ma ReaderReaderIOEither[R, C, E, A], f io.Kleisli[A, B]) ReaderReaderIOEither[R, C, E, B]

MonadChainIOK chains an IO-returning computation into a ReaderReaderIOEither.

fmt.Println(exRun(MonadChainIOK(Of[exCfg, exReq, string](7), exPrintInt)))

Output:
log: 7
Right[int](7)

func MonadChainLeft ¶

func MonadChainLeft[R, C, EA, EB, A any](fa ReaderReaderIOEither[R, C, EA, A], f Kleisli[R, C, EB, EA, A]) ReaderReaderIOEither[R, C, EB, A]

MonadChainLeft chains a computation on the error channel, allowing error recovery or transformation.

res := MonadChainLeft(
	Left[exCfg, exReq, int]("boom"),
	F.Flow2(strings.ToUpper, Left[exCfg, exReq, int, string]),
)

fmt.Println(exRun(res))

Output:
Left[string](BOOM)

func MonadChainReaderEitherK ¶

func MonadChainReaderEitherK[R, C, E, A, B any](ma ReaderReaderIOEither[R, C, E, A], f RE.Kleisli[R, E, A, B]) ReaderReaderIOEither[R, C, E, B]

MonadChainReaderEitherK chains a ReaderEither-returning computation into a ReaderReaderIOEither.

fmt.Println(exRun(MonadChainReaderEitherK(Of[exCfg, exReq, string](15), exAboveFactor)))

Output:
Right[int](5)

func MonadChainReaderIOK ¶

func MonadChainReaderIOK[C, E, R, A, B any](ma ReaderReaderIOEither[R, C, E, A], f readerio.Kleisli[R, A, B]) ReaderReaderIOEither[R, C, E, B]

MonadChainReaderIOK chains a ReaderIO-returning computation into a ReaderReaderIOEither.

fmt.Println(exRun(MonadChainReaderIOK(Of[exCfg, exReq, string](4), exScaleRIO)))

Output:
Right[int](40)

func MonadChainReaderK ¶

func MonadChainReaderK[C, E, R, A, B any](ma ReaderReaderIOEither[R, C, E, A], f reader.Kleisli[R, A, B]) ReaderReaderIOEither[R, C, E, B]

MonadChainReaderK chains a Reader-returning computation into a ReaderReaderIOEither.

fmt.Println(exRun(MonadChainReaderK(Of[exCfg, exReq, string](4), exScaleR)))

Output:
Right[int](40)

func MonadFlap ¶

func MonadFlap[R, C, E, B, A any](fab ReaderReaderIOEither[R, C, E, func(A) B], a A) ReaderReaderIOEither[R, C, E, B]

MonadFlap applies a value to a function wrapped in a context.

fmt.Println(exRun(MonadFlap(Of[exCfg, exReq, string](N.Mul(2)), 21)))

Output:
Right[int](42)

func MonadMap ¶

func MonadMap[R, C, E, A, B any](fa ReaderReaderIOEither[R, C, E, A], f func(A) B) ReaderReaderIOEither[R, C, E, B]

MonadMap applies a function to the value inside a ReaderReaderIOEither context. If the computation is successful (Right), the function is applied to the value.

fmt.Println(exRun(MonadMap(Of[exCfg, exReq, string](21), N.Mul(2))))

Output:
Right[int](42)

func MonadMapLeft ¶

func MonadMapLeft[R, C, E1, E2, A any](fa ReaderReaderIOEither[R, C, E1, A], f func(E1) E2) ReaderReaderIOEither[R, C, E2, A]

MonadMapLeft applies a function to the error value, leaving success unchanged.

res := MonadMapLeft(Left[exCfg, exReq, int]("boom"), S.Size)(exConfig)(exRequest)()

fmt.Println(res)

Output:
Left[int](4)

func MonadMapTo ¶

func MonadMapTo[R, C, E, A, B any](fa ReaderReaderIOEither[R, C, E, A], b B) ReaderReaderIOEither[R, C, E, B]

MonadMapTo replaces the success value with a constant value.

fmt.Println(exRun(MonadMapTo(Of[exCfg, exReq, string](21), "done")))

Output:
Right[string](done)

func MonadTap ¶

func MonadTap[R, C, E, A, B any](fa ReaderReaderIOEither[R, C, E, A], f Kleisli[R, C, E, A, B]) ReaderReaderIOEither[R, C, E, A]

MonadTap is an alias for MonadChainFirst, executing a side effect while preserving the original value.

fmt.Println(exRun(MonadTap(Left[exCfg, exReq, int]("boom"), exScale)))

Output:
Left[string](boom)

func MonadTapEitherK ¶

func MonadTapEitherK[R, C, E, A, B any](ma ReaderReaderIOEither[R, C, E, A], f either.Kleisli[E, A, B]) ReaderReaderIOEither[R, C, E, A]

MonadTapEitherK is an alias for MonadChainFirstEitherK, executing an Either side effect while preserving the original value.

fmt.Println(exRun(MonadTapEitherK(Of[exCfg, exReq, string](3), exPositive)))

Output:
Right[int](3)

func MonadTapIOK ¶

func MonadTapIOK[R, C, E, A, B any](ma ReaderReaderIOEither[R, C, E, A], f io.Kleisli[A, B]) ReaderReaderIOEither[R, C, E, A]

MonadTapIOK is an alias for MonadChainFirstIOK, executing an IO side effect while preserving the original value.

fmt.Println(exRun(MonadTapIOK(Of[exCfg, exReq, string](7), exPrintInt)))

Output:
log: 7
Right[int](7)

func MonadTapLeft ¶ added in v2.3.44

func MonadTapLeft[R, C, EA, EB, A, B any](ma ReaderReaderIOEither[R, C, EA, A], f Kleisli[R, C, EB, EA, B]) ReaderReaderIOEither[R, C, EA, A]

MonadTapLeft is the monadic version of TapLeft.

Chains a computation that depends on the Left value (error) but discards its result, preserving the original Left value. This is the uncurried version that takes both the ReaderReaderIOEither and the function as parameters. The name "Tap" emphasizes the side-effect nature of the operation.

Type Parameters:

• R: Outer reader environment type
• C: Inner reader environment type
• EA: Original error type
• EB: Error type of the chained computation
• A: Success value type
• B: Type of the chained computation's success value (discarded)

Parameters:

• ma: The input ReaderReaderIOEither computation
• f: Kleisli arrow that takes the error and returns a new ReaderReaderIOEither computation

Returns:

• A ReaderReaderIOEither that executes f on Left values but preserves the original error

Example:

type OuterLogger struct{ Prefix string }
type InnerLogger struct{ Verbose bool }

logFailure := func(err error) ReaderReaderIOEither[OuterLogger, InnerLogger, error, F.Void] {
    return func(outer OuterLogger) ReaderIOEither[InnerLogger, error, F.Void] {
        return func(inner InnerLogger) func() IOE.IOEither[error, F.Void] {
            return func() IOE.IOEither[error, F.Void] {
                if inner.Verbose {
                    fmt.Printf("%s: %v\n", outer.Prefix, err)
                }
                return IOE.Of[error](F.VOID)
            }
        }
    }
}

operation := Left[OuterLogger, InnerLogger, int](errors.New("parse error"))
result := MonadTapLeft(operation, logFailure)
// Logs the error with prefix if verbose mode is enabled
// Returns: Left(parse error)

See Also:

• TapLeft: Curried version
• MonadTap: Taps on Right values instead of Left

fmt.Println(exRun(MonadTapLeft(
	Left[exCfg, exReq, int]("boom"),
	F.Flow2(exPrintErr, FromIO[exCfg, exReq, string, string]),
)))

Output:
error: boom
Left[string](boom)

func MonadTapLeftIOK ¶ added in v2.3.44

func MonadTapLeftIOK[R, C, EA, A, B any](ma ReaderReaderIOEither[R, C, EA, A], f io.Kleisli[EA, B]) ReaderReaderIOEither[R, C, EA, A]

MonadTapLeftIOK is the monadic version of TapLeftIOK.

Chains an IO computation that depends on the Left value (error) but discards its result, preserving the original Left value. This is the uncurried version that takes both the ReaderReaderIOEither and the IO function as parameters. The name "Tap" emphasizes the side-effect nature of the IO operation.

Type Parameters:

• R: Outer reader environment type
• C: Inner reader environment type
• EA: Error type
• A: Success value type
• B: Type of the IO computation's result (discarded)

Parameters:

• ma: The input ReaderReaderIOEither computation
• f: IO Kleisli arrow that takes the error and returns an IO computation

Returns:

• A ReaderReaderIOEither that executes f on Left values but preserves the original error

Example:

writeToLog := func(err error) io.IO[F.Void] {
    return func() F.Void {
        logFile.WriteString(fmt.Sprintf("[ERROR] %v\n", err))
        return F.VOID
    }
}

operation := Left[OuterCfg, InnerCfg, int](errors.New("parse error"))
result := MonadTapLeftIOK(operation, writeToLog)
// Writes error to log file
// Returns: Left(parse error)

See Also:

• TapLeftIOK: Curried version
• MonadTapLeft: Taps with ReaderReaderIOEither computations

fmt.Println(exRun(MonadTapLeftIOK(Left[exCfg, exReq, int]("boom"), exPrintErr)))

Output:
error: boom
Left[string](boom)

func MonadTapReaderEitherK ¶

func MonadTapReaderEitherK[R, C, E, A, B any](ma ReaderReaderIOEither[R, C, E, A], f RE.Kleisli[R, E, A, B]) ReaderReaderIOEither[R, C, E, A]

MonadTapReaderEitherK is an alias for MonadChainFirstReaderEitherK, executing a ReaderEither side effect while preserving the original value.

fmt.Println(exRun(MonadTapReaderEitherK(Of[exCfg, exReq, string](15), exAboveFactor)))

Output:
Right[int](15)

func MonadTapReaderIOK ¶

func MonadTapReaderIOK[C, E, R, A, B any](ma ReaderReaderIOEither[R, C, E, A], f readerio.Kleisli[R, A, B]) ReaderReaderIOEither[R, C, E, A]

MonadTapReaderIOK is an alias for MonadChainFirstReaderIOK, executing a ReaderIO side effect while preserving the original value.

fmt.Println(exRun(MonadTapReaderIOK(Of[exCfg, exReq, string](4), exScaleRIO)))

Output:
Right[int](4)

func MonadTapReaderK ¶

func MonadTapReaderK[C, E, R, A, B any](ma ReaderReaderIOEither[R, C, E, A], f reader.Kleisli[R, A, B]) ReaderReaderIOEither[R, C, E, A]

MonadTapReaderK is an alias for MonadChainFirstReaderK, executing a Reader side effect while preserving the original value.

fmt.Println(exRun(MonadTapReaderK(Of[exCfg, exReq, string](4), exScaleR)))

Output:
Right[int](4)

func Of ¶

func Of[R, C, E, A any](a A) ReaderReaderIOEither[R, C, E, A]

Of creates a successful ReaderReaderIOEither with the given value. This is the pointed functor operation.

fmt.Println(exRun(Of[exCfg, exReq, string](42)))

Output:
Right[int](42)

func Retrying ¶

func Retrying[R, C, E, A any](
	policy retry.RetryPolicy,
	action Kleisli[R, C, E, retry.RetryStatus, A],
	check Predicate[Either[E, A]],
) ReaderReaderIOEither[R, C, E, A]

Retrying retries an action according to a retry policy until it succeeds or the policy gives up. The action receives a RetryStatus that tracks the retry attempt number and cumulative delay. The check predicate determines whether a result should trigger a retry.

This is useful for operations that may fail transiently and need to be retried with backoff, while having access to both outer (R) and inner (C) reader contexts.

Parameters:

• policy: The retry policy that determines delays and when to give up
• action: A Kleisli function that takes RetryStatus and returns a ReaderReaderIOEither
• check: A predicate that returns true if the result should trigger a retry

Returns:

• A ReaderReaderIOEither that will retry according to the policy

Example:

type OuterConfig struct {
    MaxRetries int
}
type InnerConfig struct {
    Endpoint string
}

// Retry a network call with exponential backoff
policy := retry.ExponentialBackoff(100*time.Millisecond, 2.0)

action := func(status retry.RetryStatus) readerreaderioeither.ReaderReaderIOEither[OuterConfig, InnerConfig, error, Response] {
    return func(outer OuterConfig) readerioeither.ReaderIOEither[InnerConfig, error, Response] {
        return func(inner InnerConfig) ioeither.IOEither[error, Response] {
            return ioeither.TryCatch(
                func() (Response, error) {
                    return makeRequest(inner.Endpoint)
                },
                func(err error) error { return err },
            )
        }
    }
}

// Retry on network errors
check := func(result either.Either[error, Response]) bool {
    return either.IsLeft(result) && isNetworkError(either.GetLeft(result))
}

result := readerreaderioeither.Retrying(policy, action, check)

action := func(status retry.RetryStatus) exRRIOE[int] {
	return FromEither[exCfg, exReq](exPositive(int(status.IterNumber) - 1))
}

retried := Retrying(retry.LimitRetries(5), action, E.IsLeft[string, int])

fmt.Println(exRun(retried))

Output:
Right[int](1)

func Right ¶

func Right[R, C, E, A any](a A) ReaderReaderIOEither[R, C, E, A]

Right creates a successful ReaderReaderIOEither with the given value.

fmt.Println(exRun(Right[exCfg, exReq, string](42)))

Output:
Right[int](42)

func RightIO ¶

func RightIO[R, C, E, A any](ma IO[A]) ReaderReaderIOEither[R, C, E, A]

RightIO lifts an IO into a ReaderReaderIOEither, placing the result in the Right side.

fmt.Println(exRun(RightIO[exCfg, exReq, string](lazy.Of(1))))

Output:
Right[int](1)

func RightReader ¶

func RightReader[C, E, R, A any](ma Reader[R, A]) ReaderReaderIOEither[R, C, E, A]

RightReader lifts a Reader into a ReaderReaderIOEither, placing the result in the Right side.

fmt.Println(exRun(RightReader[exReq, string](exFactor)))

Output:
Right[int](10)

func RightReaderIO ¶

func RightReaderIO[C, E, R, A any](ma ReaderIO[R, A]) ReaderReaderIOEither[R, C, E, A]

RightReaderIO lifts a ReaderIO into a ReaderReaderIOEither, placing the result in the Right side.

fmt.Println(exRun(RightReaderIO[exReq, string](RIO.Asks(exFactor))))

Output:
Right[int](10)