Iteratee

Value Members

final def !=(arg0: AnyRef): Boolean

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

Definition Classes
Any
final def ##(): Int

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

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

Definition Classes
Any
def apply[E, A](s: Step[E, A]): Iteratee[E, A]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def cogroupE[J, K, F[_]](implicit M: Monad[F], ord: (J, K) ⇒ Ordering): (EnumeratorP[J, F], EnumeratorP[K, F]) ⇒ EnumeratorP[Either3[J, (J, K), K], F]

Definition Classes
EnumeratorPFunctions
def collect[O, I, F[_]](pf: PartialFunction[O, I])(implicit arg0: Monad[F]): EnumerateeT[O, I, F]

Definition Classes
EnumerateeTFunctions
def collect[A, F[_]](implicit mon: Monoid[F[A]], pt: Applicative[F]): Iteratee[A, F[A]]

Iteratee that collects all inputs with the given monoid.
Iteratee that collects all inputs with the given monoid.

Definition Classes
IterateeFunctions
def collectT[E, F[_], A[_]](implicit M: Monad[F], mae: Monoid[A[E]], pointed: Applicative[A]): IterateeT[E, F, A[E]]

Definition Classes
IterateeTFunctions
def consume[E, F[_], A[_]](implicit arg0: Monad[F], arg1: PlusEmpty[A], arg2: Applicative[A]): IterateeT[E, F, A[E]]

An iteratee that consumes all of the input into something that is PlusEmpty and Applicative.
An iteratee that consumes all of the input into something that is PlusEmpty and Applicative.

Definition Classes
IterateeTFunctions
def cont[E, F[_], A](c: (Input[E]) ⇒ IterateeT[E, F, A])(implicit arg0: Applicative[F]): IterateeT[E, F, A]

Definition Classes
IterateeTFunctions
def cross[E1, E2, F[_]](e2: EnumeratorT[E2, F])(implicit arg0: Monad[F]): EnumerateeT[E1, (E1, E2), F]

Definition Classes
EnumerateeTFunctions
def done[E, F[_], A](d: ⇒ A, r: ⇒ Input[E])(implicit arg0: Applicative[F]): IterateeT[E, F, A]

Definition Classes
IterateeTFunctions
def doneOr[O, I, F[_], A](f: ((Input[I]) ⇒ IterateeT[I, F, A]) ⇒ IterateeT[O, F, StepT[I, F, A]])(implicit arg0: Applicative[F]): (StepT[I, F, A]) ⇒ IterateeT[O, F, StepT[I, F, A]]

Definition Classes
EnumerateeTFunctions
def drop[E, F[_]](n: Int)(implicit arg0: Applicative[F]): IterateeT[E, F, Unit]

An iteratee that skips the first n elements of the input *
An iteratee that skips the first n elements of the input *

Definition Classes
IterateeTFunctions
def dropUntil[E, F[_]](p: (E) ⇒ Boolean)(implicit arg0: Applicative[F]): IterateeT[E, F, Unit]

An iteratee that skips elements until the predicate evaluates to true.
An iteratee that skips elements until the predicate evaluates to true.

Definition Classes
IterateeTFunctions
def dropWhile[E, F[_]](p: (E) ⇒ Boolean)(implicit arg0: Applicative[F]): IterateeT[E, F, Unit]

An iteratee that skips elements while the predicate evaluates to true.
An iteratee that skips elements while the predicate evaluates to true.

Definition Classes
IterateeTFunctions
def elInput[E](e: ⇒ E): Input[E]

Definition Classes
InputFunctions
def empty[E, F[_]]: EnumeratorP[E, F]

Definition Classes
EnumeratorPFunctions
def empty[E, F[_]](implicit arg0: Applicative[F]): EnumeratorT[E, F]

Definition Classes
EnumeratorTFunctions
def emptyInput[E]: Input[E]

Definition Classes
InputFunctions
def enumArray[E, F[_]](a: Array[E], min: Int = 0, max: Option[Int] = None)(implicit arg0: Monad[F]): EnumeratorT[E, F]

