reader

func Compose ¶

func Compose[C, R, B any](ab Reader[R, B]) Kleisli[R, Reader[B, C], C]

Compose composes two Readers sequentially, where the output environment of the first becomes the input environment of the second.

Example:

type Config struct { Port int }
type Env struct { Config Config }
getConfig := func(e Env) Config { return e.Config }
getPort := func(c Config) int { return c.Port }
getPortFromEnv := reader.Compose(getConfig)(getPort)

func Curry1 ¶

func Curry1[R, T1, A any](f func(R, T1) A) Kleisli[R, T1, A]

Curry1 converts a function with context as first parameter into a curried function returning a Reader. The context parameter is moved to the end (Reader position).

Example:

type Config struct { Prefix string }
addPrefix := func(c Config, s string) string { return c.Prefix + s }
curried := reader.Curry1(addPrefix)
r := curried("hello")
result := r(Config{Prefix: ">> "}) // ">> hello"

func Local ¶

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

Local changes the value of the local context during the execution of the action `ma`. This is similar to Contravariant's contramap and allows you to modify the environment before passing it to a Reader.

Example:

type DetailedConfig struct { Host string; Port int }
type SimpleConfig struct { Host string }
getHost := func(c SimpleConfig) string { return c.Host }
simplify := func(d DetailedConfig) SimpleConfig { return SimpleConfig{Host: d.Host} }
r := reader.Local(simplify)(getHost)
result := r(DetailedConfig{Host: "localhost", Port: 8080}) // "localhost"

func Promap ¶

func Promap[E, A, D, B any](f func(D) E, g func(A) B) Kleisli[D, Reader[E, A], B]

Promap is the profunctor map operation that transforms both the input and output of a Reader. It applies f to the input (contravariantly) and g to the output (covariantly).

Example:

type Config struct { Port int }
type Env struct { Config Config }
getPort := func(c Config) int { return c.Port }
extractConfig := func(e Env) Config { return e.Config }
toString := strconv.Itoa
r := reader.Promap(extractConfig, toString)(getPort)
result := r(Env{Config: Config{Port: 8080}}) // "8080"

func ReduceArray ¶

func ReduceArray[R, A, B any](reduce func(B, A) B, initial B) Kleisli[R, []Reader[R, A], B]

ReduceArray returns a curried function that reduces an array of Readers to a single Reader. This is the curried version where the reduction function and initial value are provided first, returning a function that takes the array of Readers.

Parameters:

• reduce: Binary function that combines accumulated value with each Reader's result
• initial: Starting value for the reduction

Returns:

• A function that takes an array of Readers and returns a Reader of the reduced result

Example:

type Config struct { Multiplier int }
product := func(acc, val int) int { return acc * val }
reducer := reader.ReduceArray[Config](product, 1)
readers := []reader.Reader[Config, int]{
    reader.Asks(func(c Config) int { return c.Multiplier * 2 }),
    reader.Asks(func(c Config) int { return c.Multiplier * 3 }),
}
r := reducer(readers)
result := r(Config{Multiplier: 5}) // 150 (10 * 15)

func ReduceArrayM ¶

func ReduceArrayM[R, A any](m monoid.Monoid[A]) Kleisli[R, []Reader[R, A], A]

ReduceArrayM returns a curried function that reduces an array of Readers using a Monoid. This is the curried version where the Monoid is provided first, returning a function that takes the array of Readers.

The Monoid provides both the binary operation (Concat) and the identity element (Empty) for the reduction.

Parameters:

• m: Monoid that defines how to combine the Reader results

Returns:

• A function that takes an array of Readers and returns a Reader of the reduced result

Example:

type Config struct { Scale int }
intMultMonoid := monoid.MakeMonoid(func(a, b int) int { return a * b }, 1)
reducer := reader.ReduceArrayM[Config](intMultMonoid)
readers := []reader.Reader[Config, int]{
    reader.Asks(func(c Config) int { return c.Scale }),
    reader.Asks(func(c Config) int { return c.Scale * 2 }),
}
r := reducer(readers)
result := r(Config{Scale: 3}) // 18 (3 * 6)

func Sequence ¶

func Sequence[R1, R2, A any](ma Reader[R2, Reader[R1, A]]) Kleisli[R2, R1, A]

Sequence swaps the order of the two environment parameters in a Kleisli arrow. It transforms a function that takes A and returns Reader[R2, B] into a function that takes R2 and returns Reader[R1, A].

This is useful when you need to change the order of dependencies or when composing functions that expect their parameters in a different order.

Type Parameters:

