Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

itereither

package

Go to main page

Versions in this module

v2

v2.3.14

May 25, 2026

v2.3.13

May 25, 2026

v2.3.12

May 25, 2026

v2.3.11

May 22, 2026

v2.3.10

May 22, 2026

v2.3.9

May 22, 2026

v2.3.8

May 20, 2026

v2.3.7

May 20, 2026

v2.3.6

May 20, 2026

v2.3.5

May 15, 2026

v2.3.4

May 15, 2026

v2.3.3

May 12, 2026

v2.3.2

May 12, 2026

v2.3.1

May 12, 2026

Changes in this version

type Operator

+ func Filter[E, A any](pred func(A) bool) Operator[E, A, A]

type SeqEither

+ func MonadFilter[E, A any](as SeqEither[E, A], pred Predicate[A]) SeqEither[E, A]

v2.3.0

May 12, 2026

Changes in this version

+ type IO = io.IO[T]

+ type IOEither = ioeither.IOEither[E, T]

+ func Collect[E, T any](fa SeqEither[E, T]) IOEither[E, []T]

+ type Lazy = lazy.Lazy[T]

type SeqEither

+ func FromIOEither[E, A any](mr IOEither[E, A]) SeqEither[E, A]

+ func FromIO[E, A any](mr IO[A]) SeqEither[E, A]

+ func FromLazy[E, A any](mr Lazy[A]) SeqEither[E, A]

+ func StopOnLeft[E, T any](s SeqEither[E, T]) SeqEither[E, T]

+ func TakeUntilLeft[E, T any](s SeqEither[E, T]) SeqEither[E, T]

v2.2.84

May 12, 2026

v2.2.83

May 11, 2026

Changes in this version

+ func BiMap[E1, E2, A, B any](f func(E1) E2, g func(A) B) func(SeqEither[E1, A]) SeqEither[E2, B]

+ func ChainLeft[EA, EB, A any](f Kleisli[EB, EA, A]) func(SeqEither[EA, A]) SeqEither[EB, A]

+ func ChainOptionK[A, B, E any](onNone func() E) func(func(A) O.Option[B]) Operator[E, A, B]

+ func Fold[E, A, B any](onLeft iter.Kleisli[E, B], onRight iter.Kleisli[A, B]) func(SeqEither[E, A]) Seq[B]

+ func FromOption[A, E any](onNone func() E) func(o O.Option[A]) SeqEither[E, A]

+ func Functor[E, A, B any]() functor.Functor[A, B, SeqEither[E, A], SeqEither[E, B]]

+ func GetOrElseOf[E, A any](onLeft func(E) A) func(SeqEither[E, A]) Seq[A]

+ func GetOrElse[E, A any](onLeft iter.Kleisli[E, A]) func(SeqEither[E, A]) Seq[A]

+ func MapLeft[A, E1, E2 any](f func(E1) E2) func(SeqEither[E1, A]) SeqEither[E2, A]

+ func Monad[E, A, B any]() monad.Monad[A, B, SeqEither[E, A], SeqEither[E, B], SeqEither[E, func(A) B]]

+ func Pointed[E, A any]() pointed.Pointed[A, SeqEither[E, A]]

+ func Reduce[E, A, B any](f func(B, A) B, initial B) func(SeqEither[E, A]) Either[E, B]

+ func TraverseParTuple1[E error, F1 ~func(A1) SeqEither[E, T1], T1, A1 any](f1 F1) func(tuple.Tuple1[A1]) SeqEither[E, tuple.Tuple1[T1]]

+ func TraverseSeqTuple1[E error, F1 ~func(A1) SeqEither[E, T1], T1, A1 any](f1 F1) func(tuple.Tuple1[A1]) SeqEither[E, tuple.Tuple1[T1]]

+ func TraverseTuple10[E error, F1 ~func(A1) SeqEither[E, T1], F2 ~func(A2) SeqEither[E, T2], ...](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) ...

+ func TraverseTuple1[E error, F1 ~func(A1) SeqEither[E, T1], T1, A1 any](f1 F1) func(tuple.Tuple1[A1]) SeqEither[E, tuple.Tuple1[T1]]

+ func TraverseTuple2[E error, F1 ~func(A1) SeqEither[E, T1], F2 ~func(A2) SeqEither[E, T2], ...](f1 F1, f2 F2) func(tuple.Tuple2[A1, A2]) SeqEither[E, tuple.Tuple2[T1, T2]]

