readerreaderioresult

package
v2.1.16 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 19, 2026 License: Apache-2.0 Imports: 31 Imported by: 0

Documentation

Overview

Package readerreaderioresult provides a functional programming abstraction that combines four powerful concepts: Reader, Reader, IO, and Result (Either[error, A]) monads in a nested structure. This is a specialized version of readerreaderioeither where the error type is fixed to `error` and the inner context is fixed to `context.Context`.

Type Definition

ReaderReaderIOResult[R, A] is defined as: 

type ReaderReaderIOResult[R, A] = ReaderReaderIOEither[R, context.Context, error, A]

Which expands to: 

func(R) func(context.Context) func() Either[error, A]

This represents a computation that:

  • Takes an outer environment/context of type R
  • Returns a function that takes a context.Context
  • Returns an IO operation (a thunk/function with no parameters)
  • Produces an Either[error, A] (Result[A]) when executed

Type Parameter Ordering Convention

This package follows a consistent convention for ordering type parameters in function signatures. The general rule is: R -> C -> E -> T (outer context, inner context, error, type), where:

  • R: The outer Reader context/environment type
  • C: The inner Reader context/environment type (for the ReaderIOEither)
  • E: The Either error type
  • T: The value type(s) (A, B, etc.)

However, when some type parameters can be automatically inferred by the Go compiler from function arguments, the convention is modified to minimize explicit type annotations:

Rule: Undetectable types come first, followed by detectable types, while preserving the relative order within each group (R -> C -> E -> T).

