ioresult

func MonadFold ¶

func MonadFold[A, B any](ma IOResult[A], onLeft func(error) IO[B], onRight io.Kleisli[A, B]) IO[B]

func Bracket ¶

func Bracket[A, B, ANY any](
	acquire IOResult[A],
	use Kleisli[A, B],
	release func(A, Result[B]) IOResult[ANY],
) IOResult[B]

Bracket makes sure that a resource is cleaned up in the event of an error. The release action is called regardless of whether the body action returns and error or not.

func Defer ¶

func Defer[A any](gen Lazy[IOResult[A]]) IOResult[A]

Defer creates an IO by creating a brand new IO via a generator function, each time

func Do ¶

func Do[S any](
	empty S,
) IOResult[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.

Example:

type State struct {
    User  User
    Posts []Post
}
result := ioeither.Do[error](State{})

func Flatten ¶

func Flatten[A any](mma IOResult[IOResult[A]]) IOResult[A]

func FromEither ¶

func FromEither[A any](e Result[A]) IOResult[A]

func FromEitherI ¶

func FromEitherI[A any](a A, err error) IOResult[A]

func FromIO ¶

func FromIO[A any](mr IO[A]) IOResult[A]

FromIO creates an IOResult from an IO instancinvoking IO for each invocation of IOResult

func FromImpure ¶

func FromImpure[E any](f func()) IOResult[Void]

FromImpure converts a side effect without a return value into a side effect that returns any

func FromLazy ¶

func FromLazy[A any](mr Lazy[A]) IOResult[A]

FromLazy creates an IOResult from a Lazy instancinvoking Lazy for each invocation of IOResult

func FromResult ¶

func FromResult[A any](e Result[A]) IOResult[A]

func FromResultI ¶

func FromResultI[A any](a A, err error) IOResult[A]

func Left ¶

func Left[A any](l error) IOResult[A]

func LeftIO ¶

func LeftIO[A any](ml IO[error]) IOResult[A]

func Memoize ¶

func Memoize[A any](ma IOResult[A]) IOResult[A]

func MonadAlt ¶

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

MonadAlt identifies an associative operation on a type constructor

func MonadAp ¶

func MonadAp[B, A any](mab IOResult[func(A) B], ma IOResult[A]) IOResult[B]

func MonadApFirst ¶

func MonadApFirst[A, B any](first IOResult[A], second IOResult[B]) IOResult[A]

MonadApFirst combines two effectful actions, keeping only the result of the first.

func MonadApPar ¶

func MonadApPar[B, A any](mab IOResult[func(A) B], ma IOResult[A]) IOResult[B]

func MonadApSecond ¶

func MonadApSecond[A, B any](first IOResult[A], second IOResult[B]) IOResult[B]

MonadApSecond combines two effectful actions, keeping only the result of the second.

func MonadApSeq ¶

func MonadApSeq[B, A any](mab IOResult[func(A) B], ma IOResult[A]) IOResult[B]

func MonadChain ¶

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

func MonadChainEitherK ¶

func MonadChainEitherK[A, B any](ma IOResult[A], f result.Kleisli[A, B]) IOResult[B]

func MonadChainFirst ¶

func MonadChainFirst[A, B any](ma IOResult[A], f Kleisli[A, B]) IOResult[A]

MonadChainFirst runs the IOResult monad returned by the function but returns the result of the original monad

func MonadChainFirstEitherK ¶

func MonadChainFirstEitherK[A, B any](ma IOResult[A], f result.Kleisli[A, B]) IOResult[A]

func MonadChainFirstIOK ¶

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

MonadChainFirstIOK runs IO the monad returned by the function but returns the result of the original monad

func MonadChainFirstLeft ¶

func MonadChainFirstLeft[A, B any](fa IOResult[A], f Kleisli[error, B]) IOResult[A]

func MonadChainFirstResultK ¶

func MonadChainFirstResultK[A, B any](ma IOResult[A], f result.Kleisli[A, B]) IOResult[A]

func MonadChainI ¶

func MonadChainI[A, B any](fa IOResult[A], f IOI.Kleisli[A, B]) IOResult[B]

func MonadChainIOK ¶

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

func MonadChainLeft ¶

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

func MonadChainResultK ¶

func MonadChainResultK[A, B any](ma IOResult[A], f result.Kleisli[A, B]) IOResult[B]

func MonadChainTo ¶

func MonadChainTo[A, B any](fa IOResult[A], fb IOResult[B]) IOResult[B]

MonadChainTo composes to the second monad ignoring the return value of the first

func MonadFlap ¶

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

func MonadMap ¶

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

func MonadMapTo ¶

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

func MonadOf ¶

func MonadOf[A any](r A) IOResult[A]

func MonadTap ¶

func MonadTap[A, B any](ma IOResult[A], f Kleisli[A, B]) IOResult[A]

func MonadTapEitherK ¶

func MonadTapEitherK[A, B any](ma IOResult[A], f result.Kleisli[A, B]) IOResult[A]

func MonadTapIOK ¶

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

func MonadTapLeft ¶

func MonadTapLeft[A, B any](fa IOResult[A], f Kleisli[error, B]) IOResult[A]

func MonadTapResultK ¶

func MonadTapResultK[A, B any](ma IOResult[A], f result.Kleisli[A, B]) IOResult[A]

func Of ¶

func Of[A any](r A) IOResult[A]

func Retrying ¶

func Retrying[A any](
	policy R.RetryPolicy,
	action Kleisli[R.RetryStatus, A],
	check Predicate[Result[A]],
) IOResult[A]

Retrying will retry the actions according to the check policy

policy - refers to the retry policy action - converts a status into an operation to be executed check - checks if the result of the action needs to be retried

func Right ¶

func Right[A any](r A) IOResult[A]

func RightIO ¶

func RightIO[A any](mr IO[A]) IOResult[A]

func SequenceArray ¶

func SequenceArray[A any](ma []IOResult[A]) IOResult[[]A]

SequenceArray converts a homogeneous sequence of either into an either of sequence

func SequenceArrayPar ¶

func SequenceArrayPar[A any](ma []IOResult[A]) IOResult[[]A]

SequenceArrayPar converts a homogeneous Paruence of either into an either of Paruence

func SequenceArraySeq ¶

func SequenceArraySeq[A any](ma []IOResult[A]) IOResult[[]A]

SequenceArraySeq converts a homogeneous sequence of either into an either of sequence

func SequenceParT1 ¶

func SequenceParT1[T1 any](
	t1 IOResult[T1],
) IOResult[tuple.Tuple1[T1]]

SequenceParT1 converts 1 [IOResult[T]] into a [IOResult[tuple.Tuple1[T1]]]

func SequenceParT2 ¶

func SequenceParT2[T1, T2 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
) IOResult[tuple.Tuple2[T1, T2]]

SequenceParT2 converts 2 [IOResult[T]] into a [IOResult[tuple.Tuple2[T1, T2]]]

func SequenceParT3 ¶

func SequenceParT3[T1, T2, T3 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
) IOResult[tuple.Tuple3[T1, T2, T3]]

SequenceParT3 converts 3 [IOResult[T]] into a [IOResult[tuple.Tuple3[T1, T2, T3]]]

func SequenceParT4 ¶

func SequenceParT4[T1, T2, T3, T4 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
) IOResult[tuple.Tuple4[T1, T2, T3, T4]]

SequenceParT4 converts 4 [IOResult[T]] into a [IOResult[tuple.Tuple4[T1, T2, T3, T4]]]

func SequenceParT5 ¶

func SequenceParT5[T1, T2, T3, T4, T5 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
) IOResult[tuple.Tuple5[T1, T2, T3, T4, T5]]

SequenceParT5 converts 5 [IOResult[T]] into a [IOResult[tuple.Tuple5[T1, T2, T3, T4, T5]]]

func SequenceParT6 ¶

func SequenceParT6[T1, T2, T3, T4, T5, T6 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
	t6 IOResult[T6],
) IOResult[tuple.Tuple6[T1, T2, T3, T4, T5, T6]]

SequenceParT6 converts 6 [IOResult[T]] into a [IOResult[tuple.Tuple6[T1, T2, T3, T4, T5, T6]]]

func SequenceParT7 ¶

func SequenceParT7[T1, T2, T3, T4, T5, T6, T7 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
	t6 IOResult[T6],
	t7 IOResult[T7],
) IOResult[tuple.Tuple7[T1, T2, T3, T4, T5, T6, T7]]

SequenceParT7 converts 7 [IOResult[T]] into a [IOResult[tuple.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]

func SequenceParT8 ¶

func SequenceParT8[T1, T2, T3, T4, T5, T6, T7, T8 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
	t6 IOResult[T6],
	t7 IOResult[T7],
	t8 IOResult[T8],
) IOResult[tuple.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]

SequenceParT8 converts 8 [IOResult[T]] into a [IOResult[tuple.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]

func SequenceParT9 ¶

func SequenceParT9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
	t6 IOResult[T6],
	t7 IOResult[T7],
	t8 IOResult[T8],
	t9 IOResult[T9],
) IOResult[tuple.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]

SequenceParT9 converts 9 [IOResult[T]] into a [IOResult[tuple.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]

func SequenceParT10 ¶

func SequenceParT10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
	t6 IOResult[T6],
	t7 IOResult[T7],
	t8 IOResult[T8],
	t9 IOResult[T9],
	t10 IOResult[T10],
) IOResult[tuple.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]

SequenceParT10 converts 10 [IOResult[T]] into a [IOResult[tuple.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]

func SequenceParTuple1 ¶

func SequenceParTuple1[T1 any](t tuple.Tuple1[IOResult[T1]]) IOResult[tuple.Tuple1[T1]]

SequenceParTuple1 converts a [tuple.Tuple1[IOResult[T]]] into a [IOResult[tuple.Tuple1[T1]]]

func SequenceParTuple2 ¶

func SequenceParTuple2[T1, T2 any](t tuple.Tuple2[IOResult[T1], IOResult[T2]]) IOResult[tuple.Tuple2[T1, T2]]

SequenceParTuple2 converts a [tuple.Tuple2[IOResult[T]]] into a [IOResult[tuple.Tuple2[T1, T2]]]

func SequenceParTuple3 ¶

func SequenceParTuple3[T1, T2, T3 any](t tuple.Tuple3[IOResult[T1], IOResult[T2], IOResult[T3]]) IOResult[tuple.Tuple3[T1, T2, T3]]

SequenceParTuple3 converts a [tuple.Tuple3[IOResult[T]]] into a [IOResult[tuple.Tuple3[T1, T2, T3]]]

func SequenceParTuple4 ¶

func SequenceParTuple4[T1, T2, T3, T4 any](t tuple.Tuple4[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4]]) IOResult[tuple.Tuple4[T1, T2, T3, T4]]

SequenceParTuple4 converts a [tuple.Tuple4[IOResult[T]]] into a [IOResult[tuple.Tuple4[T1, T2, T3, T4]]]

func SequenceParTuple5 ¶

func SequenceParTuple5[T1, T2, T3, T4, T5 any](t tuple.Tuple5[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5]]) IOResult[tuple.Tuple5[T1, T2, T3, T4, T5]]

SequenceParTuple5 converts a [tuple.Tuple5[IOResult[T]]] into a [IOResult[tuple.Tuple5[T1, T2, T3, T4, T5]]]

func SequenceParTuple6 ¶

func SequenceParTuple6[T1, T2, T3, T4, T5, T6 any](t tuple.Tuple6[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5], IOResult[T6]]) IOResult[tuple.Tuple6[T1, T2, T3, T4, T5, T6]]

