xor

Type Members

sealed class LiftToIterateePartiallyApplied[E] extends AnyRef

Definition Classes
IterateeModule
final type M[f[_]] = MonadError[f, Throwable]

Definition Classes
XorModule → Module
sealed class PerformPartiallyApplied[E] extends AnyRef

Definition Classes
EnumeratorModule

Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final val F: MonadError[[x]XorT[Eval, Throwable, x], Throwable]

Attributes
protected
Definition Classes
XorModule → Module
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def collect[O, I](pf: PartialFunction[O, I]): Enumeratee[[x]XorT[Eval, Throwable, x], O, I]

Transform values using a scala.PartialFunction and drop values that aren't matched.
Transform values using a scala.PartialFunction and drop values that aren't matched.

Definition Classes
EnumerateeModule
final def consume[E]: Iteratee[[x]XorT[Eval, Throwable, x], E, Vector[E]]

An Iteratee that collects all the elements in a stream in a vector.
An Iteratee that collects all the elements in a stream in a vector.

Definition Classes
IterateeModule
final def consumeIn[E, C[_]](implicit C: Applicative[C], M: MonoidK[C]): Iteratee[[x]XorT[Eval, Throwable, x], E, C[E]]

An Iteratee that collects all the elements in a stream in a given collection type.
An Iteratee that collects all the elements in a stream in a given collection type.

Definition Classes
IterateeModule
final def cont[E, A](ifInput: (NonEmptyVector[E]) ⇒ Iteratee[[x]XorT[Eval, Throwable, x], E, A], ifEnd: XorT[Eval, Throwable, A]): Iteratee[[x]XorT[Eval, Throwable, x], E, A]

Create an incomplete Iteratee that will use the given function to process the next input.
Create an incomplete Iteratee that will use the given function to process the next input.

Definition Classes
IterateeModule
final def cross[E1, E2](e2: Enumerator[[x]XorT[Eval, Throwable, x], E2]): Enumeratee[[x]XorT[Eval, Throwable, x], E1, (E1, E2)]

Transform a stream by taking the cross-product with the given Enumerator.
Transform a stream by taking the cross-product with the given Enumerator.

Definition Classes
EnumerateeModule
final def done[E, A](value: A, remaining: Vector[E] = Vector.empty): Iteratee[[x]XorT[Eval, Throwable, x], E, A]

Create a new completed Iteratee with the given result and leftover input.
Create a new completed Iteratee with the given result and leftover input.

Definition Classes
IterateeModule
final def drop[E](n: Long): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

An Enumeratee that drops a given number of the first values in a stream.
An Enumeratee that drops a given number of the first values in a stream.

Definition Classes
EnumerateeModule
final def dropI[E](n: Int): Iteratee[[x]XorT[Eval, Throwable, x], E, Unit]

An Iteratee that drops a given number of the values from a stream.
An Iteratee that drops a given number of the values from a stream.

Definition Classes
IterateeModule
final def dropWhile[E](p: (E) ⇒ Boolean): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

An Enumeratee that drops values from a stream as long as they satisfy the given predicate.
An Enumeratee that drops values from a stream as long as they satisfy the given predicate.

Definition Classes
EnumerateeModule
final def dropWhileI[E](p: (E) ⇒ Boolean): Iteratee[[x]XorT[Eval, Throwable, x], E, Unit]

An Iteratee that drops values from a stream as long as they satisfy the given predicate.
An Iteratee that drops values from a stream as long as they satisfy the given predicate.

Definition Classes
IterateeModule
final def dropWhileM[E](p: (E) ⇒ XorT[Eval, Throwable, Boolean]): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

An Enumeratee that drops values from a stream as long as they satisfy the given monadic predicate.
An Enumeratee that drops values from a stream as long as they satisfy the given monadic predicate.

Definition Classes
EnumerateeModule
final def empty[E]: Enumerator[[x]XorT[Eval, Throwable, x], E]

An empty enumerator.
An empty enumerator.

Definition Classes
EnumeratorModule
final def enumIndexedSeq[E](es: IndexedSeq[E], min: Int = 0, max: Int = Int.MaxValue): Enumerator[[x]XorT[Eval, Throwable, x], E]

An enumerator that produces values from a slice of an indexed sequence.
An enumerator that produces values from a slice of an indexed sequence.

Definition Classes
EnumeratorModule
final def enumList[E](es: List[E]): Enumerator[[x]XorT[Eval, Throwable, x], E]

An enumerator that produces values from a list.
An enumerator that produces values from a list.

Definition Classes
EnumeratorModule
final def enumOne[E](e: E): Enumerator[[x]XorT[Eval, Throwable, x], E]

