final class ToPull[F[_], O] extends AnyVal
Projection of a Stream
providing various ways to get a Pull
from the Stream
.
- Source
- Stream.scala
- Alphabetic
- By Inheritance
- ToPull
- AnyVal
- Any
- Hide All
- Show All
- Public
- Protected
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- Any
- final def ##: Int
- Definition Classes
- Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- Any
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def drop(n: Long): Pull[F, INothing, Option[Stream[F, O]]]
Drops the first
n
elements of thisStream
, and returns the newStream
. - def dropThrough(p: (O) => Boolean): Pull[F, INothing, Option[Stream[F, O]]]
Like dropWhile, but drops the first value which tests false.
- def dropWhile(p: (O) => Boolean): Pull[F, INothing, Option[Stream[F, O]]]
Drops elements of the this stream until the predicate
p
fails, and returns the new stream.Drops elements of the this stream until the predicate
p
fails, and returns the new stream. If defined, the first element of the returned stream will failp
. - def echo: Pull[F, O, Unit]
Writes all inputs to the output of the returned
Pull
. - def echo1: Pull[F, O, Option[Stream[F, O]]]
Reads a single element from the input and emits it to the output.
- def echoChunk: Pull[F, O, Option[Stream[F, O]]]
Reads the next available chunk from the input and emits it to the output.
- def fetchN(n: Int): Pull[F, INothing, Option[Stream[F, O]]]
Like
unconsN
, but leaves the buffered input unconsumed. - def find(f: (O) => Boolean): Pull[F, INothing, Option[(O, Stream[F, O])]]
Awaits the next available element where the predicate returns true.
- def fold[O2](z: O2)(f: (O2, O) => O2): Pull[F, INothing, O2]
Folds all inputs using an initial value
z
and supplied binary operator, and writes the final result to the output of the suppliedPull
when the stream has no more values. - def fold1[O2 >: O](f: (O2, O2) => O2): Pull[F, INothing, Option[O2]]
Folds all inputs using the supplied binary operator, and writes the final result to the output of the supplied
Pull
when the stream has no more values. - def forall(p: (O) => Boolean): Pull[F, INothing, Boolean]
Writes a single
true
value if all input matches the predicate,false
otherwise. - def getClass(): Class[_ <: AnyVal]
- Definition Classes
- AnyVal → Any
- def headOrError(implicit F: RaiseThrowable[F]): Pull[F, INothing, O]
Takes the first value output by this stream and returns it in the result of a pull.
Takes the first value output by this stream and returns it in the result of a pull. If no value is output before the stream terminates, the pull is failed with a
NoSuchElementException
. If more than 1 value is output, everything beyond the first is ignored. - final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def last: Pull[F, INothing, Option[O]]
Returns the last element of the input, if non-empty.
- def lastOrError(implicit F: RaiseThrowable[F]): Pull[F, INothing, O]
Returns the last element of the input, if non-empty, otherwise fails the pull with a
NoSuchElementException
. - def peek: Pull[F, INothing, Option[(Chunk[O], Stream[F, O])]]
Like uncons but does not consume the chunk (i.e., the chunk is pushed back).
- def peek1: Pull[F, INothing, Option[(O, Stream[F, O])]]
Like uncons1 but does not consume the element (i.e., the element is pushed back).
- def scanChunks[S, O2](init: S)(f: (S, Chunk[O]) => (S, Chunk[O2])): Pull[F, O2, S]
Like
scan
butf
is applied to each chunk of the source stream.Like
scan
butf
is applied to each chunk of the source stream. The resulting chunk is emitted while the resulting state is used in the next invocation off
. The final state value is returned as the result of the pull. - def scanChunksOpt[S, O2](init: S)(f: (S) => Option[(Chunk[O]) => (S, Chunk[O2])]): Pull[F, O2, S]
More general version of
scanChunks
where the current state (i.e.,S
) can be inspected to determine if another chunk should be pulled or if the pull should terminate.More general version of
scanChunks
where the current state (i.e.,S
) can be inspected to determine if another chunk should be pulled or if the pull should terminate. Termination is signaled by returningNone
fromf
. Otherwise, a function which consumes the next chunk is returned wrapped inSome
. The final state value is returned as the result of the pull. - def stepLeg: Pull[F, INothing, Option[StepLeg[F, O]]]
Like
uncons
, but instead of performing normaluncons
, this will run the stream up to the first chunk available.Like
uncons
, but instead of performing normaluncons
, this will run the stream up to the first chunk available. Useful when zipping multiple streams (legs) into one stream. Assures that scopes are correctly held for each streamleg
independently of scopes from other legs.If you are not pulling from multiple streams, consider using
uncons
. - def take(n: Long): Pull[F, O, Option[Stream[F, O]]]
Emits the first
n
elements of the input. - def takeRight(n: Int): Pull[F, INothing, Chunk[O]]
Emits the last
n
elements of the input. - def takeThrough(p: (O) => Boolean): Pull[F, O, Option[Stream[F, O]]]
Like takeWhile, but emits the first value which tests false.
- def takeWhile(p: (O) => Boolean, takeFailure: Boolean = false): Pull[F, O, Option[Stream[F, O]]]
Emits the elements of the stream until the predicate
p
fails, and returns the remainingStream
.Emits the elements of the stream until the predicate
p
fails, and returns the remainingStream
. If non-empty, the returned stream will have a first elementi
for whichp(i)
isfalse
. - def timed[O2, R](pull: (Timed[F, O]) => Pull[F, O2, R])(implicit F: Temporal[F]): Pull[F, O2, R]
Allows expressing
Pull
computations whoseuncons
can receive a user-controlled, resettabletimeout
.Allows expressing
Pull
computations whoseuncons
can receive a user-controlled, resettabletimeout
. See Pull.Timed for more info on timeduncons
andtimeout
.As a quick example, let's write a timed pull which emits the string "late!" whenever a chunk of the stream is not emitted within 150 milliseconds:
scala> import cats.effect.IO scala> import cats.effect.unsafe.implicits.global scala> import scala.concurrent.duration._ scala> val s = (Stream("elem") ++ Stream.sleep_[IO](200.millis)).repeat.take(3) scala> s.pull | .timed { timedPull => | def go(timedPull: Pull.Timed[IO, String]): Pull[IO, String, Unit] = | timedPull.timeout(150.millis) >> // starts new timeout and stops the previous one | timedPull.uncons.flatMap { | case Some((Right(elems), next)) => Pull.output(elems) >> go(next) | case Some((Left(_), next)) => Pull.output1("late!") >> go(next) | case None => Pull.done | } | go(timedPull) | }.stream.compile.toVector.unsafeRunSync() res0: Vector[String] = Vector(elem, late!, elem, late!, elem)
For a more complex example, look at the implementation of Stream.groupWithin.
Example: - def toString(): String
- Definition Classes
- Any
- def uncons: Pull[F, INothing, Option[(Chunk[O], Stream[F, O])]]
Waits for a chunk of elements to be available in the source stream.
Waits for a chunk of elements to be available in the source stream. The non-empty' chunk of elements along with a new stream are provided as the resource of the returned pull. The new stream can be used for subsequent operations, like awaiting again. A
None
is returned as the resource of the pull upon reaching the end of the stream. - def uncons1: Pull[F, INothing, Option[(O, Stream[F, O])]]
Like uncons but waits for a single element instead of an entire chunk.
- def unconsLimit(n: Int): Pull[F, INothing, Option[(Chunk[O], Stream[F, O])]]
Like uncons, but returns a chunk of no more than
n
elements.Like uncons, but returns a chunk of no more than
n
elements.Pull.pure(None)
is returned if the end of the source stream is reached. - def unconsN(n: Int, allowFewer: Boolean = false): Pull[F, INothing, Option[(Chunk[O], Stream[F, O])]]
Like uncons, but returns a chunk of exactly
n
elements, splitting chunk as necessary.Like uncons, but returns a chunk of exactly
n
elements, splitting chunk as necessary.Pull.pure(None)
is returned if the end of the source stream is reached.