SequenceParTuple6 converts a [tuple.Tuple6[IOResult[T]]] into a [IOResult[tuple.Tuple6[T1, T2, T3, T4, T5, T6]]]

func SequenceParTuple7 ¶

func SequenceParTuple7[T1, T2, T3, T4, T5, T6, T7 any](t tuple.Tuple7[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5], IOResult[T6], IOResult[T7]]) IOResult[tuple.Tuple7[T1, T2, T3, T4, T5, T6, T7]]

SequenceParTuple7 converts a [tuple.Tuple7[IOResult[T]]] into a [IOResult[tuple.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]

func SequenceParTuple8 ¶

func SequenceParTuple8[T1, T2, T3, T4, T5, T6, T7, T8 any](t tuple.Tuple8[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5], IOResult[T6], IOResult[T7], IOResult[T8]]) IOResult[tuple.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]

SequenceParTuple8 converts a [tuple.Tuple8[IOResult[T]]] into a [IOResult[tuple.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]

func SequenceParTuple9 ¶

func SequenceParTuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t tuple.Tuple9[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5], IOResult[T6], IOResult[T7], IOResult[T8], IOResult[T9]]) IOResult[tuple.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]

SequenceParTuple9 converts a [tuple.Tuple9[IOResult[T]]] into a [IOResult[tuple.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]

func SequenceParTuple10 ¶

func SequenceParTuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t tuple.Tuple10[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5], IOResult[T6], IOResult[T7], IOResult[T8], IOResult[T9], IOResult[T10]]) IOResult[tuple.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]