+ func TraverseTuple3[E error, F1 ~func(A1) SeqEither[E, T1], F2 ~func(A2) SeqEither[E, T2], ...](f1 F1, f2 F2, f3 F3) func(tuple.Tuple3[A1, A2, A3]) SeqEither[E, tuple.Tuple3[T1, T2, T3]]

+ func TraverseTuple4[E error, F1 ~func(A1) SeqEither[E, T1], F2 ~func(A2) SeqEither[E, T2], ...](f1 F1, f2 F2, f3 F3, f4 F4) func(tuple.Tuple4[A1, A2, A3, A4]) SeqEither[E, tuple.Tuple4[T1, T2, T3, T4]]

+ func TraverseTuple5[E error, F1 ~func(A1) SeqEither[E, T1], F2 ~func(A2) SeqEither[E, T2], ...](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) ...

+ func TraverseTuple6[E error, F1 ~func(A1) SeqEither[E, T1], F2 ~func(A2) SeqEither[E, T2], ...](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) ...

+ func TraverseTuple7[E error, F1 ~func(A1) SeqEither[E, T1], F2 ~func(A2) SeqEither[E, T2], ...](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) ...

+ func TraverseTuple8[E error, F1 ~func(A1) SeqEither[E, T1], F2 ~func(A2) SeqEither[E, T2], ...](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) ...

+ func TraverseTuple9[E error, F1 ~func(A1) SeqEither[E, T1], F2 ~func(A2) SeqEither[E, T2], ...](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) ...

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

+ func MonadReduce[E, A, B any](fa SeqEither[E, A], f func(B, A) B, initial B) Either[E, B]

+ type Kleisli = R.Reader[A, SeqEither[E, B]]

+ func OrElse[E1, E2, A any](onLeft Kleisli[E2, E1, A]) Kleisli[E2, SeqEither[E1, A], A]

+ func TraverseArrayWithIndex[E, A, B any](f func(int, A) SeqEither[E, B]) Kleisli[E, []A, []B]

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

+ func TraverseRecordWithIndex[K comparable, E, A, B any](f func(K, A) SeqEither[E, B]) Kleisli[E, map[K]A, map[K]B]

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

+ func WithResource[A, E, R, ANY any](onCreate SeqEither[E, R], onRelease Kleisli[E, R, ANY]) Kleisli[E, Kleisli[E, R, A], A]

+ type Monoid = monoid.Monoid[SeqEither[E, A]]

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

+ type Operator = Kleisli[E, SeqEither[E, A], B]

+ func Alt[E, A any](second lazy.Lazy[SeqEither[E, A]]) Operator[E, A, A]

+ func ApFirst[A, E, B any](second SeqEither[E, B]) Operator[E, A, A]

+ func ApSL[E, S, T any](lens L.Lens[S, T], fa SeqEither[E, T]) Operator[E, S, S]

+ func ApS[E, S1, S2, T any](setter func(T) func(S1) S2, fa SeqEither[E, T]) Operator[E, S1, S2]

+ func ApSecond[A, E, B any](second SeqEither[E, B]) Operator[E, A, B]

+ func Ap[B, E, A any](ma SeqEither[E, A]) Operator[E, func(A) B, B]

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

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

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

+ func ChainEitherK[E, A, B any](f either.Kleisli[E, A, B]) Operator[E, A, B]

+ func ChainFirstEitherK[A, E, B any](f either.Kleisli[E, A, B]) Operator[E, A, A]

+ func ChainFirstLeft[A, EA, EB, B any](f Kleisli[EB, EA, B]) Operator[EA, A, A]

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

+ func ChainSeqK[E, A, B any](f iter.Kleisli[A, B]) Operator[E, A, B]

+ func ChainToSeq[E, A, B any](fb Seq[B]) Operator[E, A, B]

+ func ChainTo[A, E, B any](fb SeqEither[E, B]) Operator[E, A, B]

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

+ func FilterOrElse[E, A any](pred Predicate[A], onFalse func(A) E) Operator[E, A, A]

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

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

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

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

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

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

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

+ func MergeMapFirstEitherK[A, E, B any](f either.Kleisli[E, A, B]) Operator[E, A, A]

+ func MergeMapSeqK[E, A, B any](f iter.Kleisli[A, B]) Operator[E, A, B]

+ func MergeMap[E, A, B any](f Kleisli[E, A, B]) Operator[E, A, B]

+ func TapEitherK[A, E, B any](f either.Kleisli[E, A, B]) Operator[E, A, A]

+ func TapLeft[A, EA, EB, B any](f Kleisli[EB, EA, B]) Operator[EA, A, A]

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

+ type Predicate = predicate.Predicate[A]

+ type Semigroup = semigroup.Semigroup[SeqEither[E, A]]