• R1: The first environment type (becomes second after flip)
• R2: The second environment type (becomes first after flip)
• A: The result type

Parameters:

• ma: A Kleisli arrow from R2 to Reader[R1, A]

Returns:

• A Kleisli arrow from R1 to Reader[R2, A] with swapped environment parameters

Example:

type Config struct { Host string }
type Port int

// Original: takes Port, returns Reader[Config, string]
makeURL := func(port Port) reader.Reader[Config, string] {
    return func(c Config) string {
        return fmt.Sprintf("%s:%d", c.Host, port)
    }
}

// Sequenced: takes Config, returns Reader[Port, string]
sequenced := reader.Sequence(makeURL)
result := sequenced(Config{Host: "localhost"})(Port(8080))
// result: "localhost:8080"

The Sequence operation is particularly useful when:

• You need to partially apply environments in a different order
• You're composing functions that expect parameters in reverse order
• You want to curry multi-parameter functions differently

func TraverseArray ¶

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

TraverseArray transforms each element of an array using a function that returns a Reader, then collects the results into a single Reader containing an array.

This is useful for performing a Reader computation on each element of an array where all computations share the same environment.

Example:

type Config struct { Multiplier int }
multiply := func(n int) reader.Reader[Config, int] {
    return reader.Asks(func(c Config) int { return n * c.Multiplier })
}
transform := reader.TraverseArray(multiply)
r := transform([]int{1, 2, 3})
result := r(Config{Multiplier: 10}) // [10, 20, 30]

func TraverseArrayWithIndex ¶

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

TraverseArrayWithIndex transforms each element of an array using a function that takes both the index and the element, returning a Reader. The results are collected into a single Reader containing an array.

This is useful when the transformation needs to know the position of each element.

Example:

type Config struct { Prefix string }
addIndexPrefix := func(i int, s string) reader.Reader[Config, string] {
    return reader.Asks(func(c Config) string {
        return fmt.Sprintf("%s[%d]:%s", c.Prefix, i, s)
    })
}
transform := reader.TraverseArrayWithIndex(addIndexPrefix)
r := transform([]string{"a", "b", "c"})
result := r(Config{Prefix: "item"}) // ["item[0]:a", "item[1]:b", "item[2]:c"]

func TraverseReduceArray ¶

func TraverseReduceArray[R, A, B, C any](trfrm Kleisli[R, A, B], reduce func(C, B) C, initial C) Kleisli[R, []A, C]

TraverseReduceArray returns a curried function that transforms and reduces an array. This is the curried version where the transformation function, reduce function, and initial value are provided first, returning a function that takes the array.

First, each element is transformed using the provided Kleisli function into a Reader. Then, the Reader results are reduced using the provided reduction function.

Parameters:

• trfrm: Function that transforms each element into a Reader
• reduce: Binary function that combines accumulated value with each transformed result
• initial: Starting value for the reduction

Returns:

• A function that takes an array and returns a Reader of the reduced result

Example:

type Config struct { Base int }
addBase := func(n int) reader.Reader[Config, int] {
    return reader.Asks(func(c Config) int { return n + c.Base })
}
product := func(acc, val int) int { return acc * val }
transformer := reader.TraverseReduceArray(addBase, product, 1)
r := transformer([]int{2, 3, 4})
result := r(Config{Base: 10}) // 2184 (12 * 13 * 14)

func TraverseReduceArrayM ¶

func TraverseReduceArrayM[R, A, B any](trfrm Kleisli[R, A, B], m monoid.Monoid[B]) Kleisli[R, []A, B]

TraverseReduceArrayM returns a curried function that transforms and reduces an array using a Monoid. This is the curried version where the transformation function and Monoid are provided first, returning a function that takes the array.

First, each element is transformed using the provided Kleisli function into a Reader. Then, the Reader results are reduced using the Monoid's binary operation and identity element.

Parameters:

• trfrm: Function that transforms each element into a Reader
• m: Monoid that defines how to combine the transformed results

Returns:

• A function that takes an array and returns a Reader of the reduced result

Example:

type Config struct { Factor int }
scale := func(n int) reader.Reader[Config, int] {
    return reader.Asks(func(c Config) int { return n * c.Factor })
}
intProdMonoid := monoid.MakeMonoid(func(a, b int) int { return a * b }, 1)
transformer := reader.TraverseReduceArrayM(scale, intProdMonoid)
r := transformer([]int{2, 3, 4})
result := r(Config{Factor: 5}) // 3000 (10 * 15 * 20)

func Ap ¶

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

Ap applies a Reader containing a function to a Reader containing a value. This is the Applicative operation for combining independent computations.