SequenceParTuple10 converts a [tuple.Tuple10[IOResult[T]]] into a [IOResult[tuple.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]

func SequenceRecord ¶

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

SequenceRecord converts a homogeneous sequence of either into an either of sequence

func SequenceRecordPar ¶

func SequenceRecordPar[K comparable, A any](ma map[K]IOResult[A]) IOResult[map[K]A]

SequenceRecordPar converts a homogeneous Paruence of either into an either of Paruence

func SequenceRecordSeq ¶

func SequenceRecordSeq[K comparable, A any](ma map[K]IOResult[A]) IOResult[map[K]A]

SequenceRecordSeq converts a homogeneous sequence of either into an either of sequence

func SequenceSeqT1 ¶

func SequenceSeqT1[T1 any](
	t1 IOResult[T1],
) IOResult[tuple.Tuple1[T1]]

SequenceSeqT1 converts 1 [IOResult[T]] into a [IOResult[tuple.Tuple1[T1]]]

func SequenceSeqT2 ¶

func SequenceSeqT2[T1, T2 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
) IOResult[tuple.Tuple2[T1, T2]]

SequenceSeqT2 converts 2 [IOResult[T]] into a [IOResult[tuple.Tuple2[T1, T2]]]

func SequenceSeqT3 ¶

func SequenceSeqT3[T1, T2, T3 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
) IOResult[tuple.Tuple3[T1, T2, T3]]

SequenceSeqT3 converts 3 [IOResult[T]] into a [IOResult[tuple.Tuple3[T1, T2, T3]]]

func SequenceSeqT4 ¶

func SequenceSeqT4[T1, T2, T3, T4 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
) IOResult[tuple.Tuple4[T1, T2, T3, T4]]

SequenceSeqT4 converts 4 [IOResult[T]] into a [IOResult[tuple.Tuple4[T1, T2, T3, T4]]]

func SequenceSeqT5 ¶

func SequenceSeqT5[T1, T2, T3, T4, T5 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
) IOResult[tuple.Tuple5[T1, T2, T3, T4, T5]]

SequenceSeqT5 converts 5 [IOResult[T]] into a [IOResult[tuple.Tuple5[T1, T2, T3, T4, T5]]]

func SequenceSeqT6 ¶

func SequenceSeqT6[T1, T2, T3, T4, T5, T6 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
	t6 IOResult[T6],
) IOResult[tuple.Tuple6[T1, T2, T3, T4, T5, T6]]

SequenceSeqT6 converts 6 [IOResult[T]] into a [IOResult[tuple.Tuple6[T1, T2, T3, T4, T5, T6]]]

func SequenceSeqT7 ¶

func SequenceSeqT7[T1, T2, T3, T4, T5, T6, T7 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
	t6 IOResult[T6],
	t7 IOResult[T7],
) IOResult[tuple.Tuple7[T1, T2, T3, T4, T5, T6, T7]]

SequenceSeqT7 converts 7 [IOResult[T]] into a [IOResult[tuple.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]

func SequenceSeqT8 ¶

func SequenceSeqT8[T1, T2, T3, T4, T5, T6, T7, T8 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
	t6 IOResult[T6],
	t7 IOResult[T7],
	t8 IOResult[T8],
) IOResult[tuple.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]

SequenceSeqT8 converts 8 [IOResult[T]] into a [IOResult[tuple.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]

func SequenceSeqT9 ¶

func SequenceSeqT9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
	t6 IOResult[T6],
	t7 IOResult[T7],
	t8 IOResult[T8],
	t9 IOResult[T9],
) IOResult[tuple.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]

SequenceSeqT9 converts 9 [IOResult[T]] into a [IOResult[tuple.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]

func SequenceSeqT10 ¶

func SequenceSeqT10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
	t6 IOResult[T6],
	t7 IOResult[T7],
	t8 IOResult[T8],
	t9 IOResult[T9],
	t10 IOResult[T10],
) IOResult[tuple.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]

SequenceSeqT10 converts 10 [IOResult[T]] into a [IOResult[tuple.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]

func SequenceSeqTuple1 ¶

func SequenceSeqTuple1[T1 any](t tuple.Tuple1[IOResult[T1]]) IOResult[tuple.Tuple1[T1]]

SequenceSeqTuple1 converts a [tuple.Tuple1[IOResult[T]]] into a [IOResult[tuple.Tuple1[T1]]]

func SequenceSeqTuple2 ¶

func SequenceSeqTuple2[T1, T2 any](t tuple.Tuple2[IOResult[T1], IOResult[T2]]) IOResult[tuple.Tuple2[T1, T2]]

SequenceSeqTuple2 converts a [tuple.Tuple2[IOResult[T]]] into a [IOResult[tuple.Tuple2[T1, T2]]]

func SequenceSeqTuple3 ¶

func SequenceSeqTuple3[T1, T2, T3 any](t tuple.Tuple3[IOResult[T1], IOResult[T2], IOResult[T3]]) IOResult[tuple.Tuple3[T1, T2, T3]]

SequenceSeqTuple3 converts a [tuple.Tuple3[IOResult[T]]] into a [IOResult[tuple.Tuple3[T1, T2, T3]]]

func SequenceSeqTuple4 ¶

func SequenceSeqTuple4[T1, T2, T3, T4 any](t tuple.Tuple4[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4]]) IOResult[tuple.Tuple4[T1, T2, T3, T4]]

SequenceSeqTuple4 converts a [tuple.Tuple4[IOResult[T]]] into a [IOResult[tuple.Tuple4[T1, T2, T3, T4]]]

func SequenceSeqTuple5 ¶

func SequenceSeqTuple5[T1, T2, T3, T4, T5 any](t tuple.Tuple5[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5]]) IOResult[tuple.Tuple5[T1, T2, T3, T4, T5]]

SequenceSeqTuple5 converts a [tuple.Tuple5[IOResult[T]]] into a [IOResult[tuple.Tuple5[T1, T2, T3, T4, T5]]]

func SequenceSeqTuple6 ¶

func SequenceSeqTuple6[T1, T2, T3, T4, T5, T6 any](t tuple.Tuple6[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5], IOResult[T6]]) IOResult[tuple.Tuple6[T1, T2, T3, T4, T5, T6]]

