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
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- Any
-
final
def
##(): Int
- Definition Classes
- Any
- def +(other: String): String
- def ->[B](y: B): (ToPull[F, O], B)
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
drop(n: Long): Pull[F, Nothing, Option[Stream[F, O]]]
Drops the first
n
elements of thisStream
, and returns the newStream
. -
def
dropThrough(p: (O) ⇒ Boolean): Pull[F, Nothing, Option[Stream[F, O]]]
Like dropWhile, but drops the first value which tests false.
-
def
dropWhile(p: (O) ⇒ Boolean): Pull[F, Nothing, 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.
Reads a single element from the input and emits it to the output. Returns the new
Handle
. -
def
echoSegment: Pull[F, O, Option[Stream[F, O]]]
Reads the next available segment from the input and emits it to the output.
Reads the next available segment from the input and emits it to the output. Returns the new
Handle
. - def ensuring(cond: (ToPull[F, O]) ⇒ Boolean, msg: ⇒ Any): ToPull[F, O]
- def ensuring(cond: (ToPull[F, O]) ⇒ Boolean): ToPull[F, O]
- def ensuring(cond: Boolean, msg: ⇒ Any): ToPull[F, O]
- def ensuring(cond: Boolean): ToPull[F, O]
-
def
fetchN(n: Int): Pull[F, Nothing, Option[Stream[F, O]]]
Like
unconsN
, but leaves the buffered input unconsumed. -
def
find(f: (O) ⇒ Boolean): Pull[F, Nothing, 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, Nothing, 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, Nothing, 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, Nothing, Boolean]
Writes a single
true
value if all input matches the predicate,false
otherwise. - def formatted(fmtstr: String): String
-
def
getClass(): Class[_ <: AnyVal]
- Definition Classes
- AnyVal → Any
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
last: Pull[F, Nothing, Option[O]]
Returns the last element of the input, if non-empty.
-
def
peek: Pull[F, Nothing, Option[(Segment[O, Unit], Stream[F, O])]]
Like uncons but does not consume the segment (i.e., the segment is pushed back).
-
def
peek1: Pull[F, Nothing, Option[(O, Stream[F, O])]]
Like uncons1 but does not consume the element (i.e., the element is pushed back).
-
def
scanSegments[S, O2](init: S)(f: (S, Segment[O, Unit]) ⇒ Segment[O2, S]): Pull[F, O2, S]
Like
scan
butf
is applied to each segment of the source stream.Like
scan
butf
is applied to each segment of the source stream. The resulting segment is emitted and the result of the segment is used in the next invocation off
. The final state value is returned as the result of the pull. -
def
scanSegmentsOpt[S, O2](init: S)(f: (S) ⇒ Option[(Segment[O, Unit]) ⇒ Segment[O2, S]]): Pull[F, O2, S]
More general version of
scanSegments
where the current state (i.e.,S
) can be inspected to determine if another segment should be pulled or if the pull should terminate.More general version of
scanSegments
where the current state (i.e.,S
) can be inspected to determine if another segment should be pulled or if the pull should terminate. Termination is signaled by returningNone
fromf
. Otherwise, a function which consumes the next segment is returned wrapped inSome
. The final state value is returned as the result of the pull. -
def
stepLeg: Pull[F, Nothing, Option[StepLeg[F, O]]]
Like
uncons
, but instead of performing normaluncons
, this will run the stream up to the first segment available.Like
uncons
, but instead of performing normaluncons
, this will run the stream up to the first segment available. Useful when zipping multiple streams (legs) into one stream. Assures that scopes are correctly held for each streamleg
indepentently of scopes from other legs.If you are not pulling from mulitple 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: Long): Pull[F, Nothing, 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
toString(): String
- Definition Classes
- Any
-
def
uncons: Pull[F, Nothing, Option[(Segment[O, Unit], Stream[F, O])]]
Waits for a segment of elements to be available in the source stream.
Waits for a segment of elements to be available in the source stream. The segment 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, Nothing, Option[(O, Stream[F, O])]]
Like uncons but waits for a single element instead of an entire segment.
-
def
unconsChunk: Pull[F, Nothing, Option[(Chunk[O], Stream[F, O])]]
Like uncons but waits for a chunk instead of an entire segment.
-
def
unconsLimit(n: Long): Pull[F, Nothing, Option[(Segment[O, Unit], Stream[F, O])]]
Like uncons, but returns a segment of no more than
n
elements.Like uncons, but returns a segment of no more than
n
elements.The returned segment has a result tuple consisting of the remaining limit (
n
minus the segment size, or 0, whichever is larger) and the remainder of the source stream.Pull.pure(None)
is returned if the end of the source stream is reached. -
def
unconsN(n: Long, allowFewer: Boolean = false): Pull[F, Nothing, Option[(Segment[O, Unit], Stream[F, O])]]
Like uncons, but returns a segment of exactly
n
elements, splitting segments as necessary.Like uncons, but returns a segment of exactly
n
elements, splitting segments as necessary.Pull.pure(None)
is returned if the end of the source stream is reached. - def →[B](y: B): (ToPull[F, O], B)