Enumeratee

object Enumeratee
Companion
class
class Object
trait Matchable
class Any

Document{}

final def filter[F[_], E](p: E => Boolean)(F: Applicative[F]): Enumeratee[F, E, E]

Drop values that do not satisfy the given predicate.

Drop values that do not satisfy the given predicate.

final def scan[F[_], O, I](init: I)(f: (I, O) => I)(F: Applicative[F]): Enumeratee[F, O, I]

An Enumeratee that folds a stream and emits intermediate results.

An Enumeratee that folds a stream and emits intermediate results.

final def scanM[F[_], O, I](init: I)(f: (I, O) => F[I])(F: Monad[F]): Enumeratee[F, O, I]

An Enumeratee that folds a stream using an effectful function while emitting intermediate results.

An Enumeratee that folds a stream using an effectful function while emitting intermediate results.

Value members

Concrete methods

final def chunks[F[_], E](F: Applicative[F]): Enumeratee[F, E, Vector[E]]

Observe the chunks in a stream.

Observe the chunks in a stream.

Note

Typically you should never rely on the underlying chunking of a stream, but in some cases it can be useful.

final def collect[F[_], O, I](pf: PartialFunction[O, I])(F: Applicative[F]): Enumeratee[F, 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.

final def cross[F[_], E1, E2](e2: Enumerator[F, E2])(F: Monad[F]): Enumeratee[F, 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.

final def drop[F[_], E](n: Long)(F: Applicative[F]): Enumeratee[F, 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.

final def dropWhile[F[_], E](p: E => Boolean)(F: Applicative[F]): Enumeratee[F, 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.

final def dropWhileM[F[_], E](p: E => F[Boolean])(F: Monad[F]): Enumeratee[F, 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.

final def filterM[F[_], E](p: E => F[Boolean])(F: Monad[F]): Enumeratee[F, E, E]

Drop values that do not satisfy a monadic predicate.

Drop values that do not satisfy a monadic predicate.

final def flatMap[F[_], O, I](f: O => Enumerator[F, I])(F: Monad[F]): Enumeratee[F, 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.

final def flatMapM[F[_], O, I](f: O => F[I])(F: Monad[F]): Enumeratee[F, 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.

final def grouped[F[_], E](n: Int)(`evidence$1`: Monad[F]): Enumeratee[F, E, Vector[E]]

Split the stream into groups of a given length.

Split the stream into groups of a given length.

final def identity[F[_], E](F: Applicative[F]): Enumeratee[F, E, E]

An identity stream transformer.

An identity stream transformer.

def injectValue[F[_], E](e: E)(F: Monad[F]): Enumeratee[F, E, E]

Inject a value into a stream.

Inject a value into a stream.

def injectValues[F[_], E](es: Seq[E])(F: Monad[F]): Enumeratee[F, E, E]

Inject zero or more values into a stream.

Inject zero or more values into a stream.

final def intersperse[F[_], E](delim: E)(F: Applicative[F]): Enumeratee[F, E, E]

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

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

final def map[F[_], O, I](f: O => I)(F: Applicative[F]): Enumeratee[F, O, I]

Map a function over a stream.

Map a function over a stream.

final def rechunk[F[_], E](size: Int)(F: Monad[F]): Enumeratee[F, E, E]

Rechunk elements in the stream into chunks of the provided size.

Rechunk elements in the stream into chunks of the provided size.

final def remainderWithResult[F[_], O, R, I](iteratee: Iteratee[F, O, R])(f: (R, O) => I)(F: Monad[F]): Enumeratee[F, O, I]

Run an iteratee and then use the provided function to combine the result with the remaining elements.

Run an iteratee and then use the provided function to combine the result with the remaining elements.

final def remainderWithResultM[F[_], O, R, I](iteratee: Iteratee[F, O, R])(f: (R, O) => F[I])(F: Monad[F]): Enumeratee[F, O, I]

Run an iteratee and then use the provided effectful function to combine the result with the remaining elements.

Run an iteratee and then use the provided effectful function to combine the result with the remaining elements.

final def sequenceI[F[_], O, I](iteratee: Iteratee[F, O, I])(F: Monad[F]): Enumeratee[F, O, I]

Apply the given Iteratee repeatedly.

Apply the given Iteratee repeatedly.

final def splitOn[F[_], E](p: E => Boolean)(F: Monad[F]): Enumeratee[F, E, Vector[E]]

Split the stream using the given predicate to identify delimiters.

Split the stream using the given predicate to identify delimiters.

final def tailRecM[F[_], A, B](f: A => Enumerator[F, Either[A, B]])(F: Monad[F]): Enumeratee[F, Either[A, B], B]
final def take[F[_], E](n: Long)(F: Applicative[F]): Enumeratee[F, 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.

final def takeWhile[F[_], E](p: E => Boolean)(F: Applicative[F]): Enumeratee[F, E, E]

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

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

final def takeWhileM[F[_], E](p: E => F[Boolean])(F: Monad[F]): Enumeratee[F, E, E]
final def uniq[F[_], E](F: Applicative[F], E: Eq[E]): Enumeratee[F, E, E]

Collapse consecutive duplicates.

Collapse consecutive duplicates.

Note

Assumes that the stream is sorted.

final def zipWithIndex[F[_], E](F: Applicative[F]): Enumeratee[F, E, (E, Long)]

Zip with the number of elements that have been encountered.

Zip with the number of elements that have been encountered.

Implicits

Implicits

final implicit def enumerateeInstance[F[_]](F: Monad[F]): Category[[_, _] =>> Enumeratee[F, _$4, _$5]] & Profunctor[[_, _] =>> Enumeratee[F, _$6, _$7]]