SequenceSeqTuple6 converts a [tuple.Tuple6[IOResult[T]]] into a [IOResult[tuple.Tuple6[T1, T2, T3, T4, T5, T6]]]

func SequenceSeqTuple7 ¶

func SequenceSeqTuple7[T1, T2, T3, T4, T5, T6, T7 any](t tuple.Tuple7[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5], IOResult[T6], IOResult[T7]]) IOResult[tuple.Tuple7[T1, T2, T3, T4, T5, T6, T7]]

SequenceSeqTuple7 converts a [tuple.Tuple7[IOResult[T]]] into a [IOResult[tuple.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]

func SequenceSeqTuple8 ¶

func SequenceSeqTuple8[T1, T2, T3, T4, T5, T6, T7, T8 any](t tuple.Tuple8[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5], IOResult[T6], IOResult[T7], IOResult[T8]]) IOResult[tuple.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]

SequenceSeqTuple8 converts a [tuple.Tuple8[IOResult[T]]] into a [IOResult[tuple.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]

func SequenceSeqTuple9 ¶

func SequenceSeqTuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t tuple.Tuple9[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5], IOResult[T6], IOResult[T7], IOResult[T8], IOResult[T9]]) IOResult[tuple.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]

SequenceSeqTuple9 converts a [tuple.Tuple9[IOResult[T]]] into a [IOResult[tuple.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]

func SequenceSeqTuple10 ¶

func SequenceSeqTuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t tuple.Tuple10[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5], IOResult[T6], IOResult[T7], IOResult[T8], IOResult[T9], IOResult[T10]]) IOResult[tuple.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]

