core/io.iteratee/Enumerator

Enumerator

abstract class Enumerator[F[_], E] extends Serializable
Type Params
E

The type of the enumerated data

F

The effect type constructor

Companion
object
trait Serializable
class Object
trait Matchable
class Any

Value members

Abstract methods

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

Concrete methods

final def append(e2: Enumerator[F, E])(F: FlatMap[F]): Enumerator[F, E]
final def bindM[G[_], B](f: E => G[Enumerator[F, B]])(F: Monad[F], G: Monad[G]): F[G[Enumerator[F, B]]]
final def collect[B](pf: PartialFunction[E, B])(F: Monad[F]): Enumerator[F, B]
final def cross[E2](e2: Enumerator[F, E2])(F: Monad[F]): Enumerator[F, (E, E2)]
final def drop(n: Long)(F: Monad[F]): Enumerator[F, E]
final def dropWhile(p: E => Boolean)(F: Monad[F]): Enumerator[F, E]
final def dropWhileM(p: E => F[Boolean])(F: Monad[F]): Enumerator[F, E]
final def ensure[T](action: F[Unit])(F: MonadError[F, T]): Enumerator[F, E]
final def ensureEval[T](action: Eval[F[Unit]])(F: MonadError[F, T]): Enumerator[F, E]
final def filter(p: E => Boolean)(F: Monad[F]): Enumerator[F, E]
final def filterM(p: E => F[Boolean])(F: Monad[F]): Enumerator[F, E]
final def flatMap[B](f: E => Enumerator[F, B])(F: Monad[F]): Enumerator[F, B]
final def flatMapM[B](f: E => F[B])(F: Monad[F]): Enumerator[F, B]
final def flatten[B](M: Monad[F], ev: E =:= F[B]): Enumerator[F, B]
final def grouped(n: Int)(F: Monad[F]): Enumerator[F, Vector[E]]
final def handleErrorWith[T](f: T => Enumerator[F, E])(F: MonadError[F, T]): Enumerator[F, E]
final def intersperse(delim: E)(F: Monad[F]): Enumerator[F, E]
final def into[A](iteratee: Iteratee[F, E, A])(F: FlatMap[F]): F[A]
final def intoStep[A](s: Step[F, E, A])(F: FlatMap[F]): F[A]
final def map[B](f: E => B)(F: Monad[F]): Enumerator[F, B]
final def prepend(e: E)(F: Monad[F]): Enumerator[F, E]
final def reduced[B](b: B)(f: (B, E) => B)(F: Monad[F]): Enumerator[F, B]
final def reducedM[B](b: B)(f: (B, E) => F[B])(F: Monad[F]): Enumerator[F, B]
final def scan[A](init: A)(f: (A, E) => A)(F: Monad[F]): Enumerator[F, A]
final def scanM[A](init: A)(f: (A, E) => F[A])(F: Monad[F]): Enumerator[F, A]
final def sequenceI[B](iteratee: Iteratee[F, E, B])(F: Monad[F]): Enumerator[F, B]
final def splitOn(p: E => Boolean)(F: Monad[F]): Enumerator[F, Vector[E]]
final def take(n: Long)(F: Monad[F]): Enumerator[F, E]
final def takeWhile(p: E => Boolean)(F: Monad[F]): Enumerator[F, E]
final def takeWhileM(p: E => F[Boolean])(F: Monad[F]): Enumerator[F, E]
final def through[I](enumeratee: Enumeratee[F, E, I])(M: FlatMap[F]): Enumerator[F, I]
final def toVector(F: Monad[F]): F[Vector[E]]
final def uniq(F: Monad[F], E: Eq[E]): Enumerator[F, E]
final def zipWithIndex(F: Monad[F]): Enumerator[F, (E, Long)]