FutureModule

abstract def ec: ExecutionContext

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final val F: MonadError[Future, Throwable]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def collect[O, I](pf: PartialFunction[O, I]): Enumeratee[Future, O, I]

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

final def consume[E]: Iteratee[Future, E, Vector[E]]

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

final def consumeIn[E, C[_]](implicit C: Applicative[C], M: MonoidK[C]): Iteratee[Future, E, C[E]]

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

final def cont[E, A](ifInput: (NonEmptyList[E]) ⇒ Iteratee[Future, E, A], ifEnd: Future[A]): Iteratee[Future, E, A]

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

final def cross[E1, E2](e2: Enumerator[Future, E2]): Enumeratee[Future, E1, (E1, E2)]

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

final def done[E, A](value: A, remaining: List[E] = Nil): Iteratee[Future, E, A]

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

final def drop[E](n: Long): Enumeratee[Future, E, E]

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

final def dropI[E](n: Int): Iteratee[Future, E, Unit]

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

final def dropWhile[E](p: (E) ⇒ Boolean): Enumeratee[Future, E, E]

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

final def dropWhileI[E](p: (E) ⇒ Boolean): Iteratee[Future, E, Unit]

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

final def dropWhileM[E](p: (E) ⇒ Future[Boolean]): Enumeratee[Future, E, E]

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

final def empty[E]: Enumerator[Future, E]

An empty enumerator.

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

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

final def enumList[E](es: List[E]): Enumerator[Future, E]

An enumerator that produces values from a list.

final def enumOne[E](e: E): Enumerator[Future, E]

An enumerator that produces a single value.

final def enumStream[E](es: Stream[E]): Enumerator[Future, E]

An enumerator that produces values from a stream.

final def enumVector[E](es: Vector[E]): Enumerator[Future, E]

An enumerator that produces values from a vector.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def failEnumerator[E](t: Throwable): Enumerator[Future, E]

Create a failed enumerator with the given error.

final def failIteratee[E, A](t: Throwable): Iteratee[Future, E, A]

Create a failed iteratee with the given error.

final def filter[E](p: (E) ⇒ Boolean): Enumeratee[Future, E, E]

Drop values that do not satisfy the given predicate.

final def filterM[E](p: (E) ⇒ Future[Boolean]): Enumeratee[Future, E, E]

Drop values that do not satisfy the given monadic predicate.

def finalize(): Unit

final def flatMap[O, I](f: (O) ⇒ Enumerator[Future, I]): Enumeratee[Future, O, I]

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

final def flatMapM[O, I](f: (O) ⇒ Future[I]): Enumeratee[Future, O, I]

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

final def fold[E, A](init: A)(f: (A, E) ⇒ A): Iteratee[Future, E, A]

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

final def foldM[E, A](init: A)(f: (A, E) ⇒ Future[A]): Iteratee[Future, E, A]

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

final def foldMap[E, A](f: (E) ⇒ A)(implicit A: Monoid[A]): Iteratee[Future, E, A]

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

final def foldMapOption[E, A](f: (E) ⇒ A)(implicit A: Semigroup[A]): Iteratee[Future, E, Option[A]]

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

final def foreach[E](f: (E) ⇒ Unit): Iteratee[Future, E, Unit]

An Iteratee that runs a function for its side effects.

final def foreachM[A](f: (A) ⇒ Future[Unit]): Iteratee[Future, A, Unit]

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

final def generateM[E](f: Future[Option[E]]): Enumerator[Future, E]

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

final def getClass(): Class[_]

final def grouped[E](n: Int): Enumeratee[Future, E, Vector[E]]

Split the stream into groups of a given length.

def hashCode(): Int

final def head[E]: Iteratee[Future, E, Option[E]]

An Iteratee that returns the first value in a stream.

final def identity[E]: Iteratee[Future, E, Unit]

An iteratee that reads nothing from a stream.

final def intersperse[E](delim: E): Enumeratee[Future, E, E]

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

final def isEnd[E]: Iteratee[Future, E, Boolean]

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

final def isInstanceOf[T0]: Boolean

final def iterate[E](init: E)(f: (E) ⇒ E): Enumerator[Future, E]

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

final def iterateM[E](init: E)(f: (E) ⇒ Future[E]): Enumerator[Future, E]

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

final def iterateUntil[E](init: E)(f: (E) ⇒ Option[E]): Enumerator[Future, E]

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

final def iterateUntilM[E](init: E)(f: (E) ⇒ Future[Option[E]]): Enumerator[Future, E]

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

final def length[E]: Iteratee[Future, E, Long]

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

final def liftToEnumerator[E](fe: Future[E]): Enumerator[Future, E]

Lift an effectful value into an enumerator.

final def liftToIteratee[E]: LiftToIterateePartiallyApplied[E]

Lift an effectful value into an iteratee.

final def map[O, I](f: (O) ⇒ I): Enumeratee[Future, O, I]

Map a function over a stream.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def peek[E]: Iteratee[Future, E, Option[E]]

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

final def perform[E]: PerformPartiallyApplied[E]

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

final def repeat[E](e: E): Enumerator[Future, E]

An enumerator that repeats the given value indefinitely.

final def reversed[E]: Iteratee[Future, E, List[E]]

An Iteratee that collects all inputs in reverse order.

final def sequenceI[O, I](iteratee: Iteratee[Future, O, I]): Enumeratee[Future, O, I]

Apply the given Iteratee repeatedly.

final def splitOn[E](p: (E) ⇒ Boolean): Enumeratee[Future, E, Vector[E]]

Split the stream using the given predicate to identify delimiters.

final def sum[E](implicit E: Monoid[E]): Iteratee[Future, E, E]

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

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

object syntax

final def take[E](n: Long): Enumeratee[Future, E, E]

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

final def takeI[E](n: Int): Iteratee[Future, E, Vector[E]]

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

final def takeWhile[E](p: (E) ⇒ Boolean): Enumeratee[Future, E, E]

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

final def takeWhileI[E](p: (E) ⇒ Boolean): Iteratee[Future, E, Vector[E]]

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

final def takeWhileM[E](p: (E) ⇒ Future[Boolean]): Enumeratee[Future, E, E]

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

def toString(): String

final def uniq[E](implicit E: Eq[E]): Enumeratee[Future, E, E]

Collapse consecutive duplicates.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def zipWithIndex[E]: Enumeratee[Future, E, (E, Long)]

Zip with the number of elements that have been encountered.