SequenceSeqTuple10 converts a [tuple.Tuple10[IOResult[T]]] into a [IOResult[tuple.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]

func SequenceT1 ¶

func SequenceT1[T1 any](
	t1 IOResult[T1],
) IOResult[tuple.Tuple1[T1]]

SequenceT1 converts 1 [IOResult[T]] into a [IOResult[tuple.Tuple1[T1]]]

func SequenceT2 ¶

func SequenceT2[T1, T2 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
) IOResult[tuple.Tuple2[T1, T2]]

SequenceT2 converts 2 [IOResult[T]] into a [IOResult[tuple.Tuple2[T1, T2]]]

func SequenceT3 ¶

func SequenceT3[T1, T2, T3 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
) IOResult[tuple.Tuple3[T1, T2, T3]]

SequenceT3 converts 3 [IOResult[T]] into a [IOResult[tuple.Tuple3[T1, T2, T3]]]

func SequenceT4 ¶

func SequenceT4[T1, T2, T3, T4 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
) IOResult[tuple.Tuple4[T1, T2, T3, T4]]

SequenceT4 converts 4 [IOResult[T]] into a [IOResult[tuple.Tuple4[T1, T2, T3, T4]]]

func SequenceT5 ¶

func SequenceT5[T1, T2, T3, T4, T5 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
) IOResult[tuple.Tuple5[T1, T2, T3, T4, T5]]

SequenceT5 converts 5 [IOResult[T]] into a [IOResult[tuple.Tuple5[T1, T2, T3, T4, T5]]]

func SequenceT6 ¶

func SequenceT6[T1, T2, T3, T4, T5, T6 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
	t6 IOResult[T6],
) IOResult[tuple.Tuple6[T1, T2, T3, T4, T5, T6]]

SequenceT6 converts 6 [IOResult[T]] into a [IOResult[tuple.Tuple6[T1, T2, T3, T4, T5, T6]]]

func SequenceT7 ¶

func SequenceT7[T1, T2, T3, T4, T5, T6, T7 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
	t6 IOResult[T6],
	t7 IOResult[T7],
) IOResult[tuple.Tuple7[T1, T2, T3, T4, T5, T6, T7]]

SequenceT7 converts 7 [IOResult[T]] into a [IOResult[tuple.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]

func SequenceT8 ¶

func SequenceT8[T1, T2, T3, T4, T5, T6, T7, T8 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
	t6 IOResult[T6],
	t7 IOResult[T7],
	t8 IOResult[T8],
) IOResult[tuple.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]

SequenceT8 converts 8 [IOResult[T]] into a [IOResult[tuple.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]

func SequenceT9 ¶

func SequenceT9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
	t6 IOResult[T6],
	t7 IOResult[T7],
	t8 IOResult[T8],
	t9 IOResult[T9],
) IOResult[tuple.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]

SequenceT9 converts 9 [IOResult[T]] into a [IOResult[tuple.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]

func SequenceT10 ¶

func SequenceT10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](
	t1 IOResult[T1],
	t2 IOResult[T2],
	t3 IOResult[T3],
	t4 IOResult[T4],
	t5 IOResult[T5],
	t6 IOResult[T6],
	t7 IOResult[T7],
	t8 IOResult[T8],
	t9 IOResult[T9],
	t10 IOResult[T10],
) IOResult[tuple.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]

SequenceT10 converts 10 [IOResult[T]] into a [IOResult[tuple.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]

func SequenceTuple1 ¶

func SequenceTuple1[T1 any](t tuple.Tuple1[IOResult[T1]]) IOResult[tuple.Tuple1[T1]]

SequenceTuple1 converts a [tuple.Tuple1[IOResult[T]]] into a [IOResult[tuple.Tuple1[T1]]]

func SequenceTuple2 ¶

func SequenceTuple2[T1, T2 any](t tuple.Tuple2[IOResult[T1], IOResult[T2]]) IOResult[tuple.Tuple2[T1, T2]]

SequenceTuple2 converts a [tuple.Tuple2[IOResult[T]]] into a [IOResult[tuple.Tuple2[T1, T2]]]

func SequenceTuple3 ¶

func SequenceTuple3[T1, T2, T3 any](t tuple.Tuple3[IOResult[T1], IOResult[T2], IOResult[T3]]) IOResult[tuple.Tuple3[T1, T2, T3]]

SequenceTuple3 converts a [tuple.Tuple3[IOResult[T]]] into a [IOResult[tuple.Tuple3[T1, T2, T3]]]

func SequenceTuple4 ¶

func SequenceTuple4[T1, T2, T3, T4 any](t tuple.Tuple4[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4]]) IOResult[tuple.Tuple4[T1, T2, T3, T4]]

SequenceTuple4 converts a [tuple.Tuple4[IOResult[T]]] into a [IOResult[tuple.Tuple4[T1, T2, T3, T4]]]

func SequenceTuple5 ¶

func SequenceTuple5[T1, T2, T3, T4, T5 any](t tuple.Tuple5[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5]]) IOResult[tuple.Tuple5[T1, T2, T3, T4, T5]]

SequenceTuple5 converts a [tuple.Tuple5[IOResult[T]]] into a [IOResult[tuple.Tuple5[T1, T2, T3, T4, T5]]]

func SequenceTuple6 ¶

func SequenceTuple6[T1, T2, T3, T4, T5, T6 any](t tuple.Tuple6[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5], IOResult[T6]]) IOResult[tuple.Tuple6[T1, T2, T3, T4, T5, T6]]