An enumerator that yields the elements of the specified array from index min (inclusive) to max (exclusive)
An enumerator that yields the elements of the specified array from index min (inclusive) to max (exclusive)

Definition Classes
EnumeratorTFunctions
def enumEofT[E, F[_]](implicit arg0: Applicative[F]): EnumeratorT[E, F]

An EnumeratorT that is at EOF
An EnumeratorT that is at EOF

Definition Classes
EnumeratorTFunctions
def enumIndexedSeq[E, F[_]](a: IndexedSeq[E], min: Int = 0, max: Option[Int] = None)(implicit arg0: Monad[F]): EnumeratorT[E, F]

Definition Classes
EnumeratorTFunctions
def enumInputStream[F[_]](is: ⇒ InputStream)(implicit MO: MonadPartialOrder[F, IO]): EnumeratorT[IoExceptionOr[Byte], F]

Definition Classes
EnumeratorTFunctions
def enumIoSource[T, E, F[_]](get: () ⇒ IoExceptionOr[T], gotdata: (IoExceptionOr[T]) ⇒ Boolean, render: (T) ⇒ E)(implicit MO: MonadPartialOrder[F, IO]): EnumeratorT[IoExceptionOr[E], F]

Definition Classes
EnumeratorTFunctions
def enumIterator[E, F[_]](x: ⇒ Iterator[E])(implicit MO: MonadPartialOrder[F, IO]): EnumeratorT[E, F]

Definition Classes
EnumeratorTFunctions
def enumList[E, F[_]](xs: List[E])(implicit arg0: Monad[F]): EnumeratorT[E, F]

Definition Classes
EnumeratorTFunctions
def enumOne[E, F[_]](e: E)(implicit arg0: Applicative[F]): EnumeratorT[E, F]

Definition Classes
EnumeratorTFunctions
def enumPStream[E, F[_]](xs: Stream[E])(implicit arg0: Monad[F]): EnumeratorP[E, F]

Definition Classes
EnumeratorPFunctions
def enumReader[F[_]](r: ⇒ java.io.Reader)(implicit MO: MonadPartialOrder[F, IO]): EnumeratorT[IoExceptionOr[Char], F]

Definition Classes
EnumeratorTFunctions
def enumStream[E, F[_]](xs: Stream[E])(implicit arg0: Monad[F]): EnumeratorT[E, F]

Definition Classes
EnumeratorTFunctions
def enumerate[E](as: Stream[E]): Enumerator[E]

Definition Classes
EnumeratorTFunctions
def eofInput[E]: Input[E]

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

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

Definition Classes
AnyRef → Any
def filter[E, F[_]](p: (E) ⇒ Boolean)(implicit arg0: Monad[F]): EnumerateeT[E, E, F]

Definition Classes
EnumerateeTFunctions
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def flatMap[O, I, F[_]](f: (O) ⇒ EnumeratorT[I, F])(implicit arg0: Monad[F]): EnumerateeT[O, I, F]

Definition Classes
EnumerateeTFunctions
def fold[E, F[_], A](init: A)(f: (A, E) ⇒ A)(implicit arg0: Applicative[F]): IterateeT[E, F, A]

Definition Classes
IterateeTFunctions
def foldM[E, F[_], A](init: A)(f: (A, E) ⇒ F[A])(implicit m: Monad[F]): IterateeT[E, F, A]

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

Definition Classes
AnyRef → Any
def group[E, F[_], G[_]](n: Int)(implicit F: Applicative[F], FE: Monoid[F[E]], G: Monad[G]): EnumerateeT[E, F[E], G]

Definition Classes
EnumerateeTFunctions
def groupBy[A, F[_]](pred: (A, A) ⇒ Boolean)(implicit mon: Monoid[F[A]], pr: Applicative[F]): Iteratee[A, F[A]]

Produces chunked output split by the given predicate.
Produces chunked output split by the given predicate.

Definition Classes
IterateeFunctions
def hashCode(): Int