Examples:

  1. All types detectable from first argument: MonadMap[R, C, E, A, B](fa ReaderReaderIOEither[R, C, E, A], f func(A) B) - R, C, E, A are detectable from fa - B is detectable from f - Order: R, C, E, A, B (standard order, all detectable)

  2. Some types undetectable: FromReader[C, E, R, A](ma Reader[R, A]) ReaderReaderIOEither[R, C, E, A] - R, A are detectable from ma - C, E are undetectable (not in any argument) - Order: C, E, R, A (C, E first as undetectable, then R, A in standard order)

  3. Multiple undetectable types: Local[C, E, A, R1, R2](f func(R2) R1) func(ReaderReaderIOEither[R1, C, E, A]) ReaderReaderIOEither[R2, C, E, A] - C, E, A are undetectable - R1, R2 are detectable from f - Order: C, E, A, R1, R2 (undetectable first, then detectable)

  4. Functions returning Kleisli arrows: ChainReaderOptionK[R, C, A, B, E](onNone Lazy[E]) func(readeroption.Kleisli[R, A, B]) Operator[R, C, E, A, B] - Canonical order would be R, C, E, A, B - E is detectable from onNone parameter - R, C, A, B are not detectable (they're in the Kleisli argument type) - Order: R, C, A, B, E (undetectable R, C, A, B first, then detectable E)

This convention allows for more ergonomic function calls: 

// Without convention - need to specify all types:
result := FromReader[OuterCtx, InnerCtx, error, User](readerFunc)

// With convention - only specify undetectable types:
result := FromReader[InnerCtx, error](readerFunc)  // R and A inferred from readerFunc

The reasoning behind this approach is to reduce the number of explicit type parameters that developers need to specify when calling functions, improving code readability and reducing verbosity while maintaining type safety.

Additional examples demonstrating the convention:

  1. FromReaderOption[R, C, A, E](onNone Lazy[E]) Kleisli[R, C, E, ReaderOption[R, A], A] - Canonical order would be R, C, E, A - E is detectable from onNone parameter - R, C, A are not detectable (they're in the return type's Kleisli) - Order: R, C, A, E (undetectable R, C, A first, then detectable E)

  2. MapLeft[R, C, A, E1, E2](f func(E1) E2) func(ReaderReaderIOEither[R, C, E1, A]) ReaderReaderIOEither[R, C, E2, A] - Canonical order would be R, C, E1, E2, A - E1, E2 are detectable from f parameter - R, C, A are not detectable (they're in the return type) - Order: R, C, A, E1, E2 (undetectable R, C, A first, then detectable E1, E2)

Additional special cases:

  • Ap[B, R, C, E, A]: B is undetectable (in function return type), so B comes first
  • ChainOptionK[R, C, A, B, E]: R, C, A, B are undetectable, E is detectable from onNone
  • FromReaderIO[C, E, R, A]: C, E are undetectable, R, A are detectable from ReaderIO[R, A]

All functions in this package follow this convention consistently.

Fantasy Land Specification

This is a monad transformer combining:

Implemented Fantasy Land algebras:

ReaderReaderIOEither

ReaderReaderIOEither[R, C, E, A] represents a computation that:

  • Depends on an outer context/environment of type R (outer Reader)
  • Returns a computation that depends on an inner context/environment of type C (inner Reader)
  • Performs side effects (IO)
  • Can fail with an error of type E or succeed with a value of type A (Either)

This is particularly useful for:

  • Multi-level dependency injection patterns
  • Layered architectures with different context requirements at each layer
  • Composing operations that need access to multiple levels of configuration or context
  • Building reusable components that can be configured at different stages

Core Operations

Construction:

  • Of/Right: Create a successful computation
  • Left: Create a failed computation
  • FromEither: Lift an Either into ReaderReaderIOEither
  • FromIO: Lift an IO into ReaderReaderIOEither
  • FromReader: Lift a Reader into ReaderReaderIOEither
  • FromReaderIO: Lift a ReaderIO into ReaderReaderIOEither
  • FromIOEither: Lift an IOEither into ReaderReaderIOEither
  • FromReaderEither: Lift a ReaderEither into ReaderReaderIOEither
  • FromReaderIOEither: Lift a ReaderIOEither into ReaderReaderIOEither
  • FromReaderOption: Lift a ReaderOption into ReaderReaderIOEither

Transformation:

  • Map: Transform the success value
  • MapLeft: Transform the error value
  • Chain/Bind: Sequence dependent computations
  • Flatten: Flatten nested ReaderReaderIOEither

Combination:

  • Ap: Apply a function in a context to a value in a context
  • ApSeq: Sequential application
  • ApPar: Parallel application

Error Handling:

  • Alt: Choose the first successful computation

Context Access:

  • Ask: Get the current outer context
  • Asks: Get a value derived from the outer context
  • Local: Run a computation with a modified outer context
  • Read: Execute with a specific outer context

Kleisli Composition:

  • ChainEitherK: Chain with Either-returning functions
  • ChainReaderK: Chain with Reader-returning functions
  • ChainReaderIOK: Chain with ReaderIO-returning functions
  • ChainReaderEitherK: Chain with ReaderEither-returning functions
  • ChainReaderOptionK: Chain with ReaderOption-returning functions
  • ChainIOEitherK: Chain with IOEither-returning functions
  • ChainIOK: Chain with IO-returning functions
  • ChainOptionK: Chain with Option-returning functions

First/Tap Operations (execute for side effects, return original value):

  • ChainFirst/Tap: Execute a computation but return the original value
  • ChainFirstEitherK/TapEitherK: Tap with Either-returning functions
  • ChainFirstReaderK/TapReaderK: Tap with Reader-returning functions
  • ChainFirstReaderIOK/TapReaderIOK: Tap with ReaderIO-returning functions
  • ChainFirstReaderEitherK/TapReaderEitherK: Tap with ReaderEither-returning functions
  • ChainFirstReaderOptionK/TapReaderOptionK: Tap with ReaderOption-returning functions
  • ChainFirstIOK/TapIOK: Tap with IO-returning functions

Example Usage 

type AppConfig struct {
    DatabaseURL string
    LogLevel    string
}

// A computation that depends on AppConfig and context.Context
func fetchUser(id int) ReaderReaderIOResult[AppConfig, User] {
    return func(cfg AppConfig) readerioresult.ReaderIOResult[context.Context, User] {
        // Use cfg.DatabaseURL and cfg.LogLevel
        return func(ctx context.Context) ioresult.IOResult[User] {
            // Use ctx for cancellation/timeout
            return func() result.Result[User] {
                // Perform the actual IO operation
                // Return result.Of(user) or result.Error[User](err)
            }
        }
    }
}

// Compose operations
result := function.Pipe2(
    fetchUser(123),
    Map[AppConfig](func(u User) string { return u.Name }),
    Chain[AppConfig](func(name string) ReaderReaderIOResult[AppConfig, string] {
        return Of[AppConfig]("Hello, " + name)
    }),
)

// Execute with config and context
appConfig := AppConfig{DatabaseURL: "postgres://...", LogLevel: "info"}
ctx := t.Context()
outcome := result(appConfig)(ctx)() // Returns result.Result[string]

Use Cases

This monad is particularly useful for:

  • Applications with layered configuration (app config + request context)
  • HTTP handlers that need both application config and request context
  • Database operations with connection pool config and query context
  • Retry logic with policy configuration and execution context
  • Resource management with bracket pattern across multiple contexts

Relationship to Other Packages

  • readerreaderioeither: The generic version with configurable error and context types
  • readerioresult: Single reader with context.Context and error
  • readerresult: Single reader with error (no IO)
  • context/readerioresult: Alias for readerioresult with context.Context

Copyright (c) 2025 IBM Corp. All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ChainFirstReaderOptionK 

func ChainFirstReaderOptionK[R, A, B any](onNone Lazy[error]) func(readeroption.Kleisli[R, A, B]) Operator[R, A, A]

func ChainLeft 

func ChainLeft[R, A any](f Kleisli[R, error, A]) func(ReaderReaderIOResult[R, A]) ReaderReaderIOResult[R, A]

func ChainOptionK 

func ChainOptionK[R, A, B any](onNone Lazy[error]) func(option.Kleisli[A, B]) Operator[R, A, B]

func ChainReaderOptionK 

func ChainReaderOptionK[R, A, B any](onNone Lazy[error]) func(readeroption.Kleisli[R, A, B]) Operator[R, A, B]

func FromOption 

func FromOption[R, A any](onNone Lazy[error]) func(Option[A]) ReaderReaderIOResult[R, A]

func Local 

func Local[A, R1, R2 any](f func(R2) R1) func(ReaderReaderIOResult[R1, A]) ReaderReaderIOResult[R2, A]

func Read 

func Read[A, R any](r R) func(ReaderReaderIOResult[R, A]) ReaderIOResult[context.Context, A]

func ReadIO 

func ReadIO[A, R any](rio IO[R]) func(ReaderReaderIOResult[R, A]) ReaderIOResult[context.Context, A]

func ReadIOEither 

func ReadIOEither[A, R any](rio IOEither[error, R]) func(ReaderReaderIOResult[R, A]) ReaderIOResult[context.Context, A]

func TapReaderOptionK 

func TapReaderOptionK[R, A, B any](onNone Lazy[error]) func(readeroption.Kleisli[R, A, B]) Operator[R, A, A]

Types

type Either 

type Either[E, A any] = either.Either[E, A]

type Endmorphism 

type Endmorphism[A any] = endomorphism.Endomorphism[A]

type IO 

type IO[A any] = io.IO[A]

type IOEither 

type IOEither[E, A any] = ioeither.IOEither[E, A]

type IOResult 

type IOResult[A any] = ioresult.IOResult[A]

type Kleisli 

type Kleisli[R, A, B any] = Reader[A, ReaderReaderIOResult[R, B]]

func FromPredicate 

func FromPredicate[R, A any](pred func(A) bool, onFalse func(A) error) Kleisli[R, A, A]

func FromReaderOption 

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

type Lazy 

type Lazy[A any] = lazy.Lazy[A]

type Lens 

type Lens[S, T any] = lens.Lens[S, T]

type Monoid 

type Monoid[R, A any] = monoid.Monoid[ReaderReaderIOResult[R, A]]

func AltMonoid 

func AltMonoid[R, A any](zero Lazy[ReaderReaderIOResult[R, A]]) Monoid[R, A]

func AlternativeMonoid 

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

func ApplicativeMonoid 

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

func ApplicativeMonoidPar 

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

func ApplicativeMonoidSeq 

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

type Operator 

type Operator[R, A, B any] = Kleisli[R, ReaderReaderIOResult[R, A], B]

func Alt 

func Alt[R, A any](second Lazy[ReaderReaderIOResult[R, A]]) Operator[R, A, A]

func Ap 

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

func ApEitherS 

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

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

func ApEitherSL 

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

ApEitherSL is a lens-based version of ApEitherS.

func ApIOEitherS 

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

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

func ApIOEitherSL 

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

ApIOEitherSL is a lens-based version of ApIOEitherS.

func ApIOS 

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

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

func ApIOSL 

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

ApIOSL is a lens-based version of ApIOS.

func ApReaderIOS 

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

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

func ApReaderIOSL 

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

ApReaderIOSL is a lens-based version of ApReaderIOS.

func ApReaderS 

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

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

func ApReaderSL 

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

ApReaderSL is a lens-based version of ApReaderS.

func ApS 

func ApS[R, S1, S2, T any](
	setter func(T) func(S1) S2,
	fa ReaderReaderIOResult[R, T],
) Operator[R, 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, // ReaderReaderIOResult[OuterEnv, InnerEnv, error, int]
)

func ApSL 

func ApSL[R, S, T any](
	lens Lens[S, T],
	fa ReaderReaderIOResult[R, T],
) Operator[R, 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, S1, S2, T any](
	setter func(T) func(S1) S2,
	f func(S1) ReaderReaderIOResult[R, T],
) Operator[R, 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.ReaderReaderIOResult[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.ReaderReaderIOResult[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, S1, S2, T any](
	setter func(T) func(S1) S2,
	f either.Kleisli[error, S1, T],
) Operator[R, S1, S2]

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

func BindIOEitherK 

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

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

func BindIOEitherKL 

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

BindIOEitherKL is a lens-based version of BindIOEitherK.

func BindIOK 

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

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

func BindIOKL 

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

BindIOKL is a lens-based version of BindIOK.

func BindIOResultK 

func BindIOResultK[R, S1, S2, T any](
	setter func(T) func(S1) S2,
	f ioresult.Kleisli[S1, T],
) Operator[R, S1, S2]

func BindL 

func BindL[R, S, T any](
	lens Lens[S, T],
	f func(T) ReaderReaderIOResult[R, T],
) Operator[R, 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[R, S1, S2, T any](
	setter func(T) func(S1) S2,
	f readerio.Kleisli[R, S1, T],
) Operator[R, S1, S2]

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

func BindReaderIOKL 

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

BindReaderIOKL is a lens-based version of BindReaderIOK.

func BindReaderK 

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

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

func BindReaderKL 

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

BindReaderKL is a lens-based version of BindReaderK.

func BindTo 

func BindTo[R, S1, T any](
	setter func(T) S1,
) Operator[R, 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, A, B any](f Kleisli[R, A, B]) Operator[R, A, B]

func ChainEitherK 

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

func ChainFirst 

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

func ChainFirstEitherK 

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

func ChainFirstIOK 

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

func ChainFirstReaderEitherK 

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

func ChainFirstReaderIOK 

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

func ChainFirstReaderK 

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

func ChainIOEitherK 

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

func ChainIOK 

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

func ChainReaderEitherK 

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

func ChainReaderIOK 

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

func ChainReaderK 

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

func Delay 

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

func Flap 

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

func Let 

func Let[R, S1, S2, T any](
	setter func(T) func(S1) S2,
	f func(S1) T,
) Operator[R, 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, S, T any](
	lens Lens[S, T],
	f func(T) T,
) Operator[R, 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, S1, S2, T any](
	setter func(T) func(S1) S2,
	b T,
) Operator[R, 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, S, T any](
	lens Lens[S, T],
	b T,
) Operator[R, 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, A, B any](f func(A) B) Operator[R, A, B]

func MapLeft 

func MapLeft[R, A any](f Endmorphism[error]) Operator[R, A, A]

func MapTo 

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

func Tap 

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

func TapEitherK 

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

func TapIOK 

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

func TapReaderEitherK 

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

func TapReaderIOK 

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

func TapReaderK 

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

type Option 

type Option[A any] = option.Option[A]

type Predicate 

type Predicate[A any] = predicate.Predicate[A]

type Reader 

type Reader[R, A any] = reader.Reader[R, A]

type ReaderIO 

type ReaderIO[R, A any] = readerio.ReaderIO[R, A]

type ReaderIOResult 

type ReaderIOResult[R, A any] = readerioresult.ReaderIOResult[R, A]

type ReaderOption 

type ReaderOption[R, A any] = readeroption.ReaderOption[R, A]

type ReaderReaderIOEither 

type ReaderReaderIOEither[R, C, E, A any] = readerreaderioeither.ReaderReaderIOEither[R, C, E, A]

type ReaderReaderIOResult 

type ReaderReaderIOResult[R, A any] = ReaderReaderIOEither[R, context.Context, error, A]

func Ask 

func Ask[R any]() ReaderReaderIOResult[R, R]

func Asks 

func Asks[R, A any](r Reader[R, A]) ReaderReaderIOResult[R, A]

func Bracket 

func Bracket[
	R, A, B, ANY any](

	acquire ReaderReaderIOResult[R, A],
	use func(A) ReaderReaderIOResult[R, B],
	release func(A, Result[B]) ReaderReaderIOResult[R, ANY],
) ReaderReaderIOResult[R, 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 Do 

func Do[R, S any](
	empty S,
) ReaderReaderIOResult[R, 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, A any](mma ReaderReaderIOResult[R, ReaderReaderIOResult[R, A]]) ReaderReaderIOResult[R, A]

func FromEither 

func FromEither[R, A any](t Either[error, A]) ReaderReaderIOResult[R, A]

func FromIO 

func FromIO[R, A any](ma IO[A]) ReaderReaderIOResult[R, A]

func FromIOEither 

func FromIOEither[R, A any](ma IOEither[error, A]) ReaderReaderIOResult[R, A]

func FromIOResult 

func FromIOResult[R, A any](ma IOResult[A]) ReaderReaderIOResult[R, A]

func FromReader 

func FromReader[R, A any](ma Reader[R, A]) ReaderReaderIOResult[R, A]

func FromReaderEither 

func FromReaderEither[R, A any](ma RE.ReaderEither[R, error, A]) ReaderReaderIOResult[R, A]

func FromReaderIO 

func FromReaderIO[R, A any](ma ReaderIO[R, A]) ReaderReaderIOResult[R, A]

func FromReaderIOResult 

func FromReaderIOResult[R, A any](ma ReaderIOResult[R, A]) ReaderReaderIOResult[R, A]

func FromResult 

func FromResult[R, A any](t Result[A]) ReaderReaderIOResult[R, A]

func Left 

func Left[R, A any](e error) ReaderReaderIOResult[R, A]

func LeftIO 

func LeftIO[R, A any](ma IO[error]) ReaderReaderIOResult[R, A]

func LeftReader 

func LeftReader[A, R any](ma Reader[R, error]) ReaderReaderIOResult[R, A]

func LeftReaderIO 

func LeftReaderIO[A, R any](me ReaderIO[R, error]) ReaderReaderIOResult[R, A]

func MonadAlt 

func MonadAlt[R, A any](first ReaderReaderIOResult[R, A], second Lazy[ReaderReaderIOResult[R, A]]) ReaderReaderIOResult[R, A]

func MonadAp 

func MonadAp[R, A, B any](fab ReaderReaderIOResult[R, func(A) B], fa ReaderReaderIOResult[R, A]) ReaderReaderIOResult[R, B]

func MonadApPar 

func MonadApPar[R, A, B any](fab ReaderReaderIOResult[R, func(A) B], fa ReaderReaderIOResult[R, A]) ReaderReaderIOResult[R, B]

func MonadApSeq 

func MonadApSeq[R, A, B any](fab ReaderReaderIOResult[R, func(A) B], fa ReaderReaderIOResult[R, A]) ReaderReaderIOResult[R, B]

func MonadChain 

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

func MonadChainEitherK 

func MonadChainEitherK[R, A, B any](ma ReaderReaderIOResult[R, A], f either.Kleisli[error, A, B]) ReaderReaderIOResult[R, B]

func MonadChainFirst 

func MonadChainFirst[R, A, B any](fa ReaderReaderIOResult[R, A], f Kleisli[R, A, B]) ReaderReaderIOResult[R, A]

func MonadChainFirstEitherK 

func MonadChainFirstEitherK[R, A, B any](ma ReaderReaderIOResult[R, A], f either.Kleisli[error, A, B]) ReaderReaderIOResult[R, A]

func MonadChainFirstIOK 

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

func MonadChainFirstReaderEitherK 

func MonadChainFirstReaderEitherK[R, A, B any](ma ReaderReaderIOResult[R, A], f RE.Kleisli[R, error, A, B]) ReaderReaderIOResult[R, A]

func MonadChainFirstReaderIOK 

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

func MonadChainFirstReaderK 

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

func MonadChainIOEitherK 

func MonadChainIOEitherK[R, A, B any](ma ReaderReaderIOResult[R, A], f IOE.Kleisli[error, A, B]) ReaderReaderIOResult[R, B]

func MonadChainIOK 

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

func MonadChainLeft 

func MonadChainLeft[R, A any](fa ReaderReaderIOResult[R, A], f Kleisli[R, error, A]) ReaderReaderIOResult[R, A]

func MonadChainReaderEitherK 

func MonadChainReaderEitherK[R, A, B any](ma ReaderReaderIOResult[R, A], f RE.Kleisli[R, error, A, B]) ReaderReaderIOResult[R, B]

func MonadChainReaderIOK 

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

func MonadChainReaderK 

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

func MonadFlap 

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

func MonadMap 

func MonadMap[R, A, B any](fa ReaderReaderIOResult[R, A], f func(A) B) ReaderReaderIOResult[R, B]

func MonadMapLeft 

func MonadMapLeft[R, A any](fa ReaderReaderIOResult[R, A], f Endmorphism[error]) ReaderReaderIOResult[R, A]

func MonadMapTo 

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

func MonadTap 

func MonadTap[R, A, B any](fa ReaderReaderIOResult[R, A], f Kleisli[R, A, B]) ReaderReaderIOResult[R, A]

func MonadTapEitherK 

func MonadTapEitherK[R, A, B any](ma ReaderReaderIOResult[R, A], f either.Kleisli[error, A, B]) ReaderReaderIOResult[R, A]

func MonadTapIOK 

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

func MonadTapReaderEitherK 

func MonadTapReaderEitherK[R, A, B any](ma ReaderReaderIOResult[R, A], f RE.Kleisli[R, error, A, B]) ReaderReaderIOResult[R, A]

func MonadTapReaderIOK 

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

func MonadTapReaderK 

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

func Of 

func Of[R, A any](a A) ReaderReaderIOResult[R, A]

func Retrying 

func Retrying[R, A any](
	policy retry.RetryPolicy,
	action Kleisli[R, retry.RetryStatus, A],
	check Predicate[Result[A]],
) ReaderReaderIOResult[R, A]
func Right[R, A any](a A) ReaderReaderIOResult[R, A]

func RightIO 

func RightIO[R, A any](ma IO[A]) ReaderReaderIOResult[R, A]

func RightReader 

func RightReader[R, A any](ma Reader[R, A]) ReaderReaderIOResult[R, A]

func RightReaderIO 

func RightReaderIO[R, A any](ma ReaderIO[R, A]) ReaderReaderIOResult[R, A]

type Result 

type Result[A any] = result.Result[A]

type Trampoline 

type Trampoline[L, B any] = tailrec.Trampoline[L, B]

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.