+ func AltSemigroup[E, A any]() Semigroup[E, A]

+ type Seq = iter.Seq[A]

+ func MonadFold[E, A, B any](ma SeqEither[E, A], onLeft iter.Kleisli[E, B], onRight iter.Kleisli[A, B]) Seq[B]

+ type SeqEither = Seq[Either[E, A]]

+ func Bracket[E, A, B, ANY any](acquire SeqEither[E, A], use Kleisli[E, A, B], ...) SeqEither[E, B]

+ func Do[E, S any](empty S) SeqEither[E, S]

+ func Flatten[E, A any](mma SeqEither[E, SeqEither[E, A]]) SeqEither[E, A]

+ func FromEither[E, A any](e Either[E, A]) SeqEither[E, A]

+ func FromSeq[E, A any](mr Seq[A]) SeqEither[E, A]

+ func LeftSeq[A, E any](ml Seq[E]) SeqEither[E, A]

+ func Left[A, E any](l E) SeqEither[E, A]

+ func MonadAlt[E, A any](first SeqEither[E, A], second lazy.Lazy[SeqEither[E, A]]) SeqEither[E, A]

+ func MonadApFirst[A, E, B any](first SeqEither[E, A], second SeqEither[E, B]) SeqEither[E, A]

+ func MonadApSecond[A, E, B any](first SeqEither[E, A], second SeqEither[E, B]) SeqEither[E, B]

+ func MonadAp[B, E, A any](mab SeqEither[E, func(A) B], ma SeqEither[E, A]) SeqEither[E, B]

+ func MonadBiMap[E1, E2, A, B any](fa SeqEither[E1, A], f func(E1) E2, g func(A) B) SeqEither[E2, B]

+ func MonadChainEitherK[E, A, B any](ma SeqEither[E, A], f either.Kleisli[E, A, B]) SeqEither[E, B]

+ func MonadChainFirstEitherK[A, E, B any](ma SeqEither[E, A], f either.Kleisli[E, A, B]) SeqEither[E, A]

+ func MonadChainFirstLeft[A, EA, EB, B any](ma SeqEither[EA, A], f Kleisli[EB, EA, B]) SeqEither[EA, A]

+ func MonadChainFirst[E, A, B any](ma SeqEither[E, A], f Kleisli[E, A, B]) SeqEither[E, A]

+ func MonadChainLeft[EA, EB, A any](fa SeqEither[EA, A], f Kleisli[EB, EA, A]) SeqEither[EB, A]

+ func MonadChainSeqK[E, A, B any](ma SeqEither[E, A], f iter.Kleisli[A, B]) SeqEither[E, B]

+ func MonadChainToSeq[E, A, B any](fa SeqEither[E, A], fb Seq[B]) SeqEither[E, B]

+ func MonadChainTo[A, E, B any](fa SeqEither[E, A], fb SeqEither[E, B]) SeqEither[E, B]

+ func MonadChain[E, A, B any](fa SeqEither[E, A], f Kleisli[E, A, B]) SeqEither[E, B]

+ func MonadFlap[E, B, A any](fab SeqEither[E, func(A) B], a A) SeqEither[E, B]

+ func MonadMapLeft[A, E1, E2 any](fa SeqEither[E1, A], f func(E1) E2) SeqEither[E2, A]

+ func MonadMapTo[E, A, B any](fa SeqEither[E, A], b B) SeqEither[E, B]

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

+ func MonadMergeMapFirstEitherK[A, E, B any](ma SeqEither[E, A], f either.Kleisli[E, A, B]) SeqEither[E, A]

+ func MonadMergeMapSeqK[E, A, B any](ma SeqEither[E, A], f iter.Kleisli[A, B]) SeqEither[E, B]

+ func MonadMergeMap[E, A, B any](fa SeqEither[E, A], f Kleisli[E, A, B]) SeqEither[E, B]

+ func MonadOf[E, A any](r A) SeqEither[E, A]

+ func MonadTapEitherK[A, E, B any](ma SeqEither[E, A], f either.Kleisli[E, A, B]) SeqEither[E, A]

+ func MonadTapLeft[A, EA, EB, B any](ma SeqEither[EA, A], f Kleisli[EB, EA, B]) SeqEither[EA, A]

+ func MonadTap[E, A, B any](ma SeqEither[E, A], f Kleisli[E, A, B]) SeqEither[E, A]

+ func Of[E, A any](r A) SeqEither[E, A]

+ func RightSeq[E, A any](mr Seq[A]) SeqEither[E, A]

+ func Right[E, A any](r A) SeqEither[E, A]

