FoldId

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

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

abstract def start: Id[S]

final def !=(arg0: Any): Boolean

final def ##(): Int

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

fanout = zip in the Arrow terminology

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

parallel composition

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

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

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

zip with another fold only for its side effects

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

zip 2 folds to return a pair of values.

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

alias for observeNextState

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

alias for observeState

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

alias for observeWithNextState

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

alias for observeWithState

final def ==(arg0: Any): Boolean

def as[C](c: ⇒ C): Fold[Id, 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[Id, U, C]): Fold[Id, A, C] { ... /* 2 definitions in type refinement */ }

pipe the output of this fold into another fold

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

contramap the input values

def endWith(action: Id[Unit]): Fold[Id, A, U]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def into[M1[_]](implicit ev: <:<[Id[_], Id[_]], m: Monad[M1]): Fold[M1, A, U] { ... /* 2 definitions in type refinement */ }

final def isInstanceOf[T0]: Boolean

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

map the output value

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

flatMap the output value

val monad: Monad[Id]

def monadic[M1[_]](f: (S) ⇒ M1[S])(implicit ev: <:<[Id[_], Id[_]], m: Monad[M1]): Fold[M1, A, U] { ... /* 2 definitions in type refinement */ }

final def ne(arg0: AnyRef): Boolean

def nest[F[_], C](f: (C) ⇒ F[A])(implicit monoid: Monoid[U], foldable: Foldable[F]): Fold[Id, C, U] { ... /* 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[Id, A, C]): Fold[Id, A, U] { ... /* 2 definitions in type refinement */ }

alias for <*

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

observe the next state

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

observe the current state

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

observe both the input value and the next state

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

observe both the input value and the current state

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

alias for *>

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

run another fold on the end result

def run[F[_]](foldable: F[A])(implicit arg0: Foldable[F]): Id[U]

run a Fold with a Foldable instance

def run1(a: A): Id[U]

run over one element

def startWith(action: Id[Unit]): Fold[Id, A, U]

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

def toString(): String

def void: Fold[Id, 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[Id, A, C]): Fold[Id, A, (U, C)] { ... /* 2 definitions in type refinement */ }

zip 2 folds to return a pair of values.