Example:

type Config struct { X, Y int }
add := func(x int) func(int) int { return func(y int) int { return x + y } }
getX := reader.Map(add)(reader.Asks(func(c Config) int { return c.X }))
getY := reader.Asks(func(c Config) int { return c.Y })
getSum := reader.Ap(getY)(getX)
sum := getSum(Config{X: 3, Y: 4}) // 7

func ApS ¶

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

ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently (using Applicative rather than Monad).

This is useful when you have independent computations that can be combined without one depending on the result of the other.

Example:

type State struct {
    Host string
    Port int
}
type Config struct {
    Host string
    Port int
}

getPort := reader.Asks(func(c Config) int { return c.Port })
addPort := reader.ApS(
    func(port int) func(State) State {
        return func(s State) State { s.Port = port; return s }
    },
    getPort,
)

func ApSL ¶

func ApSL[R, S, T any](
	lens L.Lens[S, T],
	fa Reader[R, T],
) Operator[R, S, S]

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

The lens parameter provides both the getter and setter for a field within the structure S. This eliminates the need to manually write setter functions.

Example:

type State struct {
    Host string
    Port int
}
type Config struct {
    DefaultHost string
    DefaultPort int
}

portLens := lens.MakeLens(
    func(s State) int { return s.Port },
    func(s State, p int) State { s.Port = p; return s },
)

getPort := reader.Asks(func(c Config) int { return c.DefaultPort })
result := F.Pipe2(
    reader.Of[Config](State{Host: "localhost"}),
    reader.ApSL(portLens, getPort),
)

func Bind ¶

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

Bind attaches the result of a computation to a context [S1] to produce a context [S2]. This enables building up complex computations in a pipeline where each step can depend on the results of previous steps and access the shared environment.

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 { Value int }
type Config struct { Increment int }

addIncrement := reader.Bind(
    func(inc int) func(State) State {
        return func(s State) State { return State{Value: s.Value + inc} }
    },
    func(s State) reader.Reader[Config, int] {
        return reader.Asks(func(c Config) int { return c.Increment })
    },
)

func BindL ¶

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

BindL is a variant of Bind that uses a lens to focus on a specific part of the context. This provides a more ergonomic API when working with nested structures, eliminating the need to manually write setter functions.

The lens parameter provides both a getter and setter for a field of type T within the context S. The function f receives the current value of the focused field and returns a Reader computation that produces an updated value.

Example:

type State struct {
    Config ConfigData
    Status string
}
type ConfigData struct {
    Host string
    Port int
}
type Env struct {
    DefaultHost string
    DefaultPort int
}

configLens := lens.MakeLens(
    func(s State) ConfigData { return s.Config },
    func(s State, c ConfigData) State { s.Config = c; return s },
)

result := F.Pipe2(
    reader.Do[Env](State{}),
    reader.BindL(configLens, func(cfg ConfigData) reader.Reader[Env, ConfigData] {
        return reader.Asks(func(e Env) ConfigData {
            return ConfigData{Host: e.DefaultHost, Port: e.DefaultPort}
        })
    }),
)

func BindTo ¶

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

BindTo initializes a new state [S1] from a value [T]. This is typically used to start a binding chain by wrapping an initial Reader value into a state structure.

Example:

type State struct { Name string }
type Config struct { DefaultName string }

getName := reader.Asks(func(c Config) string { return c.DefaultName })
initState := reader.BindTo(func(name string) State {
    return State{Name: name}
})
result := initState(getName)

func Chain ¶

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

Chain sequences two Reader computations where the second depends on the result of the first. This is the Monad operation that enables dependent computations.

Example:

type Config struct { UserId int }
getUser := reader.Asks(func(c Config) int { return c.UserId })
getUserName := func(id int) reader.Reader[Config, string] {
    return reader.Of[Config](fmt.Sprintf("User%d", id))
}
r := reader.Chain(getUserName)(getUser)
name := r(Config{UserId: 42}) // "User42"

func ChainTo ¶

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

ChainTo creates an operator that completely ignores any Reader and returns a specific Reader. This is the curried version where the second Reader is provided first, returning a function that can be applied to any first Reader (which will be ignored).

IMPORTANT: Readers are pure functions with no side effects. This operator does NOT compose or evaluate the input Reader - it completely ignores it and returns the specified Reader directly. The input Reader is neither executed during composition nor when the resulting Reader runs.

Type Parameters:

• A: The result type of the first Reader (completely ignored)
• R: The environment type
• B: The result type of the second Reader

Parameters:

• b: The Reader to return (ignoring any input Reader)

Returns:

• An Operator that takes a Reader[R, A] and returns Reader[R, B]

Example:

type Config struct { Counter int; Message string }
getMessage := func(c Config) string { return c.Message }
// Create an operator that ignores any Reader and returns getMessage
thenGetMessage := reader.ChainTo[int, Config, string](getMessage)

increment := func(c Config) int { return c.Counter + 1 }
pipeline := thenGetMessage(increment)
result := pipeline(Config{Counter: 5, Message: "done"}) // "done" (increment was never evaluated)

Example - In a functional pipeline:

type Env struct { Step int; Result string }
step1 := reader.Asks(func(e Env) int { return e.Step })
getResult := reader.Asks(func(e Env) string { return e.Result })

pipeline := F.Pipe1(
    step1,
    reader.ChainTo[int, Env, string](getResult),
)
output := pipeline(Env{Step: 1, Result: "success"}) // "success" (step1 was never evaluated)

func Flap ¶

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

Flap takes a value and returns a function that applies a Reader containing a function to that value. This is useful for partial application in the Reader context.

Example:

type Config struct { Multiplier int }
getMultiplier := reader.Asks(func(c Config) func(int) int {
    return N.Mul(c.Multiplier)
})
applyTo5 := reader.Flap[Config](5)
r := applyTo5(getMultiplier)
result := r(Config{Multiplier: 3}) // 15

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 the result of a pure computation to a context [S1] to produce a context [S2]. Unlike Bind, the computation function f does not return a Reader, just a plain value. This is useful for transformations that don't need to access the environment.

Example:

type State struct {
    FirstName string
    LastName  string
    FullName  string
}

addFullName := reader.Let(
    func(full string) func(State) State {
        return func(s State) State { s.FullName = full; return s }
    },
    func(s State) string {
        return s.FirstName + " " + s.LastName
    },
)

func LetL ¶

func LetL[R, S, T any](
	lens L.Lens[S, T],
	f func(T) T,
) Operator[R, S, S]

LetL is a variant of Let that uses a lens to focus on a specific part of the context. This provides a more ergonomic API when working with nested structures, eliminating the need to manually write setter functions.

The lens parameter provides both a getter and setter for a field of type T within the context S. The function f receives the current value of the focused field and returns a new value (without wrapping in a Reader).

Example:

type State struct {
    Config ConfigData
    Status string
}
type ConfigData struct {
    Host string
    Port int
}

configLens := lens.MakeLens(
    func(s State) ConfigData { return s.Config },
    func(s State, c ConfigData) State { s.Config = c; return s },
)

result := F.Pipe2(
    reader.Do[any](State{Config: ConfigData{Host: "localhost"}}),
    reader.LetL(configLens, func(cfg ConfigData) ConfigData {
        cfg.Port = 8080
        return cfg
    }),
)

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]. This is useful for adding fixed values to the context without any computation.

Example:

type State struct {
    Name    string
    Version string
}

addVersion := reader.LetTo(
    func(v string) func(State) State {
        return func(s State) State { s.Version = v; return s }
    },
    "1.0.0",
)

func LetToL ¶

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

LetToL is a variant of LetTo that uses a lens to focus on a specific part of the context. This provides a more ergonomic API when working with nested structures, eliminating the need to manually write setter functions.

The lens parameter provides both a getter and setter for a field of type T within the context S. The value b is set directly to the focused field.

Example:

type State struct {
    Config ConfigData
    Status string
}
type ConfigData struct {
    Host string
    Port int
}

configLens := lens.MakeLens(
    func(s State) ConfigData { return s.Config },
    func(s State, c ConfigData) State { s.Config = c; return s },
)

newConfig := ConfigData{Host: "localhost", Port: 8080}
result := F.Pipe2(
    reader.Do[any](State{}),
    reader.LetToL(configLens, newConfig),
)

func Map ¶

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

Map transforms the result value of a Reader using the provided function. This is the Functor operation that allows you to transform values inside the Reader context.

Map can be used to turn functions `func(A)B` into functions `(fa F[A])F[B]` whose argument and return types use the type constructor `F` to represent some computational context.

Example:

type Config struct { Port int }
getPort := reader.Asks(func(c Config) int { return c.Port })
getPortStr := reader.Map(strconv.Itoa)(getPort)
result := getPortStr(Config{Port: 8080}) // "8080"

func MapTo ¶

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

MapTo creates an operator that completely ignores any Reader and returns a constant value. This is the curried version where the constant value is provided first, returning a function that can be applied to any Reader.