An enumerator that produces a single value.
An enumerator that produces a single value.

Definition Classes
EnumeratorModule
final def enumStream[E](es: Stream[E]): Enumerator[[x]XorT[Eval, Throwable, x], E]

An enumerator that produces values from a stream.
An enumerator that produces values from a stream.

Definition Classes
EnumeratorModule
final def enumVector[E](es: Vector[E]): Enumerator[[x]XorT[Eval, Throwable, x], E]

An enumerator that produces values from a vector.
An enumerator that produces values from a vector.

Definition Classes
EnumeratorModule
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
final def failEnumerator[E](t: Throwable): Enumerator[[x]XorT[Eval, Throwable, x], E]

Create a failed enumerator with the given error.
Create a failed enumerator with the given error.

Definition Classes
EnumeratorErrorModule
final def failIteratee[E, A](t: Throwable): Iteratee[[x]XorT[Eval, Throwable, x], E, A]

Create a failed iteratee with the given error.
Create a failed iteratee with the given error.

Definition Classes
IterateeErrorModule
final def filter[E](p: (E) ⇒ Boolean): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

Drop values that do not satisfy the given predicate.
Drop values that do not satisfy the given predicate.

Definition Classes
EnumerateeModule
final def filterM[E](p: (E) ⇒ XorT[Eval, Throwable, Boolean]): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

Drop values that do not satisfy the given monadic predicate.
Drop values that do not satisfy the given monadic predicate.

Definition Classes
EnumerateeModule
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def flatMap[O, I](f: (O) ⇒ Enumerator[[x]XorT[Eval, Throwable, x], I]): Enumeratee[[x]XorT[Eval, Throwable, x], O, I]

Map a function returning an Enumerator over a stream and flatten the results.
Map a function returning an Enumerator over a stream and flatten the results.

Definition Classes
EnumerateeModule
final def flatMapM[O, I](f: (O) ⇒ XorT[Eval, Throwable, I]): Enumeratee[[x]XorT[Eval, Throwable, x], O, I]

Map a function returning a value in a context over a stream.
Map a function returning a value in a context over a stream.

Definition Classes
EnumerateeModule
final def fold[E, A](init: A)(f: (A, E) ⇒ A): Iteratee[[x]XorT[Eval, Throwable, x], E, A]

An Iteratee that folds a stream using an initial value and an accumulation function.
An Iteratee that folds a stream using an initial value and an accumulation function.

Definition Classes
IterateeModule
final def foldM[E, A](init: A)(f: (A, E) ⇒ XorT[Eval, Throwable, A]): Iteratee[[x]XorT[Eval, Throwable, x], E, A]

An Iteratee that folds a stream using an initial value and a monadic accumulation function.
An Iteratee that folds a stream using an initial value and a monadic accumulation function.

Definition Classes
IterateeModule
final def foldMap[E, A](f: (E) ⇒ A)(implicit A: Monoid[A]): Iteratee[[x]XorT[Eval, Throwable, x], E, A]

An Iteratee that combines values using a function to a type with a cats.Monoid instance.
An Iteratee that combines values using a function to a type with a cats.Monoid instance.

Definition Classes
IterateeModule
final def foreach[E](f: (E) ⇒ Unit): Iteratee[[x]XorT[Eval, Throwable, x], E, Unit]

An Iteratee that runs a function for its side effects.
An Iteratee that runs a function for its side effects.

Definition Classes
IterateeModule
final def foreachM[A](f: (A) ⇒ XorT[Eval, Throwable, Unit]): Iteratee[[x]XorT[Eval, Throwable, x], A, Unit]

An Iteratee that runs an effectful function for its side effects.
An Iteratee that runs an effectful function for its side effects.

Definition Classes
IterateeModule
final def generateM[E](f: XorT[Eval, Throwable, Option[E]]): Enumerator[[x]XorT[Eval, Throwable, x], E]

An enumerator that returns the result of an effectful operation until None is generated.
An enumerator that returns the result of an effectful operation until None is generated.

Definition Classes
EnumeratorModule
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
final def grouped[E](n: Int): Enumeratee[[x]XorT[Eval, Throwable, x], E, Vector[E]]

Split the stream into groups of a given length.
Split the stream into groups of a given length.

Definition Classes
EnumerateeModule
def hashCode(): Int

Definition Classes
AnyRef → Any
final def head[E]: Iteratee[[x]XorT[Eval, Throwable, x], E, Option[E]]

An Iteratee that returns the first value in a stream.
An Iteratee that returns the first value in a stream.

Definition Classes
IterateeModule
final def identity[E]: Iteratee[[x]XorT[Eval, Throwable, x], E, Unit]

