Type Members

1.  trait Async [F[_]] extends Effect[F]

   Annotations

   @implicitNotFound( ... )

2.  trait Chunk [+A] extends AnyRef

   Chunk represents a strict, in-memory sequence of A values.

3.  type Pipe[F[_], -I, +O] = (Stream[F, I]) ⇒ Stream[F, O]

   A pipe is a stream transformation, represented as a function from stream to stream.

   A pipe is a stream transformation, represented as a function from stream to stream.

   Pipes are typically applied with the through operation on Stream.

4.  type Pipe2[F[_], -I, -I2, +O] = (Stream[F, I], Stream[F, I2]) ⇒ Stream[F, O]

   A Pipe2 is a stream transformation that combines two strings in to a single stream, represented as a function from stream to stream.

   A Pipe2 is a stream transformation that combines two strings in to a single stream, represented as a function from stream to stream.

   Pipe2s are typically applied with the through2 operation on Stream.

5.  class Pull [+F[_], +O, +R] extends PullOps[F, O, R]
6.  trait PullDerived extends AnyRef
7.  trait Pulls [Pull[+_[_], +_, +_]] extends AnyRef

   Laws:

   Laws:

   or forms a monoid in conjunction with done:

   or(done, p) == p and or(p, done) == p. or(or(p1,p2), p3) == or(p1, or(p2,p3))

   fail is caught by onError:

   onError(fail(e))(f) == f(e)

   Pull forms a monad with pure and flatMap:

   pure >=> f == f f >=> pure == f (f >=> g) >=> h == f >=> (g >=> h) where f >=> g is defined as a => a flatMap f flatMap g

8.  sealed trait Pure [+A] extends AnyRef

   Marker trait.

   Marker trait. A Stream[Pure,O] can be safely cast to a Stream[Nothing,O], but the Stream[Pure,O] has better type inference properties in some places. See usage in Stream.pull.

9.  trait Scheduler extends AnyRef

   Provides the ability to schedule evaluation of thunks in the future.

10.  case class Scope [+F[_], +O](get: Free[[x]RF[F, x], O]) extends Product with Serializable
11.  type Sink[F[_], -I] = (Stream[F, I]) ⇒ Stream[F, Unit]

    A sink is a pipe that converts a stream to a Stream[F,Unit].

    A sink is a pipe that converts a stream to a Stream[F,Unit].

    Sinks are typically applied with the to operation on Stream.

12.  case class Step [+A, +B](head: A, tail: B) extends Product with Serializable
13.  trait Strategy extends AnyRef

    Provides a function for evaluating thunks, possibly asynchronously.

14.  abstract class Stream [+F[_], +O] extends StreamOps[F, O]

    A stream producing output of type O, which may evaluate F effects.

    A stream producing output of type O, which may evaluate F effects. If F is Nothing or fs2.Pure, the stream is pure.

15.  trait Streams [Stream[+_[_], +_]] extends AnyRef

    Laws (using infix syntax):

    Laws (using infix syntax):

    append forms a monoid in conjunction with empty:

    empty append p == p and p append empty == p. (p1 append p2) append p3 == p1 append (p2 append p3)

    And push is consistent with using append to prepend a single chunk:

    push(c)(s) == chunk(c) append s

    fail propagates until being caught by onError:

    fail(e) onError h == h(e) fail(e) append s == fail(e) fail(e) flatMap f == fail(e)

    Stream forms a monad with emit and flatMap:

    emit >=> f == f f >=> emit == f (f >=> g) >=> h == f >=> (g >=> h) where emit(a) is defined as chunk(Chunk.singleton(a)) and f >=> g is defined as a => a flatMap f flatMap g

    The monad is the list-style sequencing monad:

    (a append b) flatMap f == (a flatMap f) append (b flatMap f) empty flatMap f == empty

16.  trait Trace extends AnyRef