Fold

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

abstract def fold: (S, A) ⇒ M[S]

implicit abstract def monad: Monad[M]

abstract def start: M[S]

final def !=(arg0: Any): Boolean

final def ##(): Int

def &&&[C](f: Fold[M, A, C]): Fold[M, A, (B, C)] { ... /* 2 definitions in type refinement */ }

fanout = zip in the Arrow terminology

def ***[V, W](f: Fold[M, V, W]): Fold[M, (A, V), (B, W)] { ... /* 2 definitions in type refinement */ }

parallel composition

def *>[C](f: Fold[M, A, C]): Fold[M, A, C]

zip with another fold, running this one only for its side effects

def <*[C](f: Fold[M, A, C]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }

zip with another fold only for its side effects

def <*>[C](f: Fold[M, A, C]): Fold[M, A, (B, C)] { ... /* 2 definitions in type refinement */ }

zip 2 folds to return a pair of values.

def <+*(sink: Sink[M, S]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }

alias for observeNextState

def <-*(sink: Sink[M, S]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }

alias for observeState

def <<+*(sink: Sink[M, (A, S)]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }

alias for observeWithNextState

def <<-*(sink: Sink[M, (A, S)]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }

alias for observeWithState

final def ==(arg0: Any): Boolean

def as[C](c: ⇒ C): Fold[M, A, C] { ... /* 2 definitions in type refinement */ }

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

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def compose[C](f2: Fold[M, B, C]): Fold[M, A, C] { ... /* 2 definitions in type refinement */ }

pipe the output of this fold into another fold

def contraFlatMap[C](f: (C) ⇒ M[A]): Fold[M, C, B] { ... /* 2 definitions in type refinement */ }

contra flatmap the input values

def contramap[C](f: (C) ⇒ A): Fold[M, C, B] { ... /* 2 definitions in type refinement */ }

contramap the input values

def contramapFilter[C](f: (C) ⇒ Option[A]): Fold[M, C, B] { ... /* 2 definitions in type refinement */ }

combine contramap and preFilter

def endWith(action: M[Unit]): Fold[M, A, B]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flattenOption: Fold[M, Option[A], B] { ... /* 2 definitions in type refinement */ }

fold only the non empty values

final def getClass(): Class[_]

def hashCode(): Int

def into[M1[_]](implicit nat: ~>[M, M1], m: Monad[M1]): Fold[M1, A, B] { ... /* 2 definitions in type refinement */ }

final def isInstanceOf[T0]: Boolean

def map[C](f: (B) ⇒ C): Fold[M, A, C] { ... /* 2 definitions in type refinement */ }

map the output value

def mapFlatten[C](f: (B) ⇒ M[C]): Fold[M, A, C] { ... /* 2 definitions in type refinement */ }

flatMap the output value

def monadic[M1[_]](implicit nat: ~>[M, M1], m: Monad[M1]): Fold[M1, A, B] { ... /* 2 definitions in type refinement */ }

final def ne(arg0: AnyRef): Boolean

def nest[F[_], C](f: (C) ⇒ F[A])(implicit monoid: Monoid[B], foldable: Foldable[F]): Fold[M, C, B] { ... /* 2 definitions in type refinement */ }

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[C](f: Fold[M, A, C]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }

alias for <*

def observeNextState(sink: Sink[M, S]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }

observe the next state

def observeState(sink: Sink[M, S]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }

observe the current state

def observeWithNextState(sink: Sink[M, (A, S)]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }

observe both the input value and the next state

def observeWithState(sink: Sink[M, (A, S)]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }

observe both the input value and the current state

def observedBy[C](f: Fold[M, A, C]): Fold[M, A, C]

alias for *>

def pipe[C](f: Fold[M, B, C]): Fold[M, A, C] { ... /* 2 definitions in type refinement */ }

run another fold on the end result

def preCollect[C](pf: PartialFunction[C, A]): Fold[M, C, B] { ... /* 2 definitions in type refinement */ }

similar to contramapFilter, but use a partial function

def preFilter(f: (A) ⇒ Boolean): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }

filter the input values

def run[F[_]](foldable: F[A])(implicit arg0: Foldable[F]): M[B]

run a Fold with a Foldable instance

def run1(a: A): M[B]

run over one element

def startWith(action: M[Unit]): Fold[M, A, B]

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

def toString(): String

def void: Fold[M, A, Unit] { ... /* 2 definitions in type refinement */ }

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[C](f: Fold[M, A, C]): Fold[M, A, (B, C)] { ... /* 2 definitions in type refinement */ }

zip 2 folds to return a pair of values.