An iteratee that reads nothing from a stream.
An iteratee that reads nothing from a stream.

Definition Classes
IterateeModule
final def intersperse[E](delim: E): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

Add a value delim between every two items in a stream.
Add a value delim between every two items in a stream.

Definition Classes
EnumerateeModule
final def isEnd[E]: Iteratee[[x]XorT[Eval, Throwable, x], E, Boolean]

An Iteratee that checks if the stream is at its end.
An Iteratee that checks if the stream is at its end.

Definition Classes
IterateeModule
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def iterate[E](init: E)(f: (E) ⇒ E): Enumerator[[x]XorT[Eval, Throwable, x], E]

An enumerator that iteratively performs an operation and returns the results.
An enumerator that iteratively performs an operation and returns the results.

Definition Classes
EnumeratorModule
final def iterateM[E](init: E)(f: (E) ⇒ XorT[Eval, Throwable, E]): Enumerator[[x]XorT[Eval, Throwable, x], E]

An enumerator that iteratively performs an effectful operation and returns the results.
An enumerator that iteratively performs an effectful operation and returns the results.

Definition Classes
EnumeratorModule
final def iterateUntil[E](init: E)(f: (E) ⇒ Option[E]): Enumerator[[x]XorT[Eval, Throwable, x], E]

An enumerator that iteratively performs an operation until None is produced and returns the results.
An enumerator that iteratively performs an operation until None is produced and returns the results.

Definition Classes
EnumeratorModule
final def iterateUntilM[E](init: E)(f: (E) ⇒ XorT[Eval, Throwable, Option[E]]): Enumerator[[x]XorT[Eval, Throwable, x], E]

An enumerator that iteratively performs an effectful operation until None is produced and returns the results.
An enumerator that iteratively performs an effectful operation until None is produced and returns the results.

Definition Classes
EnumeratorModule
final def length[E]: Iteratee[[x]XorT[Eval, Throwable, x], E, Long]

An Iteratee that counts the number of values in a stream.
An Iteratee that counts the number of values in a stream.

Definition Classes
IterateeModule
final def liftToEnumerator[E](fe: XorT[Eval, Throwable, E]): Enumerator[[x]XorT[Eval, Throwable, x], E]

Lift an effectful value into an enumerator.
Lift an effectful value into an enumerator.

Definition Classes
EnumeratorModule
final def liftToIteratee[E]: LiftToIterateePartiallyApplied[E]

Lift an effectful value into an iteratee.
Lift an effectful value into an iteratee.

Definition Classes
IterateeModule
final def map[O, I](f: (O) ⇒ I): Enumeratee[[x]XorT[Eval, Throwable, x], O, I]

Map a function over a stream.
Map a function over a stream.

Definition Classes
EnumerateeModule
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def peek[E]: Iteratee[[x]XorT[Eval, Throwable, x], E, Option[E]]

An Iteratee that returns the first value in a stream without consuming it.
An Iteratee that returns the first value in a stream without consuming it.

Definition Classes
IterateeModule
final def perform[E]: PerformPartiallyApplied[E]

An enumerator that forces the evaluation of an effect when it is consumed.
An enumerator that forces the evaluation of an effect when it is consumed.

Definition Classes
EnumeratorModule
final def repeat[E](e: E): Enumerator[[x]XorT[Eval, Throwable, x], E]

An enumerator that repeats the given value indefinitely.
An enumerator that repeats the given value indefinitely.

Definition Classes
EnumeratorModule
final def reversed[E]: Iteratee[[x]XorT[Eval, Throwable, x], E, List[E]]

An Iteratee that collects all inputs in reverse order.
An Iteratee that collects all inputs in reverse order.

Definition Classes
IterateeModule
final def sequenceI[O, I](iteratee: Iteratee[[x]XorT[Eval, Throwable, x], O, I]): Enumeratee[[x]XorT[Eval, Throwable, x], O, I]

Apply the given Iteratee repeatedly.
Apply the given Iteratee repeatedly.

Definition Classes
EnumerateeModule
final def splitOn[E](p: (E) ⇒ Boolean): Enumeratee[[x]XorT[Eval, Throwable, x], E, Vector[E]]

Split the stream using the given predicate to identify delimiters.
Split the stream using the given predicate to identify delimiters.

Definition Classes
EnumerateeModule
final def sum[E](implicit E: Monoid[E]): Iteratee[[x]XorT[Eval, Throwable, x], E, E]

An Iteratee that combines values using an cats.Monoid instance.
An Iteratee that combines values using an cats.Monoid instance.

Definition Classes
IterateeModule
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
object syntax

