IterateeT

Abstract Value Members

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

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
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]
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
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))
```
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])(implicit MO: |>=|[G, F]): IterateeT[EE, G, AA]

A generalization of >>== that allows a step function which returns its result in a different, "bigger" 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]])(implicit MO: |>=|[G, F]): G[StepT[EE, F, AA]]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def contramap[EE](f: (EE) ⇒ E)(implicit F: Monad[F]): IterateeT[EE, F, A]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
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]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
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: ~>[F, G])(implicit F: Functor[F]): IterateeT[E, G, A]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def run(implicit F: Monad[F]): F[A]

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.
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.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def up[G[_]](implicit G: Applicative[G], F: Comonad[F]): IterateeT[E, G, A]
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def zip[B](other: IterateeT[E, F, B])(implicit F: Monad[F]): IterateeT[E, F, (A, B)]

Related Docs: object IterateeT | package iteratee

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

Abstract Value Members

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

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

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]

final def ==(arg0: Any): Boolean

def >>==[EE, AA](f: (StepT[E, F, A]) ⇒ IterateeT[EE, F, AA])(implicit F: Bind[F]): IterateeT[EE, F, AA]

def advance[EE, AA, G[_]](f: (StepT[E, F, A]) ⇒ IterateeT[EE, G, AA])(implicit MO: |>=|[G, F]): IterateeT[EE, G, AA]

def advanceT[EE, AA, G[_]](f: (StepT[E, F, A]) ⇒ G[StepT[EE, F, AA]])(implicit MO: |>=|[G, F]): G[StepT[EE, F, AA]]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def contramap[EE](f: (EE) ⇒ E)(implicit F: Monad[F]): IterateeT[EE, F, A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

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]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

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: ~>[F, G])(implicit F: Functor[F]): IterateeT[E, G, A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def run(implicit F: Monad[F]): F[A]

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

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

def toString(): String

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zip[B](other: IterateeT[E, F, B])(implicit F: Monad[F]): IterateeT[E, F, (A, B)]

Inherited from AnyRef

Inherited from Any

Ungrouped