SequenceTuple6 converts a [tuple.Tuple6[IOResult[T]]] into a [IOResult[tuple.Tuple6[T1, T2, T3, T4, T5, T6]]]

func SequenceTuple7 ¶

func SequenceTuple7[T1, T2, T3, T4, T5, T6, T7 any](t tuple.Tuple7[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5], IOResult[T6], IOResult[T7]]) IOResult[tuple.Tuple7[T1, T2, T3, T4, T5, T6, T7]]

SequenceTuple7 converts a [tuple.Tuple7[IOResult[T]]] into a [IOResult[tuple.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]

func SequenceTuple8 ¶

func SequenceTuple8[T1, T2, T3, T4, T5, T6, T7, T8 any](t tuple.Tuple8[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5], IOResult[T6], IOResult[T7], IOResult[T8]]) IOResult[tuple.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]

SequenceTuple8 converts a [tuple.Tuple8[IOResult[T]]] into a [IOResult[tuple.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]

func SequenceTuple9 ¶

func SequenceTuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t tuple.Tuple9[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5], IOResult[T6], IOResult[T7], IOResult[T8], IOResult[T9]]) IOResult[tuple.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]

SequenceTuple9 converts a [tuple.Tuple9[IOResult[T]]] into a [IOResult[tuple.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]

func SequenceTuple10 ¶

func SequenceTuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t tuple.Tuple10[IOResult[T1], IOResult[T2], IOResult[T3], IOResult[T4], IOResult[T5], IOResult[T6], IOResult[T7], IOResult[T8], IOResult[T9], IOResult[T10]]) IOResult[tuple.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]

SequenceTuple10 converts a [tuple.Tuple10[IOResult[T]]] into a [IOResult[tuple.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]

func TryCatch ¶

func TryCatch[A any](f func() (A, error), onThrow Endomorphism[error]) IOResult[A]

func TryCatchError ¶

func TryCatchError[A any](f func() (A, error)) IOResult[A]

func LogJSON ¶

func LogJSON[A any](prefix string) Kleisli[A, string]

LogJSON converts the argument to pretty printed JSON and then logs it via the format string Can be used with ChainFirst

func TailRec ¶

func TailRec[A, B any](f Kleisli[A, tailrec.Trampoline[A, B]]) Kleisli[A, B]

func TraverseArray ¶

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

TraverseArray transforms an array

func TraverseArrayPar ¶

func TraverseArrayPar[A, B any](f Kleisli[A, B]) Kleisli[[]A, []B]

TraverseArrayPar transforms an array

func TraverseArraySeq ¶

func TraverseArraySeq[A, B any](f Kleisli[A, B]) Kleisli[[]A, []B]

TraverseArraySeq transforms an array

func TraverseArrayWithIndex ¶

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

TraverseArrayWithIndex transforms an array

func TraverseArrayWithIndexPar ¶

func TraverseArrayWithIndexPar[A, B any](f func(int, A) IOResult[B]) Kleisli[[]A, []B]

TraverseArrayWithIndexPar transforms an array

func TraverseArrayWithIndexSeq ¶

func TraverseArrayWithIndexSeq[A, B any](f func(int, A) IOResult[B]) Kleisli[[]A, []B]

TraverseArrayWithIndexSeq transforms an array

func TraverseRecord ¶

func TraverseRecord[K comparable, A, B any](f Kleisli[A, B]) Kleisli[map[K]A, map[K]B]

TraverseRecord transforms a record

func TraverseRecordPar ¶

func TraverseRecordPar[K comparable, A, B any](f Kleisli[A, B]) Kleisli[map[K]A, map[K]B]

TraverseRecordPar transforms a record

func TraverseRecordSeq ¶

func TraverseRecordSeq[K comparable, A, B any](f Kleisli[A, B]) Kleisli[map[K]A, map[K]B]

TraverseRecordSeq transforms a record

func TraverseRecordWithIndex ¶

func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) IOResult[B]) Kleisli[map[K]A, map[K]B]

