IterateeT

sealed abstract
class IterateeT[E, F[_], A]

A data sink.

Represents a value of type F[StepT[E, F, A]]

Type Params
A

The type of the calculated result

E

The type of the input data (mnemonic: '''E'''lement type)

F

The type constructor representing an effect. The type constructor scalaz.Id is used to model pure computations, and is fixed as such in the type alias scalaz.iteratee.Iteratee.

See also
Companion
object
class Object
trait Matchable
class Any

Value members

Abstract methods

def value: F[StepT[E, F, A]]

Concrete methods

def %=[O](e: EnumerateeT[O, E, F])(implicit m: Monad[F]): IterateeT[O, F, A]
def &=(e: EnumeratorT[E, F])(implicit F: Bind[F]): IterateeT[E, F, A]
def >>==[EE, AA](f: StepT[E, F, A] => IterateeT[EE, F, AA])(implicit F: Bind[F]): IterateeT[EE, F, AA]

Combine this Iteratee with an Enumerator-like function.

Combine this Iteratee with an Enumerator-like function.

Often used in combination with the implicit views such as enumStream and enumIterator, for example:

head[Unit, Int, Id] >>== Stream.continually(1) // enumStream(Stream.continually(1))
Value Params
f

An Enumerator-like function. If the type parameters EE and BB are chosen to be E and B respectively, the type of f is equivalent to EnumeratorT[E, F, A].

def advance[EE, AA, G[_]](f: StepT[E, F, A] => IterateeT[EE, G, AA], trans: NaturalTransformation[F, G])(implicit G: Bind[G]): IterateeT[EE, G, AA]

A generalization of >>== that allows a step function which returns its result in a different, "bigger" monad. The monad for G must perform all the effects of F as part of its evaluation; in the trivial case, of course F and G will have the same monad.

A generalization of >>== that allows a step function which returns its result in a different, "bigger" monad. The monad for G must perform all the effects of F as part of its evaluation; in the trivial case, of course F and G will have the same monad.

def advanceT[EE, AA, G[_]](f: StepT[E, F, A] => G[StepT[EE, F, AA]], trans: NaturalTransformation[F, G])(implicit G: Bind[G]): G[StepT[EE, F, AA]]
def contramap[EE](f: EE => E)(implicit F: Monad[F]): IterateeT[EE, F, A]
def flatMap[B](f: A => IterateeT[E, F, B])(implicit F: Monad[F]): IterateeT[E, F, B]
def foldT[Z](cont: Input[E] => IterateeT[E, F, A] => F[Z], done: (=> A, => Input[E]) => F[Z])(implicit F: Bind[F]): F[Z]
def joinI[I, B](implicit outer: IterateeT[E, F, A] === IterateeT[E, F, StepT[I, F, B]], M: Monad[F]): IterateeT[E, F, B]
def map[B](f: A => B)(implicit F: Monad[F]): IterateeT[E, F, B]
def mapI[G[_]](f: NaturalTransformation[F, G])(implicit F: Functor[F]): IterateeT[E, G, A]
def run(implicit F: Monad[F]): F[A]

Run this iteratee

Run this iteratee

def sequenceI(implicit m: Monad[F]): EnumerateeT[E, A, F]

Feeds input elements to this iteratee until it is done, feeds the produced value to the inner iteratee. Then this iteratee will start over, looping until the inner iteratee is done.

Feeds input elements to this iteratee until it is done, feeds the produced value to the inner iteratee. Then this iteratee will start over, looping until the inner iteratee is done.

def up[G[_]](implicit G: Applicative[G], F: Comonad[F]): IterateeT[E, G, A]
def zip[B](other: IterateeT[E, F, B])(implicit F: Monad[F]): IterateeT[E, F, (A, B)]