stateio

func ApSL ¶

func ApSL[ST, S, T any](
	lens Lens[S, T],
	fa StateIO[ST, T],
) Endomorphism[StateIO[ST, S]]

ApSL is a lens-based variant of ApS for working with nested structures. It uses a lens to focus on a specific field in the accumulator state, making it easier to update nested fields without manual destructuring.

Example:

nameLens := lens.Prop[Result, string]("name")
result := function.Pipe2(
    Do[AppState](Result{}),
    ApSL(nameLens, Of[AppState]("John")),
)

func BindL ¶

func BindL[ST, S, T any](
	lens Lens[S, T],
	f Kleisli[ST, T, T],
) Endomorphism[StateIO[ST, S]]

BindL is a lens-based variant of Bind for working with nested structures. It uses a lens to focus on a specific field in the accumulator state, allowing you to update that field based on a computation that depends on its current value.

Example:

counterLens := lens.Prop[Result, int]("counter")
result := function.Pipe2(
    Do[AppState](Result{counter: 0}),
    BindL(counterLens, func(n int) StateIO[AppState, int] {
        return Of[AppState](n + 1)
    }),
)

func LetL ¶

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

LetL is a lens-based variant of Let for working with nested structures. It uses a lens to focus on a specific field in the accumulator state, allowing you to update that field using a pure function.

Example:

counterLens := lens.Prop[Result, int]("counter")
result := function.Pipe2(
    Do[AppState](Result{counter: 5}),
    LetL(counterLens, N.Mul(2)),
)

func LetToL ¶

func LetToL[ST, S, T any](
	lens Lens[S, T],
	b T,
) Endomorphism[StateIO[ST, S]]

LetToL is a lens-based variant of LetTo for working with nested structures. It uses a lens to focus on a specific field in the accumulator state, allowing you to set that field to a constant value.

Example:

statusLens := lens.Prop[Result, string]("status")
result := function.Pipe2(
    Do[AppState](Result{}),
    LetToL(statusLens, "active"),
)

func FromIOK ¶

func FromIOK[S, A, B any](f func(A) IO[B]) Kleisli[S, A, B]

FromIOK lifts an IO-returning function into a Kleisli arrow for StateIO. This is useful for composing functions that return IO actions with StateIO computations.

Example:

readFile := func(path string) IO[string] { ... }
kleisli := FromIOK[AppState](readFile)
// kleisli can now be used with Chain

func WithResource ¶

func WithResource[A, S, RES, ANY any](
	onCreate StateIO[S, RES],
	onRelease Kleisli[S, RES, ANY],
) Kleisli[S, Kleisli[S, RES, A], A]

WithResource provides safe resource management for StateIO computations. It ensures that resources are properly acquired and released, even if errors occur.

The function takes:

• onCreate: A StateIO computation that creates/acquires the resource
• onRelease: A Kleisli arrow that releases the resource (receives the resource, returns any value)

It returns a Kleisli arrow that takes a resource-using computation and ensures proper cleanup.

The pattern follows the bracket pattern (acquire-use-release):

1. Acquire the resource using onCreate
2. Use the resource with the provided computation
3. Release the resource using onRelease (guaranteed to run)

Example:

// Create a file resource
openFile := func(s AppState) IO[Pair[AppState, *os.File]] {
    return io.Of(pair.MakePair(s, file))
}

// Release the file resource
closeFile := func(f *os.File) StateIO[AppState, error] {
    return FromIO[AppState](io.Of(f.Close()))
}

// Use the resource safely
withFile := WithResource[string, AppState, *os.File, error](
    openFile,
    closeFile,
)

// Apply to a computation that uses the file
result := withFile(func(f *os.File) StateIO[AppState, string] {
    // Use file f here
    return Of[AppState]("data")
})

func Ap ¶

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

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

func ApS ¶

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

ApS applies a computation in sequence and binds the result to a field. This is the applicative version of Bind, useful for parallel-style composition where computations don't depend on each other's results.

Example:

result := function.Pipe2(
    Do[AppState](Result{}),
    ApS(
        func(count int) func(Result) Result {
            return func(r Result) Result { return Result{count: count} }
        },
        Of[AppState](42),
    ),
)

func Bind ¶

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

Bind executes a computation and binds its result to a field in the accumulator state. This is used in do-notation to sequence dependent computations.

The setter function takes the computed value and returns a function that updates the accumulator state. The computation function (f) receives the current accumulator state and returns a StateIO computation.

