FoldM

abstract def end(s: S): M[U]

abstract def fold: (S, T) ⇒ S

abstract def start: M[S]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def &&&[V](f: FoldM[T, M, V])(implicit ap: Apply[M]): FoldM[T, M, (U, V)] { type S = (FoldM.this.S, f.S) }

fanout = zip in the Arrow terminology

def ***[V, W](f: FoldM[V, M, W])(implicit m: Bind[M]): FoldM[(T, V), M, (U, W)] { type S = (FoldM.this.S, f.S) }

parallel composition

def *>[V](f: FoldM[T, M, V])(implicit ap: Apply[M], ev: <:<[U, Unit]): FoldM[T, M, V] { type S = (FoldM.this.S, f.S) }

zip on the right with another fold only for self side-effects

def <*[V](f: SinkM[T, M])(implicit ap: Apply[M]): FoldM[T, M, U] { type S = (FoldM.this.S, f.S) }

zip with another fold only for its side effects

def <*>[V](f: FoldM[T, M, V])(implicit ap: Apply[M]): FoldM[T, M, (U, V)] { type S = (FoldM.this.S, f.S) }

zip 2 folds to return a pair of values.

def <<*[V](sink: SinkM[(S, T), M])(implicit ap: Apply[M]): FoldM[T, M, U] { type S = (FoldM.this.S, sink.S) }

alias for observeState

def <<<*[V](sink: SinkM[(S, T), M])(implicit ap: Apply[M]): FoldM[T, M, U] { type S = (FoldM.this.S, sink.S) }

alias for observeNextState

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def as[V](v: ⇒ V)(implicit m: Functor[M]): FoldM[T, M, V] { type S = FoldM.this.S }

equivalent of the as method for functors, added here for easier type inference

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def compose[V](f2: FoldM[U, M, V])(implicit m: Monad[M]): FoldM[T, M, V] { type S = M[(FoldM.this.S, f2.S)] }

pipe the output of this fold into another fold

def contramap[R](f: (R) ⇒ T)(implicit m: Functor[M]): FoldM[R, M, U] { type S = FoldM.this.S }

contramap the input values

def endWith(action: M[Unit])(implicit ap: Apply[M]): FoldM[T, M, U] { type S = FoldM.this.S }

add an effectful action at the end of the fold

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def first[V](implicit m: MonadPlus[M]): FoldM[(T, V), M, (U, V)] { type S = (FoldM.this.S, M[V]) }

first operator on a MonadPlus monad

def firstOption[V](implicit m: Bind[M], nat: ~>[scalaz.Id.Id, M]): FoldM[(T, V), M, (U, Option[V])] { type S = (FoldM.this.S, Option[V]) }

first-like operator

final def getClass(): Class[_]

def hashCode(): Int

def into[N[_]](implicit nat: ~>[M, N]): FoldM[T, N, U] { type S = FoldM.this.S }

use a natural transformation to go from context M to context N this can be used to transform a FoldM[A, Id, B] into a FoldM[A, Task, B] for example (a fold with no effects to a fold with monadic effects from the Task monad)

final def isInstanceOf[T0]: Boolean

def map[V](f: (U) ⇒ V)(implicit m: Functor[M]): FoldM[T, M, V] { type S = FoldM.this.S }

map the output value

def mapFlatten[V](f: (U) ⇒ M[V])(implicit m: Bind[M]): FoldM[T, M, V] { type S = FoldM.this.S }

flatMap the output value

final def ne(arg0: AnyRef): Boolean

def nest[F[_], R](f: (R) ⇒ F[T])(implicit df: FoldableM[F, M], monoid: Monoid[U], monad: Monad[M]): FoldM[R, M, U] { type S = M[U] }

create a fold that will run this fold repeatedly on input elements and collect all results

final def notify(): Unit

final def notifyAll(): Unit

def observe[V](f: SinkM[T, M])(implicit ap: Apply[M]): FoldM[T, M, U] { type S = (FoldM.this.S, f.S) }

alias for <*

def observeNextState[V](sink: SinkM[(S, T), M])(implicit ap: Apply[M]): FoldM[T, M, U] { type S = (FoldM.this.S, sink.S) }

observe both the input value and the next state

def observeState[V](sink: SinkM[(S, T), M])(implicit ap: Apply[M]): FoldM[T, M, U] { type S = (FoldM.this.S, sink.S) }

observe both the input value and the current state

def pipe[V](f: FoldM[U, M, V])(implicit m: Bind[M]): FoldM[T, M, V] { type S = FoldM.this.S }

map with another fold

def run[F[_]](ft: F[T])(implicit foldableM: FoldableM[F, M]): M[U]

run a FoldM with a FoldableM instance (like a List, an Iterator, a scalaz Process)

def run1(t: T)(implicit m: Bind[M]): M[U]

run over one element

def runBreak[F[_]](ft: F[T])(implicit foldableM: FoldableM[F, M]): M[U]

run a FoldM with a FoldableM instance (like a List, an Iterator, a scalaz Process) and break early if possible

def runS[F](f: F)(implicit foldableMS: FoldableMS[T, F, M]): M[U]

run a FoldM with a FoldableMS instance (like an InputStream which is specialized on producing Array[Byte])

def second[V](implicit m: MonadPlus[M]): FoldM[(V, T), M, (V, U)] { type S = (M[V], FoldM.this.S) }

second operator on a MonadPlus monad

def secondOption[V](implicit m: Bind[M], nat: ~>[scalaz.Id.Id, M]): FoldM[(V, T), M, (Option[V], U)] { type S = (Option[V], FoldM.this.S) }

second-like operator

def startWith(action: M[Unit])(implicit ap: Apply[M]): FoldM[T, M, U] { type S = FoldM.this.S }

add an effectful action at the beginning of the fold

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def void(implicit m: Functor[M]): FoldM[T, M, Unit] { type S = FoldM.this.S }

equivalent of the void method for functors, added here for easier type inference

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def zip[V](f: FoldM[T, M, V])(implicit ap: Apply[M]): FoldM[T, M, (U, V)] { type S = (FoldM.this.S, f.S) }

zip 2 folds to return a pair of values.