Definition Classes
Module
final def take[E](n: Long): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

An Enumeratee that takes a given number of the first values in a stream.
An Enumeratee that takes a given number of the first values in a stream.

Definition Classes
EnumerateeModule
final def takeI[E](n: Int): Iteratee[[x]XorT[Eval, Throwable, x], E, Vector[E]]

An Iteratee that returns a given number of the first values in a stream.
An Iteratee that returns a given number of the first values in a stream.

Definition Classes
IterateeModule
final def takeWhile[E](p: (E) ⇒ Boolean): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

An Enumeratee that takes values from a stream as long as they satisfy the given predicate.
An Enumeratee that takes values from a stream as long as they satisfy the given predicate.

Definition Classes
EnumerateeModule
final def takeWhileI[E](p: (E) ⇒ Boolean): Iteratee[[x]XorT[Eval, Throwable, x], E, Vector[E]]

An Iteratee that returns values from a stream as long as they satisfy the given predicate.
An Iteratee that returns values from a stream as long as they satisfy the given predicate.

Definition Classes
IterateeModule
final def takeWhileM[E](p: (E) ⇒ XorT[Eval, Throwable, Boolean]): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

An Enumeratee that takes values from a stream as long as they satisfy the given monadic predicate.
An Enumeratee that takes values from a stream as long as they satisfy the given monadic predicate.

Definition Classes
EnumerateeModule
def toString(): String

Definition Classes
AnyRef → Any
final def uniq[E](implicit E: Eq[E]): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

Collapse consecutive duplicates.
Collapse consecutive duplicates.

Definition Classes
EnumerateeModule
Note
Assumes that the stream is sorted.
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( ... )
final def zipWithIndex[E]: Enumeratee[[x]XorT[Eval, Throwable, x], E, (E, Long)]

Zip with the number of elements that have been encountered.
Zip with the number of elements that have been encountered.

Definition Classes
EnumerateeModule

Related Doc: package modules

object xor extends XorModule

Type Members

sealed class LiftToIterateePartiallyApplied[E] extends AnyRef

final type M[f[_]] = MonadError[f, Throwable]

sealed class PerformPartiallyApplied[E] extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final val F: MonadError[[x]XorT[Eval, Throwable, x], Throwable]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def collect[O, I](pf: PartialFunction[O, I]): Enumeratee[[x]XorT[Eval, Throwable, x], O, I]

final def consume[E]: Iteratee[[x]XorT[Eval, Throwable, x], E, Vector[E]]

final def consumeIn[E, C[_]](implicit C: Applicative[C], M: MonoidK[C]): Iteratee[[x]XorT[Eval, Throwable, x], E, C[E]]

final def cont[E, A](ifInput: (NonEmptyVector[E]) ⇒ Iteratee[[x]XorT[Eval, Throwable, x], E, A], ifEnd: XorT[Eval, Throwable, A]): Iteratee[[x]XorT[Eval, Throwable, x], E, A]

final def cross[E1, E2](e2: Enumerator[[x]XorT[Eval, Throwable, x], E2]): Enumeratee[[x]XorT[Eval, Throwable, x], E1, (E1, E2)]

final def done[E, A](value: A, remaining: Vector[E] = Vector.empty): Iteratee[[x]XorT[Eval, Throwable, x], E, A]

final def drop[E](n: Long): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

final def dropI[E](n: Int): Iteratee[[x]XorT[Eval, Throwable, x], E, Unit]

final def dropWhile[E](p: (E) ⇒ Boolean): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

final def dropWhileI[E](p: (E) ⇒ Boolean): Iteratee[[x]XorT[Eval, Throwable, x], E, Unit]

final def dropWhileM[E](p: (E) ⇒ XorT[Eval, Throwable, Boolean]): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

final def empty[E]: Enumerator[[x]XorT[Eval, Throwable, x], E]

final def enumIndexedSeq[E](es: IndexedSeq[E], min: Int = 0, max: Int = Int.MaxValue): Enumerator[[x]XorT[Eval, Throwable, x], E]

final def enumList[E](es: List[E]): Enumerator[[x]XorT[Eval, Throwable, x], E]

final def enumOne[E](e: E): Enumerator[[x]XorT[Eval, Throwable, x], E]

final def enumStream[E](es: Stream[E]): Enumerator[[x]XorT[Eval, Throwable, x], E]

final def enumVector[E](es: Vector[E]): Enumerator[[x]XorT[Eval, Throwable, x], E]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def failEnumerator[E](t: Throwable): Enumerator[[x]XorT[Eval, Throwable, x], E]