Definition Classes
AnyRef → Any
def head[E, F[_]](implicit arg0: Applicative[F]): IterateeT[E, F, Option[E]]

An iteratee that consumes the head of the input *
An iteratee that consumes the head of the input *

Definition Classes
IterateeTFunctions
def headDoneOr[E, F[_], B](b: ⇒ B, f: (E) ⇒ IterateeT[E, F, B])(implicit arg0: Monad[F]): IterateeT[E, F, B]

Definition Classes
IterateeTFunctions
def isEof[E, F[_]](implicit arg0: Applicative[F]): IterateeT[E, F, Boolean]

An iteratee that checks if the input is EOF.
An iteratee that checks if the input is EOF.

Definition Classes
IterateeTFunctions
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterate[E, F[_]](f: (E) ⇒ E, e: E)(implicit arg0: Monad[F]): EnumeratorT[E, F]

Definition Classes
EnumeratorTFunctions
def iteratee[E, A](s: Step[E, A]): Iteratee[E, A]

Definition Classes
IterateeFunctions
def iterateeT[E, F[_], A](s: F[StepT[E, F, A]]): IterateeT[E, F, A]

Definition Classes
IterateeTFunctions
def joinE[J, K, F[_]](implicit M: Monad[F], ord: (J, K) ⇒ Ordering): (EnumeratorP[J, F], EnumeratorP[K, F]) ⇒ EnumeratorP[(J, K), F]

Definition Classes
EnumeratorPFunctions
def length[E, F[_]](implicit arg0: Applicative[F]): IterateeT[E, F, Int]

An iteratee that counts and consumes the elements of the input
An iteratee that counts and consumes the elements of the input

Definition Classes
IterateeTFunctions
def liftE2[J, K, I, F[_]](e2t: ForallM[[β[_$1]]Enumeratee2T[J, K, I, β]]): (EnumeratorP[J, F], EnumeratorP[K, F]) ⇒ EnumeratorP[I, F]

Definition Classes
EnumeratorPFunctions
def map[O, I, F[_]](f: (O) ⇒ I)(implicit arg0: Monad[F]): EnumerateeT[O, I, F]

Applies a function to each input element and feeds the resulting outputs to the inner iteratee.
Applies a function to each input element and feeds the resulting outputs to the inner iteratee.

Definition Classes
EnumerateeTFunctions
def mergeAll[E, F[_]](enumerators: EnumeratorP[E, F]*)(implicit arg0: Order[E], arg1: Monad[F]): EnumeratorP[E, F]

Definition Classes
EnumeratorPFunctions
def mergeE[E, F[_]](implicit arg0: Order[E], arg1: Monad[F]): (EnumeratorP[E, F], EnumeratorP[E, F]) ⇒ EnumeratorP[E, F]

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def peek[E, F[_]](implicit arg0: Applicative[F]): IterateeT[E, F, Option[E]]

An iteratee that returns the first element of the input *
An iteratee that returns the first element of the input *

Definition Classes
IterateeTFunctions
def peekDoneOr[E, F[_], B](b: ⇒ B, f: (E) ⇒ IterateeT[E, F, B])(implicit arg0: Monad[F]): IterateeT[E, F, B]

Definition Classes
IterateeTFunctions
def perform[E, F[_], B](f: F[B]): EnumeratorP[E, F]

Definition Classes
EnumeratorPFunctions
def perform[E, F[_], B](f: F[B])(implicit arg0: Monad[F]): EnumeratorT[E, F]

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

Definition Classes
EnumeratorTFunctions
def putStrTo[E](os: OutputStream)(implicit s: Show[E]): IterateeT[E, IO, Unit]

An iteratee that writes input to the output stream as it comes in.
An iteratee that writes input to the output stream as it comes in. Useful for debugging.

Definition Classes
IterateeTFunctions
def repeat[E, F[_]](e: E)(implicit arg0: Monad[F]): EnumeratorT[E, F]

