fs2-core/fs2/Pull$

Pull

object Pull extends PullLowPriority
Companion
class
trait PullLowPriority
class Object
trait Matchable
class Any

Type members

Classlikes

final class StreamPullOps[F <: ([_$3] =>> Any), O](self: Pull[F, O, Unit]) extends AnyVal
final class PartiallyAppliedFromEither[F <: ([_$16] =>> Any)]
trait Timed[F <: ([_$18] =>> Any), O]
An abstraction for writing Pull computations that can timeout
while reading from a Stream.
A Pull.Timed is not created or intepreted directly, but by
calling Stream.ToPull.timed.
{{{
yourStream.pull.timed(tp => ...).stream
}}}
The argument to timed is a Pull.Timed[F, O] => Pull[F, O2, R]
function, which describes the pulling logic and is often recursive,
with shape:
{{{
def go(timedPull: Pull.Timed[F, A] ): Pull[F, B, Unit] =
timedPull.uncons.flatMap {
case Some((Right(chunk), next)) => doSomething >> go(next)
case Some((Left(_), next)) => doSomethingElse >> go(next)
case None => Pull.done
}
}}}
Where doSomething and doSomethingElse are Pull computations
such as Pull.output, in addition to Pull.Timed.timeout.
See below for detailed descriptions of timeout and uncons, and
look at the Stream.ToPull.timed scaladoc for an example of usage.
final class IdOps[O](self: Pull[Id, O, Unit]) extends AnyVal
Provides syntax for pure pulls based on cats.Id.

Value members

Methods

def pure[F <: ([_$4] =>> Any), R](r: R): Pull[F, INothing, R]
Creates an pull that performs no effects, emits no outputs,
and terminates successfully with the supplied value as its result.
def raiseError[F <: ([_$5] =>> Any)](err: Throwable)(evidence$1: RaiseThrowable[F]): Pull[F, INothing, INothing]
Lifts a throwable error into an atomic pull that emits no outputs and
fails with the given error, without any result.
The F type must be explicitly provided (e.g., via raiseError[IO]
or raiseError[Fallible]).
def eval[F <: ([_$6] =>> Any), R](fr: F[R]): Pull[F, INothing, R]
Creates a pull that evaluates the supplied effect fr, emits no
outputs, and terminates with the result of the effect.
If the fr effect fails with an error, the new pull fails with that error.
def output1[F >: ([x] =>> Pure[x]) <: ([x] =>> Any), O](o: O): Pull[F, O, Unit]
Lifts the given output value O into a pull that performs no
effects, emits that single output in a singleton chunk, and always
terminates successfully with a unit result.
Note: using singleton chunks is not efficient. If possible,
use the chunk-based output method instead.
def output[F >: ([x] =>> Pure[x]) <: ([x] =>> Any), O](os: Chunk[O]): Pull[Pure, O, Unit]
Creates a pull that emits the elements of the given chunk.
The new pull performs no effects and terminates successfully with a unit result.
def attemptEval[F <: ([_$9] =>> Any), R](fr: F[R]): Pull[F, INothing, Either[Throwable, R]]
Like eval but if the effectful value fails, the exception is returned
in a Left instead of failing the pull.
def bracketCase[F <: ([_$10] =>> Any), O, A, B](acquire: Pull[F, O, A], use: A => Pull[F, O, B], release: (A, ExitCase) => Pull[F, O, Unit]): Pull[F, O, B]
def extendScopeTo[F <: ([_$11] =>> Any), O](s: Stream[F, O])(F: MonadError[F, Throwable]): Pull[F, INothing, Stream[F, O]]
Extends the scope of the currently open resources to the specified stream,
preventing them from being finalized until after s completes execution,
even if the returned pull is converted to a stream, compiled, and
evaluated before s is compiled and evaluated.
def loop[F <: ([_$14] =>> Any), O, R](f: R => Pull[F, O, Option[R]]): R => Pull[F, O, Unit]
Repeatedly uses the output of the pull as input for the next step of the
pull. Halts when a step terminates with None or Pull.raiseError.
def fromEither[F <: ([x] =>> Any)]: PartiallyAppliedFromEither[F]
Lifts an Either[Throwable, A] to an effectful Pull[F, A, Unit] .
Example
{{{
scala> import cats.effect.SyncIO, scala.util.Try
scala> Pull.fromEitherSyncIO.stream.compile.toList.unsafeRunSync()
res0: List[Int] = List(42)
scala> Try(Pull.fromEither[SyncIO] (Left(new RuntimeException)).stream.compile.toList.unsafeRunSync())
res1: Try[List[INothing] ] = Failure(java.lang.RuntimeException)
}}}
def suspend[F >: ([x] =>> Pure[x]) <: ([x] =>> Any), O, R](p: => Pull[F, O, R]): Pull[F, O, R]
Returns a pull that evaluates the supplied by-name each time the pull is
used, allowing use of a mutable value in pull computations.

Fields

val done: Pull[Pure, INothing, Unit]
A pull that performs no effects, emits no outputs, and
always terminates successfully with a unit result.

Implicits

Implicits

implicit def syncInstance[F <: ([_$19] =>> Any), O](evidence$2: Sync[F]): Sync[[_$20] =>> Pull[F, O, _$20]]
Sync instance for Pull.
implicit def functionKInstance[F <: ([_$21] =>> Any)]: FunctionK[F, [_$22] =>> Pull[F, INothing, _$22]]
FunctionK instance for F ~> Pull[F, INothing, *]
Example
{{{
scala> import cats.Id
scala> Pull.functionKInstanceId.flatMap(Pull.output1).stream.compile.toList
res0: cats.Id[List[Int] ] = List(42)
}}}

Inherited implicits

implicit def monadErrorInstance[F <: ([_$79] =>> Any), O]: MonadError[[_$80] =>> Pull[F, O, _$80], Throwable]
Inhertied from
PullLowPriority