object Enumeratee extends EnumerateeInstances with Serializable
- Source
- Enumeratee.scala
- Grouped
- Alphabetic
- By Inheritance
- Enumeratee
- Serializable
- Serializable
- EnumerateeInstances
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
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.
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
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.
-
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.
-
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.
-
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.
-
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.
-
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
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
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.
-
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.
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
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.
-
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.
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
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.
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
identity[F[_], E](implicit F: Applicative[F]): Enumeratee[F, E, E]
An identity stream transformer.
-
def
injectValue[F[_], E](e: E)(implicit F: Monad[F]): Enumeratee[F, E, E]
Inject a value into a stream.
-
def
injectValues[F[_], E](es: Seq[E])(implicit F: Monad[F]): Enumeratee[F, E, E]
Inject zero or more values into a stream.
-
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. -
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
map[F[_], O, I](f: (O) ⇒ I)(implicit F: Applicative[F]): Enumeratee[F, O, I]
Map a function over a stream.
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
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.
-
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.
-
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.
-
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.
-
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.
-
final
def
sequenceI[F[_], O, I](iteratee: Iteratee[F, O, I])(implicit F: Monad[F]): Enumeratee[F, O, I]
Apply the given Iteratee repeatedly.
-
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.
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
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.
-
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.
- final def takeWhileM[F[_], E](p: (E) ⇒ F[Boolean])(implicit F: Monad[F]): Enumeratee[F, E, E]
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
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.
-
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
- @native() @throws( ... )
-
final
def
zipWithIndex[F[_], E](implicit F: Applicative[F]): Enumeratee[F, E, (E, Long)]
Zip with the number of elements that have been encountered.