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.

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})()

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"})()

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"})()

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]

func AltMonoid ¶

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

func AlternativeMonoid ¶

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

func ApplicativeMonoid ¶

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

func ApplicativeMonoidPar ¶

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

func ApplicativeMonoidSeq ¶

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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]
)

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.

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)
                })
            }
        },
    ),
)

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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} }),
)

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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
    },
)

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.

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",
)

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.

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.

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.

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.

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.

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.

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.

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.

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.

func Ask ¶

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

Ask returns a ReaderReaderIOEither that retrieves the outer context.

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.

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 ensures that a resource is properly cleaned up regardless of whether the operation succeeds or fails. It follows the acquire-use-release pattern with access to both outer (R) and inner (C) reader contexts.

The release action is always called after the use action completes, whether it succeeds or fails. This makes it ideal for managing resources like file handles, database connections, or locks.

Parameters:

• acquire: Acquires the resource, returning a ReaderReaderIOEither[R, C, E, A]
• use: Uses the acquired resource to perform an operation, returning ReaderReaderIOEither[R, C, E, B]
• release: Releases the resource, receiving both the resource and the result of use

Returns:

• A ReaderReaderIOEither[R, C, E, B] that safely manages the resource lifecycle

The release function receives:

• The acquired resource (A)
• The result of the use function (Either[E, B])

Example:

type OuterConfig struct {
    ConnectionPool string
}
type InnerConfig struct {
    Timeout time.Duration
}

// Acquire a database connection
acquire := func(outer OuterConfig) readerioeither.ReaderIOEither[InnerConfig, error, *sql.DB] {
    return func(inner InnerConfig) ioeither.IOEither[error, *sql.DB] {
        return ioeither.TryCatch(
            func() (*sql.DB, error) {
                return sql.Open("postgres", outer.ConnectionPool)
            },
            func(err error) error { return err },
        )
    }
}

// Use the connection
use := func(db *sql.DB) readerreaderioeither.ReaderReaderIOEither[OuterConfig, InnerConfig, error, []User] {
    return func(outer OuterConfig) readerioeither.ReaderIOEither[InnerConfig, error, []User] {
        return func(inner InnerConfig) ioeither.IOEither[error, []User] {
            return queryUsers(db, inner.Timeout)
        }
    }
}

// Release the connection
release := func(db *sql.DB, result either.Either[error, []User]) readerreaderioeither.ReaderReaderIOEither[OuterConfig, InnerConfig, error, any] {
    return func(outer OuterConfig) readerioeither.ReaderIOEither[InnerConfig, error, any] {
        return func(inner InnerConfig) ioeither.IOEither[error, any] {
            return ioeither.TryCatch(
                func() (any, error) {
                    return nil, db.Close()
                },
                func(err error) error { return err },
            )
        }
    }
}

result := readerreaderioeither.Bracket(acquire, use, release)

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.

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{})

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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)

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.

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.

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.

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.