Definition Classes
EnumeratorTFunctions
def repeatBuild[E, A, F[_]](iter: Iteratee[E, A])(implicit mon: Monoid[F[A]], F: Applicative[F]): Iteratee[E, F[A]]

Repeats the given iteratee by appending with the given monoid.
Repeats the given iteratee by appending with the given monoid.

Definition Classes
IterateeFunctions
def reversed[A, F[_]](implicit r: Reducer[A, F[A]]): Iteratee[A, F[A]]

Iteratee that collects all inputs in reverse with the given reducer.
Iteratee that collects all inputs in reverse with the given reducer.
This iteratee is useful for F[_] with efficient cons, i.e. List.

Definition Classes
IterateeFunctions
def scont[E, F[_], A](c: (Input[E]) ⇒ IterateeT[E, F, A]): StepT[E, F, A]

Definition Classes
StepTFunctions
def sdone[E, F[_], A](d: ⇒ A, r: ⇒ Input[E]): StepT[E, F, A]

Definition Classes
StepTFunctions
def splitOn[E, F[_], G[_]](p: (E) ⇒ Boolean)(implicit F: Applicative[F], FE: Monoid[F[E]], G: Monad[G]): EnumerateeT[E, F[E], G]

Definition Classes
EnumerateeTFunctions
def sum[E, F[_]](implicit arg0: Monoid[E], arg1: Monad[F]): IterateeT[E, F, E]

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

Definition Classes
AnyRef
def take[A, F[_]](n: Int)(implicit mon: Monoid[F[A]], pt: Applicative[F]): Iteratee[A, F[A]]

Iteratee that collects the first n inputs.
Iteratee that collects the first n inputs.

Definition Classes
IterateeFunctions
def takeUntil[A, F[_]](p: (A) ⇒ Boolean)(implicit mon: Monoid[F[A]], pt: Applicative[F]): Iteratee[A, F[A]]

Iteratee that collects inputs with the given monoid until the input element passes a test.
Iteratee that collects inputs with the given monoid until the input element passes a test.

Definition Classes
IterateeFunctions
def takeWhile[A, F[_]](p: (A) ⇒ Boolean)(implicit mon: Monoid[F[A]], pt: Applicative[F]): Iteratee[A, F[A]]

Iteratee that collects inputs with the given monoid until the input element fails a test.
Iteratee that collects inputs with the given monoid until the input element fails a test.

Definition Classes
IterateeFunctions
def toString(): String

Definition Classes
AnyRef → Any
def uniq[E, F[_]](implicit arg0: Order[E], arg1: Monad[F]): EnumerateeT[E, E, F]

Uniqueness filter.
Uniqueness filter. Assumes that the input enumerator is already sorted.

Definition Classes
EnumerateeTFunctions
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 zipWithIndex[E, F[_]](implicit arg0: Monad[F]): EnumerateeT[E, (E, Long), F]

Zips with the count of elements that have been encountered.
Zips with the count of elements that have been encountered.

Definition Classes
EnumerateeTFunctions