Example:

result := function.Pipe2(
    Do[AppState](Result{}),
    Bind(
        func(name string) func(Result) Result {
            return func(r Result) Result { return Result{name: name, age: r.age} }
        },
        func(r Result) StateIO[AppState, string] {
            return Of[AppState]("John")
        },
    ),
)

func BindTo ¶

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

BindTo wraps a value in a simple constructor, typically used to start a do-notation chain after getting an initial value. This transforms a StateIO[S, T] into StateIO[S, S1] by applying a constructor function.

Example:

result := function.Pipe2(
    Of[AppState](42),
    BindTo[AppState](func(x int) Result { return Result{value: x} }),
)

func Chain ¶

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

Chain is the curried version of MonadChain. Returns a function that sequences computations.

Example:

stringify := Chain(func(x int) StateIO[AppState, string] {
    return Of[AppState](fmt.Sprintf("%d", x))
})
result := function.Pipe1(Of[AppState](42), stringify)

func Let ¶

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

Let computes a derived value and binds it to a field in the accumulator state. Unlike Bind, this does not execute a monadic computation, just a pure function.

The key function takes the computed value and returns a function that updates the accumulator state. The computation function (f) receives the current accumulator state and returns a pure value.

Example:

result := function.Pipe2(
    Do[AppState](Result{age: 25}),
    Let(
        func(isAdult bool) func(Result) Result {
            return func(r Result) Result { return Result{age: r.age, isAdult: isAdult} }
        },
        func(r Result) bool { return r.age >= 18 },
    ),
)

func LetTo ¶

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

LetTo binds a constant value to a field in the accumulator state. This is useful for setting fixed values in the accumulator during do-notation.

Example:

result := function.Pipe2(
    Do[AppState](Result{}),
    LetTo(
        func(status string) func(Result) Result {
            return func(r Result) Result { return Result{status: status} }
        },
        "active",
    ),
)

func Map ¶

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

Map is the curried version of MonadMap. Returns a function that transforms a StateIO.

Example:

double := Map[AppState](func(x int) int { return x * 2 })
result := function.Pipe1(Of[AppState](21), double)

func Do ¶

func Do[ST, A any](
	empty A,
) StateIO[ST, A]

Do starts a do-notation chain for building computations in a fluent style. This is typically used with Bind, Let, and other combinators to compose stateful computations with side effects.

Example:

type Result struct {
    name string
    age  int
}
result := function.Pipe2(
    Do[AppState](Result{}),
    Bind(...),
    Let(...),
)

func FromIO ¶

func FromIO[S, A any](fa IO[A]) StateIO[S, A]

FromIO lifts an IO computation into StateIO. The IO computation is executed and its result is wrapped in StateIO. The state is passed through unchanged.

Example:

ioAction := io.Of(42)
stateIOAction := FromIO[AppState](ioAction)

func MonadAp ¶

func MonadAp[B, S, A any](fab StateIO[S, func(A) B], fa StateIO[S, A]) StateIO[S, B]

MonadAp applies a function wrapped in a StateIO to a value wrapped in a StateIO. The state is threaded through both computations sequentially. This is the applicative apply operation.

Example:

fab := Of[AppState](func(x int) int { return x * 2 })
fa := Of[AppState](21)
result := MonadAp(fab, fa) // Result contains 42

func MonadChain ¶

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

MonadChain sequences two computations, passing the result of the first to a function that produces the second computation. This is the monadic bind operation. The state is threaded through both computations sequentially.

Example:

result := MonadChain(
    Of[AppState](5),
    func(x int) StateIO[AppState, string] {
        return Of[AppState](fmt.Sprintf("value: %d", x))
    },
)

func MonadMap ¶

func MonadMap[S, A, B any](fa StateIO[S, A], f func(A) B) StateIO[S, B]

MonadMap transforms the value of a StateIO using the provided function. The state is threaded through the computation unchanged. This is the functor map operation.

Example:

result := MonadMap(
    Of[AppState](21),
    func(x int) int { return x * 2 },
) // Result contains 42

func Of ¶

func Of[S, A any](a A) StateIO[S, A]

Of creates a StateIO that wraps a pure value. The value is wrapped and the state is passed through unchanged.

This is the Pointed/Applicative 'of' operation that lifts a pure value into the StateIO context.

Example:

result := Of[AppState](42)
// Returns a computation containing 42 that passes state through unchanged