TraverseRecordWithIndex transforms a record

func TraverseRecordWithIndexPar ¶

func TraverseRecordWithIndexPar[K comparable, A, B any](f func(K, A) IOResult[B]) Kleisli[map[K]A, map[K]B]

TraverseRecordWithIndexPar transforms a record

func TraverseRecordWithIndexSeq ¶

func TraverseRecordWithIndexSeq[K comparable, A, B any](f func(K, A) IOResult[B]) Kleisli[map[K]A, map[K]B]

TraverseRecordWithIndexSeq transforms a record

func WithResource ¶

func WithResource[A, R, ANY any](onCreate IOResult[R], onRelease Kleisli[R, ANY]) Kleisli[Kleisli[R, A], A]

WithResource constructs a function that creates a resourcthen operates on it and then releases the resource

func ApplicativeMonoid ¶

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

ApplicativeMonoid returns a Monoid that concatenates IOResult instances via their applicative

func ApplicativeMonoidPar ¶

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

ApplicativeMonoid returns a Monoid that concatenates IOResult instances via their applicative

func ApplicativeMonoidSeq ¶

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

ApplicativeMonoid returns a Monoid that concatenates IOResult instances via their applicative

func After ¶

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

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

func Alt ¶

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

Alt identifies an associative operation on a type constructor

func Ap ¶

func Ap[B, A any](ma IOResult[A]) Operator[func(A) B, B]

Ap is an alias of ApPar

func ApFirst ¶

func ApFirst[A, B any](second IOResult[B]) Operator[A, A]

ApFirst combines two effectful actions, keeping only the result of the first.

func ApPar ¶

func ApPar[B, A any](ma IOResult[A]) Operator[func(A) B, B]

ApPar applies function and value in parallel

func ApS ¶