IMPORTANT: Readers are pure functions with no side effects. This operator does NOT compose or evaluate the input Reader - it completely ignores it and returns a new Reader that always returns the constant value. The input Reader is neither executed during composition nor when the resulting Reader runs.

Type Parameters:

• E: The environment type
• A: The result type of the input Reader (completely ignored)
• B: The type of the constant value to return

Parameters:

• b: The constant value to return

Returns:

• An Operator that takes a Reader[E, A] and returns Reader[E, B]

Example:

type Config struct { Counter int }
increment := reader.Asks(func(c Config) int { return c.Counter + 1 })
// Create an operator that ignores any Reader and returns "done"
toDone := reader.MapTo[Config, int, string]("done")
pipeline := toDone(increment)
result := pipeline(Config{Counter: 5}) // "done" (increment was never evaluated)

Example - In a functional pipeline:

type Env struct { Step int }
step1 := reader.Asks(func(e Env) int { return e.Step })
pipeline := F.Pipe1(
    step1,
    reader.MapTo[Env, int, string]("complete"),
)
output := pipeline(Env{Step: 1}) // "complete" (step1 was never evaluated)

func Ask ¶

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

Ask reads the current context and returns it as the result. This is the fundamental operation for accessing the environment.

Example:

type Config struct { Host string }
r := reader.Ask[Config]()
config := r(Config{Host: "localhost"}) // Returns the config itself

func Asks ¶

func Asks[R, A any](f Reader[R, A]) Reader[R, A]

Asks projects a value from the global context in a Reader. It's essentially an identity function that makes the intent clearer.

Example:

type Config struct { Port int }
getPort := reader.Asks(func(c Config) int { return c.Port })
port := getPort(Config{Port: 8080}) // Returns 8080

func AsksReader ¶

func AsksReader[R, A any](f Kleisli[R, R, A]) Reader[R, A]

AsksReader creates a Reader that depends on the environment to produce another Reader, then immediately executes that Reader with the same environment.

This is useful when you need to dynamically choose a Reader based on the environment.

Example:

type Config struct { UseCache bool }
r := reader.AsksReader(func(c Config) reader.Reader[Config, string] {
    if c.UseCache {
        return reader.Of[Config]("cached")
    }
    return reader.Of[Config]("fresh")
})

func Bracket ¶

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

	acquire Reader[R, A],
	use Kleisli[R, A, B],
	release func(A, B) Reader[R, ANY],
) Reader[R, B]

func Curry0 ¶

func Curry0[R, A any](f func(R) A) Reader[R, A]

Curry0 converts a function that takes a context and returns a value into a Reader.

Example:

type Config struct { Value int }
getValue := func(c Config) int { return c.Value }
r := reader.Curry0(getValue)
result := r(Config{Value: 42}) // 42

func Do ¶

func Do[R, S any](
	empty S,
) Reader[R, S]

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

Example:

type State struct {
    Name string
    Age  int
}
type Config struct {
    DefaultName string
    DefaultAge  int
}

result := function.Pipe3(
    reader.Do[Config](State{}),
    reader.Bind(
        func(name string) func(State) State {
            return func(s State) State { s.Name = name; return s }
        },
        func(s State) reader.Reader[Config, string] {
            return reader.Asks(func(c Config) string { return c.DefaultName })
        },
    ),
    reader.Bind(
        func(age int) func(State) State {
            return func(s State) State { s.Age = age; return s }
        },
        func(s State) reader.Reader[Config, int] {
            return reader.Asks(func(c Config) int { return c.DefaultAge })
        },
    ),
)

func First ¶

func First[A, B, C any](pab Reader[A, B]) Reader[T.Tuple2[A, C], T.Tuple2[B, C]]

First applies a Reader to the first element of a tuple, leaving the second element unchanged. This is useful for working with paired data where only one element needs transformation.

Example:

double := N.Mul(2)
r := reader.First[int, int, string](double)
result := r(tuple.MakeTuple2(5, "hello")) // (10, "hello")

func Flatten ¶

func Flatten[R, A any](mma Reader[R, Reader[R, A]]) Reader[R, A]

Flatten removes one level of Reader nesting. Converts Reader[R, Reader[R, A]] to Reader[R, A].

Example:

type Config struct { Value int }
nested := func(c Config) reader.Reader[Config, int] {
    return func(c2 Config) int { return c.Value + c2.Value }
}
flat := reader.Flatten(nested)
result := flat(Config{Value: 5}) // 10 (5 + 5)

func MonadAp ¶

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

MonadAp applies a Reader containing a function to a Reader containing a value. Both Readers share the same environment and are evaluated with it. This is the monadic version that takes both parameters.

Example:

type Config struct { X, Y int }
add := func(x int) func(int) int { return func(y int) int { return x + y } }
getX := func(c Config) func(int) int { return add(c.X) }
getY := func(c Config) int { return c.Y }
result := reader.MonadAp(getX, getY)
sum := result(Config{X: 3, Y: 4}) // 7

func MonadChain ¶

func MonadChain[R, A, B any](ma Reader[R, A], f Kleisli[R, A, B]) Reader[R, B]

MonadChain sequences two Reader computations where the second depends on the result of the first. Both computations share the same environment. This is the monadic bind operation (flatMap).

Example:

type Config struct { UserId int }
getUser := func(c Config) int { return c.UserId }
getUserName := func(id int) reader.Reader[Config, string] {
    return func(c Config) string { return fmt.Sprintf("User%d", id) }
}
r := reader.MonadChain(getUser, getUserName)
name := r(Config{UserId: 42}) // "User42"

func MonadChainTo ¶

func MonadChainTo[A, R, B any](_ Reader[R, A], b Reader[R, B]) Reader[R, B]

MonadChainTo completely ignores the first Reader and returns the second Reader. This is the monadic version that takes both Readers as parameters.

IMPORTANT: Readers are pure functions with no side effects. This function does NOT compose or evaluate the first Reader - it completely ignores it and returns the second Reader directly. The first Reader is neither executed during composition nor when the resulting Reader runs.

Type Parameters:

• A: The result type of the first Reader (completely ignored)
• R: The environment type
• B: The result type of the second Reader

Parameters:

• _: The first Reader (completely ignored, never evaluated)
• b: The second Reader to return

Returns:

• The second Reader unchanged

Example:

type Config struct { Counter int; Message string }
increment := func(c Config) int { return c.Counter + 1 }
getMessage := func(c Config) string { return c.Message }
// Ignore increment and return getMessage
r := reader.MonadChainTo(increment, getMessage)
result := r(Config{Counter: 5, Message: "done"}) // "done" (increment was never evaluated)

func MonadFlap ¶

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

MonadFlap is the monadic version of Flap. It takes a Reader containing a function and a value, and returns a Reader that applies the function to the value.

Example:

type Config struct { Multiplier int }
getMultiplier := func(c Config) func(int) int {
    return N.Mul(c.Multiplier)
}
r := reader.MonadFlap(getMultiplier, 5)
result := r(Config{Multiplier: 3}) // 15

func MonadMap ¶

func MonadMap[E, A, B any](fa Reader[E, A], f func(A) B) Reader[E, B]

MonadMap transforms the result value of a Reader using the provided function. This is the monadic version that takes the Reader as the first parameter.

Example:

type Config struct { Port int }
getPort := func(c Config) int { return c.Port }
getPortStr := reader.MonadMap(getPort, strconv.Itoa)
result := getPortStr(Config{Port: 8080}) // "8080"

func MonadMapTo ¶

func MonadMapTo[E, A, B any](_ Reader[E, A], b B) Reader[E, B]

MonadMapTo creates a new Reader that completely ignores the first Reader and returns a constant value. This is the monadic version that takes both the Reader and the constant value as parameters.

IMPORTANT: Readers are pure functions with no side effects. This function does NOT compose or evaluate the first Reader - it completely ignores it and returns a new Reader that always returns the constant value. The first Reader is neither executed during composition nor when the resulting Reader runs.

Type Parameters:

• E: The environment type
• A: The result type of the first Reader (completely ignored)
• B: The type of the constant value to return

Parameters:

• _: The first Reader (completely ignored, never evaluated)
• b: The constant value to return

Returns:

• A new Reader that ignores the environment and always returns b

Example:

type Config struct { Counter int }
increment := func(c Config) int { return c.Counter + 1 }
// Create a Reader that ignores increment and returns "done"
r := reader.MonadMapTo(increment, "done")
result := r(Config{Counter: 5}) // "done" (increment was never evaluated)

func MonadReduceArray ¶

func MonadReduceArray[R, A, B any](as []Reader[R, A], reduce func(B, A) B, initial B) Reader[R, B]

MonadReduceArray reduces an array of Readers to a single Reader by applying a reduction function. This is the monadic version that takes the array of Readers as the first parameter.

Each Reader is evaluated with the same environment R, and the results are accumulated using the provided reduce function starting from the initial value.

Parameters:

• as: Array of Readers to reduce
• reduce: Binary function that combines accumulated value with each Reader's result
• initial: Starting value for the reduction

Example:

type Config struct { Base int }
readers := []reader.Reader[Config, int]{
    reader.Asks(func(c Config) int { return c.Base + 1 }),
    reader.Asks(func(c Config) int { return c.Base + 2 }),
    reader.Asks(func(c Config) int { return c.Base + 3 }),
}
sum := func(acc, val int) int { return acc + val }
r := reader.MonadReduceArray(readers, sum, 0)
result := r(Config{Base: 10}) // 36 (11 + 12 + 13)

func MonadReduceArrayM ¶

func MonadReduceArrayM[R, A any](as []Reader[R, A], m monoid.Monoid[A]) Reader[R, A]

MonadReduceArrayM reduces an array of Readers using a Monoid to combine the results. This is the monadic version that takes the array of Readers as the first parameter.

The Monoid provides both the binary operation (Concat) and the identity element (Empty) for the reduction, making it convenient when working with monoidal types.

Parameters:

• as: Array of Readers to reduce
• m: Monoid that defines how to combine the Reader results

Example:

type Config struct { Factor int }
readers := []reader.Reader[Config, int]{
    reader.Asks(func(c Config) int { return c.Factor }),
    reader.Asks(func(c Config) int { return c.Factor * 2 }),
    reader.Asks(func(c Config) int { return c.Factor * 3 }),
}
intAddMonoid := monoid.MakeMonoid(func(a, b int) int { return a + b }, 0)
r := reader.MonadReduceArrayM(readers, intAddMonoid)
result := r(Config{Factor: 5}) // 30 (5 + 10 + 15)

func MonadTraverseArray ¶

func MonadTraverseArray[R, A, B any](ma []A, f Kleisli[R, A, B]) Reader[R, []B]

MonadTraverseArray transforms each element of an array using a function that returns a Reader, then collects the results into a single Reader containing an array. This is the monadic version that takes the array as the first parameter.

All Readers share the same environment R and are evaluated with it.

Example:

type Config struct { Prefix string }
numbers := []int{1, 2, 3}
addPrefix := func(n int) reader.Reader[Config, string] {
    return reader.Asks(func(c Config) string {
        return fmt.Sprintf("%s%d", c.Prefix, n)
    })
}
r := reader.MonadTraverseArray(numbers, addPrefix)
result := r(Config{Prefix: "num"}) // ["num1", "num2", "num3"]

func MonadTraverseRecord ¶

func MonadTraverseRecord[K comparable, R, A, B any](ma map[K]A, f Kleisli[R, A, B]) Reader[R, map[K]B]

func MonadTraverseRecordWithIndex ¶

func MonadTraverseRecordWithIndex[K comparable, R, A, B any](ma map[K]A, f func(K, A) Reader[R, B]) Reader[R, map[K]B]

func MonadTraverseReduceArray ¶

func MonadTraverseReduceArray[R, A, B, C any](as []A, trfrm Kleisli[R, A, B], reduce func(C, B) C, initial C) Reader[R, C]

MonadTraverseReduceArray transforms and reduces an array in one operation. This is the monadic version that takes the array as the first parameter.

First, each element is transformed using the provided Kleisli function into a Reader. Then, the Reader results are reduced using the provided reduction function.

This is more efficient than calling TraverseArray followed by a separate reduce operation, as it combines both operations into a single traversal.

Parameters:

• as: Array of elements to transform and reduce
• trfrm: Function that transforms each element into a Reader
• reduce: Binary function that combines accumulated value with each transformed result
• initial: Starting value for the reduction

Example:

type Config struct { Multiplier int }
numbers := []int{1, 2, 3, 4}
multiply := func(n int) reader.Reader[Config, int] {
    return reader.Asks(func(c Config) int { return n * c.Multiplier })
}
sum := func(acc, val int) int { return acc + val }
r := reader.MonadTraverseReduceArray(numbers, multiply, sum, 0)
result := r(Config{Multiplier: 10}) // 100 (10 + 20 + 30 + 40)

func MonadTraverseReduceArrayM ¶

func MonadTraverseReduceArrayM[R, A, B any](as []A, trfrm Kleisli[R, A, B], m monoid.Monoid[B]) Reader[R, B]

MonadTraverseReduceArrayM transforms and reduces an array using a Monoid. This is the monadic version that takes the array as the first parameter.

First, each element is transformed using the provided Kleisli function into a Reader. Then, the Reader results are reduced using the Monoid's binary operation and identity element.

This combines transformation and monoidal reduction in a single efficient operation.

Parameters:

• as: Array of elements to transform and reduce
• trfrm: Function that transforms each element into a Reader
• m: Monoid that defines how to combine the transformed results

Example:

type Config struct { Offset int }
numbers := []int{1, 2, 3}
addOffset := func(n int) reader.Reader[Config, int] {
    return reader.Asks(func(c Config) int { return n + c.Offset })
}
intSumMonoid := monoid.MakeMonoid(func(a, b int) int { return a + b }, 0)
r := reader.MonadTraverseReduceArrayM(numbers, addOffset, intSumMonoid)
result := r(Config{Offset: 100}) // 306 (101 + 102 + 103)

func Of ¶

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

Of lifts a pure value into the Reader context. The resulting Reader ignores its environment and always returns the given value. This is the Pointed/Applicative pure operation.

Example:

type Config struct { Host string }
r := reader.Of[Config]("constant value")
result := r(Config{Host: "any"}) // "constant value"

func Second ¶

func Second[A, B, C any](pbc Reader[B, C]) Reader[T.Tuple2[A, B], T.Tuple2[A, C]]

Second applies a Reader to the second element of a tuple, leaving the first element unchanged. This is useful for working with paired data where only one element needs transformation.

Example:

double := N.Mul(2)
r := reader.Second[string, int, int](double)
result := r(tuple.MakeTuple2("hello", 5)) // ("hello", 10)

func SequenceArray ¶

func SequenceArray[R, A any](ma []Reader[R, A]) Reader[R, []A]

SequenceArray converts an array of Readers into a single Reader containing an array. All Readers in the input array share the same environment and are evaluated with it.

This is useful when you have multiple independent Reader computations and want to collect all their results.

Example:

type Config struct { X, Y, Z int }
readers := []reader.Reader[Config, int]{
    reader.Asks(func(c Config) int { return c.X }),
    reader.Asks(func(c Config) int { return c.Y }),
    reader.Asks(func(c Config) int { return c.Z }),
}
r := reader.SequenceArray(readers)
result := r(Config{X: 1, Y: 2, Z: 3}) // [1, 2, 3]

func SequenceRecord ¶

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

func SequenceT1 ¶

func SequenceT1[R, A any](a Reader[R, A]) Reader[R, T.Tuple1[A]]

SequenceT1 combines 1 Reader into a Reader of a 1-tuple.

Example:

type Config struct { Value int }
r := reader.Asks(func(c Config) int { return c.Value })
result := reader.SequenceT1(r)
tuple := result(Config{Value: 42}) // Tuple1{F1: 42}

func SequenceT2 ¶

func SequenceT2[R, A, B any](a Reader[R, A], b Reader[R, B]) Reader[R, T.Tuple2[A, B]]

SequenceT2 combines 2 Readers into a Reader of a 2-tuple. All Readers share the same environment and are evaluated with it.

Example:

type Config struct { X, Y int }
getX := reader.Asks(func(c Config) int { return c.X })
getY := reader.Asks(func(c Config) int { return c.Y })
result := reader.SequenceT2(getX, getY)
tuple := result(Config{X: 10, Y: 20}) // Tuple2{F1: 10, F2: 20}

func SequenceT3 ¶

func SequenceT3[R, A, B, C any](a Reader[R, A], b Reader[R, B], c Reader[R, C]) Reader[R, T.Tuple3[A, B, C]]

SequenceT3 combines 3 Readers into a Reader of a 3-tuple. All Readers share the same environment and are evaluated with it.

Example:

type Config struct { Host string; Port int; Secure bool }
getHost := reader.Asks(func(c Config) string { return c.Host })
getPort := reader.Asks(func(c Config) int { return c.Port })
getSecure := reader.Asks(func(c Config) bool { return c.Secure })
result := reader.SequenceT3(getHost, getPort, getSecure)
tuple := result(Config{Host: "localhost", Port: 8080, Secure: true})
// Tuple3{F1: "localhost", F2: 8080, F3: true}

func SequenceT4 ¶

func SequenceT4[R, A, B, C, D any](a Reader[R, A], b Reader[R, B], c Reader[R, C], d Reader[R, D]) Reader[R, T.Tuple4[A, B, C, D]]

SequenceT4 combines 4 Readers into a Reader of a 4-tuple. All Readers share the same environment and are evaluated with it.

Example:

type Config struct { A, B, C, D int }
getA := reader.Asks(func(c Config) int { return c.A })
getB := reader.Asks(func(c Config) int { return c.B })
getC := reader.Asks(func(c Config) int { return c.C })
getD := reader.Asks(func(c Config) int { return c.D })
result := reader.SequenceT4(getA, getB, getC, getD)
tuple := result(Config{A: 1, B: 2, C: 3, D: 4})
// Tuple4{F1: 1, F2: 2, F3: 3, F4: 4}