object Iteratee extends IterateeFunctions with IterateeTFunctions with EnumeratorTFunctions with EnumeratorPFunctions with EnumerateeTFunctions with StepTFunctions with InputFunctions

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def apply[E, A](s: Step[E, A]): Iteratee[E, A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def cogroupE[J, K, F[_]](implicit M: Monad[F], ord: (J, K) ⇒ Ordering): (EnumeratorP[J, F], EnumeratorP[K, F]) ⇒ EnumeratorP[Either3[J, (J, K), K], F]

def collect[O, I, F[_]](pf: PartialFunction[O, I])(implicit arg0: Monad[F]): EnumerateeT[O, I, F]

def collect[A, F[_]](implicit mon: Monoid[F[A]], pt: Applicative[F]): Iteratee[A, F[A]]

def collectT[E, F[_], A[_]](implicit M: Monad[F], mae: Monoid[A[E]], pointed: Applicative[A]): IterateeT[E, F, A[E]]

def consume[E, F[_], A[_]](implicit arg0: Monad[F], arg1: PlusEmpty[A], arg2: Applicative[A]): IterateeT[E, F, A[E]]

def cont[E, F[_], A](c: (Input[E]) ⇒ IterateeT[E, F, A])(implicit arg0: Applicative[F]): IterateeT[E, F, A]

def cross[E1, E2, F[_]](e2: EnumeratorT[E2, F])(implicit arg0: Monad[F]): EnumerateeT[E1, (E1, E2), F]

def done[E, F[_], A](d: ⇒ A, r: ⇒ Input[E])(implicit arg0: Applicative[F]): IterateeT[E, F, A]

def doneOr[O, I, F[_], A](f: ((Input[I]) ⇒ IterateeT[I, F, A]) ⇒ IterateeT[O, F, StepT[I, F, A]])(implicit arg0: Applicative[F]): (StepT[I, F, A]) ⇒ IterateeT[O, F, StepT[I, F, A]]

def drop[E, F[_]](n: Int)(implicit arg0: Applicative[F]): IterateeT[E, F, Unit]

def dropUntil[E, F[_]](p: (E) ⇒ Boolean)(implicit arg0: Applicative[F]): IterateeT[E, F, Unit]

def dropWhile[E, F[_]](p: (E) ⇒ Boolean)(implicit arg0: Applicative[F]): IterateeT[E, F, Unit]

def elInput[E](e: ⇒ E): Input[E]

def empty[E, F[_]]: EnumeratorP[E, F]

def empty[E, F[_]](implicit arg0: Applicative[F]): EnumeratorT[E, F]

def emptyInput[E]: Input[E]

def enumArray[E, F[_]](a: Array[E], min: Int = 0, max: Option[Int] = None)(implicit arg0: Monad[F]): EnumeratorT[E, F]

def enumEofT[E, F[_]](implicit arg0: Applicative[F]): EnumeratorT[E, F]

def enumIndexedSeq[E, F[_]](a: IndexedSeq[E], min: Int = 0, max: Option[Int] = None)(implicit arg0: Monad[F]): EnumeratorT[E, F]

def enumInputStream[F[_]](is: ⇒ InputStream)(implicit MO: MonadPartialOrder[F, IO]): EnumeratorT[IoExceptionOr[Byte], F]

def enumIoSource[T, E, F[_]](get: () ⇒ IoExceptionOr[T], gotdata: (IoExceptionOr[T]) ⇒ Boolean, render: (T) ⇒ E)(implicit MO: MonadPartialOrder[F, IO]): EnumeratorT[IoExceptionOr[E], F]

def enumIterator[E, F[_]](x: ⇒ Iterator[E])(implicit MO: MonadPartialOrder[F, IO]): EnumeratorT[E, F]

def enumList[E, F[_]](xs: List[E])(implicit arg0: Monad[F]): EnumeratorT[E, F]

def enumOne[E, F[_]](e: E)(implicit arg0: Applicative[F]): EnumeratorT[E, F]

def enumPStream[E, F[_]](xs: Stream[E])(implicit arg0: Monad[F]): EnumeratorP[E, F]

def enumReader[F[_]](r: ⇒ java.io.Reader)(implicit MO: MonadPartialOrder[F, IO]): EnumeratorT[IoExceptionOr[Char], F]

def enumStream[E, F[_]](xs: Stream[E])(implicit arg0: Monad[F]): EnumeratorT[E, F]

def enumerate[E](as: Stream[E]): Enumerator[E]

def eofInput[E]: Input[E]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter[E, F[_]](p: (E) ⇒ Boolean)(implicit arg0: Monad[F]): EnumerateeT[E, E, F]

def finalize(): Unit

def flatMap[O, I, F[_]](f: (O) ⇒ EnumeratorT[I, F])(implicit arg0: Monad[F]): EnumerateeT[O, I, F]

def fold[E, F[_], A](init: A)(f: (A, E) ⇒ A)(implicit arg0: Applicative[F]): IterateeT[E, F, A]

def foldM[E, F[_], A](init: A)(f: (A, E) ⇒ F[A])(implicit m: Monad[F]): IterateeT[E, F, A]

final def getClass(): Class[_]

def group[E, F[_], G[_]](n: Int)(implicit F: Applicative[F], FE: Monoid[F[E]], G: Monad[G]): EnumerateeT[E, F[E], G]

def groupBy[A, F[_]](pred: (A, A) ⇒ Boolean)(implicit mon: Monoid[F[A]], pr: Applicative[F]): Iteratee[A, F[A]]

def hashCode(): Int

def head[E, F[_]](implicit arg0: Applicative[F]): IterateeT[E, F, Option[E]]

def headDoneOr[E, F[_], B](b: ⇒ B, f: (E) ⇒ IterateeT[E, F, B])(implicit arg0: Monad[F]): IterateeT[E, F, B]

def isEof[E, F[_]](implicit arg0: Applicative[F]): IterateeT[E, F, Boolean]

final def isInstanceOf[T0]: Boolean

def iterate[E, F[_]](f: (E) ⇒ E, e: E)(implicit arg0: Monad[F]): EnumeratorT[E, F]

def iteratee[E, A](s: Step[E, A]): Iteratee[E, A]

def iterateeT[E, F[_], A](s: F[StepT[E, F, A]]): IterateeT[E, F, A]

def joinE[J, K, F[_]](implicit M: Monad[F], ord: (J, K) ⇒ Ordering): (EnumeratorP[J, F], EnumeratorP[K, F]) ⇒ EnumeratorP[(J, K), F]

def length[E, F[_]](implicit arg0: Applicative[F]): IterateeT[E, F, Int]

def liftE2[J, K, I, F[_]](e2t: ForallM[[β[_$1]]Enumeratee2T[J, K, I, β]]): (EnumeratorP[J, F], EnumeratorP[K, F]) ⇒ EnumeratorP[I, F]

def map[O, I, F[_]](f: (O) ⇒ I)(implicit arg0: Monad[F]): EnumerateeT[O, I, F]

def mergeAll[E, F[_]](enumerators: EnumeratorP[E, F]*)(implicit arg0: Order[E], arg1: Monad[F]): EnumeratorP[E, F]

def mergeE[E, F[_]](implicit arg0: Order[E], arg1: Monad[F]): (EnumeratorP[E, F], EnumeratorP[E, F]) ⇒ EnumeratorP[E, F]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def peek[E, F[_]](implicit arg0: Applicative[F]): IterateeT[E, F, Option[E]]

def peekDoneOr[E, F[_], B](b: ⇒ B, f: (E) ⇒ IterateeT[E, F, B])(implicit arg0: Monad[F]): IterateeT[E, F, B]

def perform[E, F[_], B](f: F[B]): EnumeratorP[E, F]

def perform[E, F[_], B](f: F[B])(implicit arg0: Monad[F]): EnumeratorT[E, F]

def putStrTo[E](os: OutputStream)(implicit s: Show[E]): IterateeT[E, IO, Unit]

def repeat[E, F[_]](e: E)(implicit arg0: Monad[F]): EnumeratorT[E, F]

def repeatBuild[E, A, F[_]](iter: Iteratee[E, A])(implicit mon: Monoid[F[A]], F: Applicative[F]): Iteratee[E, F[A]]

def reversed[A, F[_]](implicit r: Reducer[A, F[A]]): Iteratee[A, F[A]]

def scont[E, F[_], A](c: (Input[E]) ⇒ IterateeT[E, F, A]): StepT[E, F, A]

def sdone[E, F[_], A](d: ⇒ A, r: ⇒ Input[E]): StepT[E, F, A]

def splitOn[E, F[_], G[_]](p: (E) ⇒ Boolean)(implicit F: Applicative[F], FE: Monoid[F[E]], G: Monad[G]): EnumerateeT[E, F[E], G]

def sum[E, F[_]](implicit arg0: Monoid[E], arg1: Monad[F]): IterateeT[E, F, E]

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