func ApS[S1, S2, T any](
	setter func(T) func(S1) S2,
	fa IOResult[T],
) Operator[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 allows independent computations to be combined without one depending on the result of the other.

Unlike Bind, which sequences operations, ApS can be used when operations are independent and can conceptually run in parallel.

Example:

type State struct {
    User  User
    Posts []Post
}

// These operations are independent and can be combined with ApS
getUser := ioeither.Right[error](User{ID: 1, Name: "Alice"})
getPosts := ioeither.Right[error]([]Post{{ID: 1, Title: "Hello"}})

result := F.Pipe2(
    ioeither.Do[error](State{}),
    ioeither.ApS(
        func(user User) func(State) State {
            return func(s State) State { s.User = user; return s }
        },
        getUser,
    ),
    ioeither.ApS(
        func(posts []Post) func(State) State {
            return func(s State) State { s.Posts = posts; return s }
        },
        getPosts,
    ),
)

func ApSL ¶

func ApSL[S, T any](
	lens L.Lens[S, T],
	fa IOResult[T],
) Operator[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 Config struct {
    Host string
    Port int
}

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

result := F.Pipe2(
    ioeither.Of[error](Config{Host: "localhost"}),
    ioeither.ApSL(portLens, ioeither.Of[error](8080)),
)

func ApSecond ¶

func ApSecond[A, B any](second IOResult[B]) Operator[A, B]

ApSecond combines two effectful actions, keeping only the result of the second.

func Bind ¶

func Bind[S1, S2, T any](
	setter func(T) func(S1) S2,
	f Kleisli[S1, T],
) Operator[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.

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
}

result := F.Pipe2(
    ioeither.Do[error](State{}),
    ioeither.Bind(
        func(user User) func(State) State {
            return func(s State) State { s.User = user; return s }
        },
        func(s State) ioeither.IOResult[error, User] {
            return ioeither.TryCatch(func() (User, error) {
                return fetchUser()
            })
        },
    ),
    ioeither.Bind(
        func(posts []Post) func(State) State {
            return func(s State) State { s.Posts = posts; return s }
        },
        func(s State) ioeither.IOResult[error, []Post] {
            // This can access s.User from the previous step
            return ioeither.TryCatch(func() ([]Post, error) {
                return fetchPostsForUser(s.User.ID)
            })
        },
    ),
)

func BindL ¶

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

BindL attaches the result of a computation to a context using a lens-based setter. This is a convenience function that combines Bind with a lens, allowing you to use optics to update nested structures based on their current values.

The lens parameter provides both the getter and setter for a field within the structure S. The computation function f receives the current value of the focused field and returns an IOResult that produces the new value.

Example:

type Counter struct {
    Value int
}

valueLens := lens.MakeLens(
    func(c Counter) int { return c.Value },
    func(c Counter, v int) Counter { c.Value = v; return c },
)

increment := func(v int) ioeither.IOResult[error, int] {
    return ioeither.TryCatch(func() (int, error) {
        if v >= 100 {
            return 0, errors.New("overflow")
        }
        return v + 1, nil
    })
}

result := F.Pipe1(
    ioeither.Of[error](Counter{Value: 42}),
    ioeither.BindL(valueLens, increment),
)

func BindTo ¶

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

BindTo initializes a new state [S1] from a value [T]

func Chain ¶

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

func ChainConsumer ¶

func ChainConsumer[A any](c Consumer[A]) Operator[A, struct{}]

func ChainEitherK ¶

func ChainEitherK[A, B any](f result.Kleisli[A, B]) Operator[A, B]

func ChainFirst ¶

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

ChainFirst runs the IOResult monad returned by the function but returns the result of the original monad

func ChainFirstConsumer ¶

func ChainFirstConsumer[A any](c Consumer[A]) Operator[A, A]

func ChainFirstEitherK ¶

func ChainFirstEitherK[A, B any](f result.Kleisli[A, B]) Operator[A, A]

func ChainFirstIOK ¶

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

ChainFirstIOK runs the IO monad returned by the function but returns the result of the original monad

func ChainFirstLeft ¶

func ChainFirstLeft[A, B any](f Kleisli[error, B]) Operator[A, A]

func ChainI ¶

func ChainI[A, B any](f IOI.Kleisli[A, B]) Operator[A, B]

func ChainIOK ¶

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

func ChainLazyK ¶

func ChainLazyK[A, B any](f func(A) Lazy[B]) Operator[A, B]

func ChainLeft ¶

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

func ChainResultK ¶

func ChainResultK[A, B any](f result.Kleisli[A, B]) Operator[A, B]

func ChainTo ¶

func ChainTo[A, B any](fb IOResult[B]) Operator[A, B]

ChainTo composes to the second IOResult monad ignoring the return value of the first

func Delay ¶

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

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

func Flap ¶

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

func Let ¶

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

Let attaches the result of a computation to a context [S1] to produce a context [S2]

func LetL ¶

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

LetL attaches the result of a pure computation to a context using a lens-based setter. This is a convenience function that combines Let with a lens, allowing you to use optics to update nested structures with pure transformations.

The lens parameter provides both the getter and setter for a field within the structure S. The transformation function f receives the current value of the focused field and returns the new value directly (not wrapped in IOResult).

Example:

type Counter struct {
    Value int
}

valueLens := lens.MakeLens(
    func(c Counter) int { return c.Value },
    func(c Counter, v int) Counter { c.Value = v; return c },
)

double := func(v int) int { return v * 2 }

result := F.Pipe1(
    ioeither.Of[error](Counter{Value: 21}),
    ioeither.LetL(valueLens, double),
)

func LetTo ¶

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

LetTo attaches the a value to a context [S1] to produce a context [S2]

func LetToL ¶

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

LetToL attaches a constant value to a context using a lens-based setter. This is a convenience function that combines LetTo with a lens, allowing you to use optics to set nested fields to specific values.

The lens parameter provides the setter for a field within the structure S. Unlike LetL which transforms the current valuLetToL simply replaces it with the provided constant value b.

Example:

type Config struct {
    Debug   bool
    Timeout int
}

debugLens := lens.MakeLens(
    func(c Config) bool { return c.Debug },
    func(c Config, d bool) Config { c.Debug = d; return c },
)

result := F.Pipe1(
    ioeither.Of[error](Config{Debug: truTimeout: 30}),
    ioeither.LetToL(debugLens, false),
)

func LogEntryExit ¶

func LogEntryExit[A any](name string) Operator[A, A]

func LogEntryExitF ¶

func LogEntryExitF[A, STARTTOKEN, ANY any](
	onEntry IO[STARTTOKEN],
	onExit io.Kleisli[pair.Pair[STARTTOKEN, Result[A]], ANY],
) Operator[A, A]

func Map ¶

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

func MapTo ¶

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

func OrElse ¶ added in v2.1.0

func OrElse[A any](onLeft Kleisli[error, A]) Operator[A, A]

OrElse recovers from a Left (error) by providing an alternative computation. If the IOResult is Right, it returns the value unchanged. If the IOResult is Left, it applies the provided function to the error value, which returns a new IOResult that replaces the original.

This is useful for error recovery, fallback logic, or chaining alternative computations in IO contexts. Since IOResult is specialized for error type, the error type remains error.

Example:

// Recover from specific errors with fallback IO operations
recover := ioresult.OrElse(func(err error) ioresult.IOResult[int] {
    if err.Error() == "not found" {
        return ioresult.Right[int](0) // default value
    }
    return ioresult.Left[int](err) // propagate other errors
})
result := recover(ioresult.Left[int](errors.New("not found"))) // Right(0)
result := recover(ioresult.Right[int](42)) // Right(42) - unchanged

func Tap ¶

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

func TapEitherK ¶

func TapEitherK[A, B any](f result.Kleisli[A, B]) Operator[A, A]

func TapIOK ¶

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

func TapLeft ¶

func TapLeft[A, B any](f Kleisli[error, B]) Operator[A, A]

func WithLock ¶

func WithLock[A any](lock IO[context.CancelFunc]) Operator[A, A]

WithLock executes the provided IO operation in the scope of a lock

func AltSemigroup ¶

func AltSemigroup[A any]() Semigroup[A]

AltSemigroup is a Semigroup that tries the first item and then the second one using an alternative