final def failIteratee[E, A](t: Throwable): Iteratee[[x]XorT[Eval, Throwable, x], E, A]

final def filter[E](p: (E) ⇒ Boolean): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

final def filterM[E](p: (E) ⇒ XorT[Eval, Throwable, Boolean]): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

def finalize(): Unit

final def flatMap[O, I](f: (O) ⇒ Enumerator[[x]XorT[Eval, Throwable, x], I]): Enumeratee[[x]XorT[Eval, Throwable, x], O, I]

final def flatMapM[O, I](f: (O) ⇒ XorT[Eval, Throwable, I]): Enumeratee[[x]XorT[Eval, Throwable, x], O, I]

final def fold[E, A](init: A)(f: (A, E) ⇒ A): Iteratee[[x]XorT[Eval, Throwable, x], E, A]

final def foldM[E, A](init: A)(f: (A, E) ⇒ XorT[Eval, Throwable, A]): Iteratee[[x]XorT[Eval, Throwable, x], E, A]

final def foldMap[E, A](f: (E) ⇒ A)(implicit A: Monoid[A]): Iteratee[[x]XorT[Eval, Throwable, x], E, A]

final def foreach[E](f: (E) ⇒ Unit): Iteratee[[x]XorT[Eval, Throwable, x], E, Unit]

final def foreachM[A](f: (A) ⇒ XorT[Eval, Throwable, Unit]): Iteratee[[x]XorT[Eval, Throwable, x], A, Unit]

final def generateM[E](f: XorT[Eval, Throwable, Option[E]]): Enumerator[[x]XorT[Eval, Throwable, x], E]

final def getClass(): Class[_]

final def grouped[E](n: Int): Enumeratee[[x]XorT[Eval, Throwable, x], E, Vector[E]]

def hashCode(): Int

final def head[E]: Iteratee[[x]XorT[Eval, Throwable, x], E, Option[E]]

final def identity[E]: Iteratee[[x]XorT[Eval, Throwable, x], E, Unit]

final def intersperse[E](delim: E): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

final def isEnd[E]: Iteratee[[x]XorT[Eval, Throwable, x], E, Boolean]

final def isInstanceOf[T0]: Boolean

final def iterate[E](init: E)(f: (E) ⇒ E): Enumerator[[x]XorT[Eval, Throwable, x], E]

final def iterateM[E](init: E)(f: (E) ⇒ XorT[Eval, Throwable, E]): Enumerator[[x]XorT[Eval, Throwable, x], E]

final def iterateUntil[E](init: E)(f: (E) ⇒ Option[E]): Enumerator[[x]XorT[Eval, Throwable, x], E]

final def iterateUntilM[E](init: E)(f: (E) ⇒ XorT[Eval, Throwable, Option[E]]): Enumerator[[x]XorT[Eval, Throwable, x], E]

final def length[E]: Iteratee[[x]XorT[Eval, Throwable, x], E, Long]

final def liftToEnumerator[E](fe: XorT[Eval, Throwable, E]): Enumerator[[x]XorT[Eval, Throwable, x], E]

final def liftToIteratee[E]: LiftToIterateePartiallyApplied[E]

final def map[O, I](f: (O) ⇒ I): Enumeratee[[x]XorT[Eval, Throwable, x], O, I]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def peek[E]: Iteratee[[x]XorT[Eval, Throwable, x], E, Option[E]]

final def perform[E]: PerformPartiallyApplied[E]

final def repeat[E](e: E): Enumerator[[x]XorT[Eval, Throwable, x], E]

final def reversed[E]: Iteratee[[x]XorT[Eval, Throwable, x], E, List[E]]

final def sequenceI[O, I](iteratee: Iteratee[[x]XorT[Eval, Throwable, x], O, I]): Enumeratee[[x]XorT[Eval, Throwable, x], O, I]

final def splitOn[E](p: (E) ⇒ Boolean): Enumeratee[[x]XorT[Eval, Throwable, x], E, Vector[E]]

final def sum[E](implicit E: Monoid[E]): Iteratee[[x]XorT[Eval, Throwable, x], E, E]

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

object syntax

final def take[E](n: Long): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

final def takeI[E](n: Int): Iteratee[[x]XorT[Eval, Throwable, x], E, Vector[E]]

final def takeWhile[E](p: (E) ⇒ Boolean): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

final def takeWhileI[E](p: (E) ⇒ Boolean): Iteratee[[x]XorT[Eval, Throwable, x], E, Vector[E]]

final def takeWhileM[E](p: (E) ⇒ XorT[Eval, Throwable, Boolean]): Enumeratee[[x]XorT[Eval, Throwable, x], E, E]

def toString(): String