io.iteratee

Enumeratee

object Enumeratee extends EnumerateeInstances with Serializable

Linear Supertypes
Serializable, Serializable, EnumerateeInstances, AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Enumeratee
  2. Serializable
  3. Serializable
  4. EnumerateeInstances
  5. AnyRef
  6. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: AnyRef): Boolean

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

    Definition Classes
    Any
  3. final def ##(): Int

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

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

    Definition Classes
    Any
  6. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  7. final def chunks[F[_], E](implicit 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.

  8. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  9. final def collect[F[_], O, I](pf: PartialFunction[O, I])(implicit F: Applicative[F]): Enumeratee[F, O, I]

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

  10. final def cross[F[_], E1, E2](e2: Enumerator[F, E2])(implicit F: Monad[F]): Enumeratee[F, E1, (E1, E2)]

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

  11. final def drop[F[_], E](n: Long)(implicit F: Applicative[F]): Enumeratee[F, E, E]

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

  12. final def dropWhile[F[_], E](p: (E) ⇒ Boolean)(implicit F: Applicative[F]): Enumeratee[F, E, E]

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

  13. final def dropWhileM[F[_], E](p: (E) ⇒ F[Boolean])(implicit F: Monad[F]): Enumeratee[F, E, E]

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

  14. implicit final def enumerateeInstance[F[_]](implicit F: Monad[F]): Category[[β$0$, γ$1$]Enumeratee[F, β$0$, γ$1$]] with Profunctor[[β$2$, γ$3$]Enumeratee[F, β$2$, γ$3$]]

    Definition Classes
    EnumerateeInstances
  15. final def eq(arg0: AnyRef): Boolean

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

    Definition Classes
    AnyRef → Any
  17. final def filter[F[_], E](p: (E) ⇒ Boolean)(implicit F: Applicative[F]): Enumeratee[F, E, E]

    Drop values that do not satisfy the given predicate.

  18. final def filterM[F[_], E](p: (E) ⇒ F[Boolean])(implicit F: Monad[F]): Enumeratee[F, E, E]

    Drop values that do not satisfy a monadic predicate.

  19. def finalize(): Unit

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

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

  21. final def flatMapM[F[_], O, I](f: (O) ⇒ F[I])(implicit F: Monad[F]): Enumeratee[F, O, I]

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

  22. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any
  23. final def grouped[F[_], E](n: Int)(implicit arg0: Monad[F]): Enumeratee[F, E, Vector[E]]

    Split the stream into groups of a given length.

  24. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  25. final def identity[F[_], E](implicit F: Applicative[F]): Enumeratee[F, E, E]

    An identity stream transformer.

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

    Inject a value into a stream.

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

    Inject zero or more values into a stream.

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

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

  29. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  30. final def map[F[_], O, I](f: (O) ⇒ I)(implicit F: Applicative[F]): Enumeratee[F, O, I]

    Map a function over a stream.

  31. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  32. final def notify(): Unit

    Definition Classes
    AnyRef
  33. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  34. final def rechunk[F[_], E](size: Int)(implicit F: Monad[F]): Enumeratee[F, E, E]

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

  35. final def remainderWithResult[F[_], O, R, I](iteratee: Iteratee[F, O, R])(f: (R, O) ⇒ I)(implicit F: Monad[F]): Enumeratee[F, O, I]

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

  36. final def remainderWithResultM[F[_], O, R, I](iteratee: Iteratee[F, O, R])(f: (R, O) ⇒ F[I])(implicit 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.

  37. final def scan[F[_], O, I](init: I)(f: (I, O) ⇒ I)(implicit F: Applicative[F]): Enumeratee[F, O, I]

    An Enumeratee that folds a stream and emits intermediate results.

  38. final def scanM[F[_], O, I](init: I)(f: (I, O) ⇒ F[I])(implicit F: Monad[F]): Enumeratee[F, O, I]

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

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

    Apply the given Iteratee repeatedly.

  40. final def splitOn[F[_], E](p: (E) ⇒ Boolean)(implicit F: Monad[F]): Enumeratee[F, E, Vector[E]]

    Split the stream using the given predicate to identify delimiters.

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

    Definition Classes
    AnyRef
  42. final def take[F[_], E](n: Long)(implicit F: Applicative[F]): Enumeratee[F, E, E]

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

  43. final def takeWhile[F[_], E](p: (E) ⇒ Boolean)(implicit F: Applicative[F]): Enumeratee[F, E, E]

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

  44. final def takeWhileM[F[_], E](p: (E) ⇒ F[Boolean])(implicit F: Monad[F]): Enumeratee[F, E, E]

  45. def toString(): String

    Definition Classes
    AnyRef → Any
  46. final def uniq[F[_], E](implicit F: Applicative[F], E: Eq[E]): Enumeratee[F, E, E]

    Collapse consecutive duplicates.

    Collapse consecutive duplicates.

    Note

    Assumes that the stream is sorted.

  47. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  48. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  49. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  50. final def zipWithIndex[F[_], E](implicit F: Applicative[F]): Enumeratee[F, E, (E, Long)]

    Zip with the number of elements that have been encountered.

Inherited from Serializable

Inherited from Serializable

Inherited from EnumerateeInstances

Inherited from AnyRef

Inherited from Any

Collection

Enumeratees

Ungrouped