+ func SequenceArray[E, A any](ma []SeqEither[E, A]) SeqEither[E, []A]

+ func SequenceParT1[E, T1 any](t1 SeqEither[E, T1]) SeqEither[E, tuple.Tuple1[T1]]

+ func SequenceParTuple1[E, T1 any](t tuple.Tuple1[SeqEither[E, T1]]) SeqEither[E, tuple.Tuple1[T1]]

+ func SequenceRecord[K comparable, E, A any](ma map[K]SeqEither[E, A]) SeqEither[E, map[K]A]

+ func SequenceSeqT1[E, T1 any](t1 SeqEither[E, T1]) SeqEither[E, tuple.Tuple1[T1]]

+ func SequenceSeqTuple1[E, T1 any](t tuple.Tuple1[SeqEither[E, T1]]) SeqEither[E, tuple.Tuple1[T1]]

+ func SequenceT10[E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t1 SeqEither[E, T1], t2 SeqEither[E, T2], t3 SeqEither[E, T3], ...) SeqEither[E, tuple.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]

+ func SequenceT1[E, T1 any](t1 SeqEither[E, T1]) SeqEither[E, tuple.Tuple1[T1]]

+ func SequenceT2[E, T1, T2 any](t1 SeqEither[E, T1], t2 SeqEither[E, T2]) SeqEither[E, tuple.Tuple2[T1, T2]]

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

+ func SequenceT4[E, T1, T2, T3, T4 any](t1 SeqEither[E, T1], t2 SeqEither[E, T2], t3 SeqEither[E, T3], ...) SeqEither[E, tuple.Tuple4[T1, T2, T3, T4]]

+ func SequenceT5[E, T1, T2, T3, T4, T5 any](t1 SeqEither[E, T1], t2 SeqEither[E, T2], t3 SeqEither[E, T3], ...) SeqEither[E, tuple.Tuple5[T1, T2, T3, T4, T5]]

+ func SequenceT6[E, T1, T2, T3, T4, T5, T6 any](t1 SeqEither[E, T1], t2 SeqEither[E, T2], t3 SeqEither[E, T3], ...) SeqEither[E, tuple.Tuple6[T1, T2, T3, T4, T5, T6]]

+ func SequenceT7[E, T1, T2, T3, T4, T5, T6, T7 any](t1 SeqEither[E, T1], t2 SeqEither[E, T2], t3 SeqEither[E, T3], ...) SeqEither[E, tuple.Tuple7[T1, T2, T3, T4, T5, T6, T7]]

+ func SequenceT8[E, T1, T2, T3, T4, T5, T6, T7, T8 any](t1 SeqEither[E, T1], t2 SeqEither[E, T2], t3 SeqEither[E, T3], ...) SeqEither[E, tuple.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]

+ func SequenceT9[E, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t1 SeqEither[E, T1], t2 SeqEither[E, T2], t3 SeqEither[E, T3], ...) SeqEither[E, tuple.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]

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

+ func SequenceTuple1[E, T1 any](t tuple.Tuple1[SeqEither[E, T1]]) SeqEither[E, tuple.Tuple1[T1]]

+ func SequenceTuple2[E, T1, T2 any](t tuple.Tuple2[SeqEither[E, T1], SeqEither[E, T2]]) SeqEither[E, tuple.Tuple2[T1, T2]]

+ func SequenceTuple3[E, T1, T2, T3 any](t tuple.Tuple3[SeqEither[E, T1], SeqEither[E, T2], SeqEither[E, T3]]) SeqEither[E, tuple.Tuple3[T1, T2, T3]]

+ func SequenceTuple4[E, T1, T2, T3, T4 any](...) SeqEither[E, tuple.Tuple4[T1, T2, T3, T4]]

+ func SequenceTuple5[E, T1, T2, T3, T4, T5 any](...) SeqEither[E, tuple.Tuple5[T1, T2, T3, T4, T5]]

+ func SequenceTuple6[E, T1, T2, T3, T4, T5, T6 any](...) SeqEither[E, tuple.Tuple6[T1, T2, T3, T4, T5, T6]]

+ func SequenceTuple7[E, T1, T2, T3, T4, T5, T6, T7 any](...) SeqEither[E, tuple.Tuple7[T1, T2, T3, T4, T5, T6, T7]]

+ func SequenceTuple8[E, T1, T2, T3, T4, T5, T6, T7, T8 any](...) SeqEither[E, tuple.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]

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

+ func Swap[E, A any](val SeqEither[E, A]) SeqEither[A, E]

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

+ type Void = function.Void