Stream

fs2.Stream

See theStream companion class

object Stream

Attributes

Companion: class
Source: Stream.scala
Graph
Supertypes: class Object

trait Matchable

class Any
Self type: Stream.type

Members list

Type members

Classlikes

Projection of a Stream providing various ways to compile a Stream[F,O] to a G[...].

Attributes

Source: Stream.scala
Supertypes: class Object

trait Matchable

class Any

Provides syntax for fallible streams.

Attributes

Source: Stream.scala
Supertypes: class AnyVal

trait Matchable

class Any

Provides syntax for pure pipes based on cats.Id.

Attributes

Source: Stream.scala
Supertypes: class AnyVal

trait Matchable

class Any

A view of Stream that removes the variance from the type parameters.

A view of Stream that removes the variance from the type parameters. This allows defining syntax in which the type parameters appear in contravariant (i.e. input) position, which would fail to compile if defined as instance methods.

Attributes

Source: Stream.scala
Supertypes: class AnyVal

trait Matchable

class Any

Provides syntax for streams of streams.

Attributes

Source: Stream.scala
Supertypes: class AnyVal

trait Matchable

class Any

Attributes

Source: Stream.scala
Supertypes: class AnyVal

trait Matchable

class Any

Attributes

Source: Stream.scala
Supertypes: class AnyVal

trait Matchable

class Any

Attributes

Source: Stream.scala
Supertypes: class AnyVal

trait Matchable

class Any

Attributes

Companion: object
Source: Stream.scala
Supertypes: class AnyVal

trait Matchable

class Any

Attributes

Companion: class
Source: Stream.scala
Supertypes: class Object

trait Matchable

class Any
Self type: PartiallyAppliedFromIterator.type

Provides operations on effectful pipes for syntactic convenience.

Attributes

Source: Stream.scala
Supertypes: class AnyVal

trait Matchable

class Any

Provides syntax for pure streams.

Attributes

Source: Stream.scala
Supertypes: class AnyVal

trait Matchable

class Any

Provides operations on pure pipes for syntactic convenience.

Attributes

Source: Stream.scala
Supertypes: class AnyVal

trait Matchable

class Any

Provides operations on pure pipes for syntactic convenience.

Attributes

Source: Stream.scala
Supertypes: class AnyVal

trait Matchable

class Any

When merging multiple streams, this represents step of one leg.

It is common to uncons, however unlike uncons, it keeps track of stream scope independently of the main scope of the stream.

This assures, that after each next stepLeg each Stream leg keeps its scope when interpreting.

Usual scenarios is to first invoke stream.pull.stepLeg and then consume whatever is available in leg.head. If the next step is required leg.stepLeg will yield next Leg.

Once the stream will stop to be interleaved (merged), then stream allows to return to normal stream invocation.

Attributes

Source: Stream.scala
Supertypes: class Object

trait Matchable

class Any
Self type: StepLeg[F, O]

Projection of a Stream providing various ways to get a Pull from the Stream.

Attributes

Source: Stream.scala
Supertypes: class AnyVal

trait Matchable

class Any

Value members

Concrete methods

Creates a pure stream that emits the supplied values.

Creates a pure stream that emits the supplied values. To convert to an effectful stream, use covary.

Attributes

Source: Stream.scala

Creates a single element stream that gets its value by evaluating the supplied effect.

Creates a single element stream that gets its value by evaluating the supplied effect. If the effect fails, a Left is emitted. Otherwise, a Right is emitted.

Use eval instead if a failure while evaluating the effect should fail the stream.

Attributes

Example

scala> import cats.effect.SyncIO
scala> Stream.attemptEval(SyncIO(10)).compile.toVector.unsafeRunSync()
res0: Vector[Either[Throwable,Int]] = Vector(Right(10))
scala> Stream.attemptEval(SyncIO(throw new RuntimeException)).compile.toVector.unsafeRunSync()
res1: Vector[Either[Throwable,Nothing]] = Vector(Left(java.lang.RuntimeException))

Source

Stream.scala

Light weight alternative to awakeEvery that sleeps for duration d before each pulled element.

Attributes

Source: Stream.scala

Discrete stream that every d emits elapsed duration since the start time of stream consumption.

Missed periods are dampened to a single tick.

For example: awakeEvery[IO](5 seconds) will return (approximately) 5s, 10s, 15s, and will lie dormant between emitted values.

Value parameters

period: duration between emits of the resulting stream

Attributes

Source: Stream.scala

Discrete stream that every d emits elapsed duration since the start time of stream consumption.

For example: awakeEvery[IO](5 seconds) will return (approximately) 5s, 10s, 15s, and will lie dormant between emitted values.

Value parameters

dampen: whether missed periods result in 1 emitted tick or 1 per missed period, see fixedRate for more info
period: duration between emits of the resulting stream

Attributes

Source: Stream.scala

Creates a stream that emits a resource allocated by an effect, ensuring the resource is eventually released regardless of how the stream is used.

A typical use case for bracket is working with files or network sockets. The resource effect opens a file and returns a reference to it. One can then flatMap on the returned Stream to access the file, e.g to read bytes and transform them in to some stream of elements (e.g., bytes, strings, lines, etc.). The release action then closes the file once the result Stream terminates, even in case of interruption or errors.

Value parameters

acquire: resource to acquire at start of stream
release: function which returns an effect that releases the resource

Attributes

Source: Stream.scala

Like bracket but the release action is passed an ExitCase[Throwable].

ExitCase.Canceled is passed to the release action in the event of either stream interruption or overall compiled effect cancelation.

Attributes

Source: Stream.scala

Like bracketCase but no scope is introduced, causing resource finalization to occur at the end of the current scope at the time of acquisition.

Attributes

Source: Stream.scala

Like bracketCase but the acquire action may be canceled.

Attributes

Source: Stream.scala

Like bracketFull but no scope is introduced, causing resource finalization to occur at the end of the current scope at the time of acquisition.

Attributes

Source: Stream.scala

Like bracket but no scope is introduced, causing resource finalization to occur at the end of the current scope at the time of acquisition.

Attributes

Source: Stream.scala

Creates a pure stream that emits the elements of the supplied chunk.

Attributes

Example

scala> Stream.chunk(Chunk(1,2,3)).toList
res0: List[Int] = List(1, 2, 3)

Source

Stream.scala

Creates an infinite pure stream that always returns the supplied value.

Elements are emitted in finite chunks with chunkSize number of elements.

Attributes

Example

scala> Stream.constant(0).take(5).toList
res0: List[Int] = List(0, 0, 0, 0, 0)

Source

Stream.scala

A continuous stream of the elapsed time, computed using System.nanoTime.

A continuous stream of the elapsed time, computed using System.nanoTime. Note that the actual granularity of these elapsed times depends on the OS, for instance the OS may only update the current time every ten milliseconds or so.

Attributes

Source: Stream.scala

Creates a singleton pure stream that emits the supplied value.

Attributes

Example

scala> Stream.emit(0).toList
res0: List[Int] = List(0)

Source

Stream.scala

Creates a pure stream that emits the supplied values.

Attributes

Example

scala> Stream.emits(List(1, 2, 3)).toList
res0: List[Int] = List(1, 2, 3)

Source

Stream.scala

Creates a single element stream that gets its value by evaluating the supplied effect.

Creates a single element stream that gets its value by evaluating the supplied effect. If the effect fails, the returned stream fails.

Use attemptEval instead if a failure while evaluating the effect should be emitted as a value.

Attributes

Example

scala> import cats.effect.SyncIO
scala> Stream.eval(SyncIO(10)).compile.toVector.unsafeRunSync()
res0: Vector[Int] = Vector(10)
scala> Stream.eval(SyncIO(throw new RuntimeException)).covaryOutput[Int].compile.toVector.attempt.unsafeRunSync()
res1: Either[Throwable,Vector[Int]] = Left(java.lang.RuntimeException)

Source

Stream.scala

Like evals, but lifts any Seq in the effect.

Attributes

Source: Stream.scala

Like eval but resulting chunk is flatten efficiently.

Attributes

Source: Stream.scala

Like eval, but lifts a foldable structure.

Attributes

Source: Stream.scala

A continuous stream which is true after d, 2d, 3d... elapsed duration, and false otherwise.

A continuous stream which is true after d, 2d, 3d... elapsed duration, and false otherwise. If you'd like a 'discrete' stream that will actually block until d has elapsed, use awakeEvery instead.

Attributes

Source: Stream.scala

As a result, the returned stream emits no elements and hence has output type Nothing.

Attributes

Example

scala> import cats.effect.SyncIO
scala> Stream.exec(SyncIO(println("Ran"))).covaryOutput[Int].compile.toVector.unsafeRunSync()
res0: Vector[Int] = Vector()

Source

Stream.scala

Light weight alternative to fixedRate that sleeps for duration d before each pulled element.

Behavior differs from fixedRate because the sleep between elements occurs after the next element is pulled whereas fixedRate accounts for the time it takes to process the emitted unit. This difference can roughly be thought of as the difference between scheduleWithFixedDelay and scheduleAtFixedRate in java.util.concurrent.Scheduler.

Alias for sleep(period).repeat.

Attributes

Source: Stream.scala

Discrete stream that emits a unit every d, with missed period ticks dampened.

See fixedDelay for an alternative that sleeps d between elements.

Value parameters

period: duration between emits of the resulting stream

Attributes

Source: Stream.scala

Discrete stream that emits a unit every d.

See fixedDelay for an alternative that sleeps d between elements.

This operation differs in that the time between ticks should roughly be equal to the specified period, regardless of how much time it takes to process that tick downstream. For example, with a 1 second period and a task that takes 100ms, the task would run at timestamps, 1s, 2s, 3s, etc. when using fixedRate >> task whereas it would run at timestamps 1s, 2.1s, 3.2s, etc. when using fixedDelay >> task.

In the case where task processing takes longer than a single period, 1 or more ticks are immediately emitted to "catch-up". The dampen parameter controls whether a single tick is emitted or whether one per missed period is emitted.

Value parameters

dampen: true if a single unit should be emitted when multiple periods have passed since last execution, false if a unit for each period should be emitted
period: period between emits of the resulting stream

Attributes

Source: Stream.scala

Discrete stream that emits a unit every d, with missed period ticks dampened.

Unlike fixedRate, it doesn't wait for d before emitting the first unit.

Value parameters

period: duration between emits of the resulting stream

Attributes

Source: Stream.scala

Discrete stream that emits a unit every d.

Unlike fixedRate, it doesn't wait for d before emitting the first unit.

Value parameters

dampen: true if a single unit should be emitted when multiple periods have passed since last execution, false if a unit for each period should be emitted
period: duration between emits of the resulting stream

Attributes

Source: Stream.scala

Like emits, but works for any G that has a Foldable instance.

Attributes

Source: Stream.scala

Lifts an effect that generates a stream in to a stream.

Lifts an effect that generates a stream in to a stream. Alias for eval(f).flatMap(_).

Attributes

Example

scala> import cats.effect.SyncIO
scala> Stream.force(SyncIO(Stream(1,2,3).covary[SyncIO])).compile.toVector.unsafeRunSync()
res0: Vector[Int] = Vector(1, 2, 3)

Source

Stream.scala

Converts the supplied java.lang.AutoCloseable into a singleton stream.

Attributes

Source: Stream.scala

Like fromAutoCloseable but does not introduce a scope, allowing finalization to occur after subsequent appends or other scope-preserving transformations.

Scopes can be manually introduced via Stream#scope if desired.

Attributes

Source: Stream.scala

Lifts an iterator into a Stream, shifting any interaction with the iterator to the blocking pool.

Attributes

Source: Stream.scala

Lifts an Either[Throwable, A] to an effectful Stream.

Attributes

Example

scala> import cats.effect.SyncIO, scala.util.Try
scala> Stream.fromEither[SyncIO](Right(42)).compile.toList.unsafeRunSync()
res0: List[Int] = List(42)
scala> Try(Stream.fromEither[SyncIO](Left(new RuntimeException)).compile.toList.unsafeRunSync())
res1: Try[List[Nothing]] = Failure(java.lang.RuntimeException)

Source

Stream.scala

Lifts an iterator into a Stream.

Attributes

Source: Stream.scala

Lifts an Option[A] to an effectful Stream.

Attributes

Example

scala> import cats.effect.SyncIO
scala> Stream.fromOption[SyncIO](Some(42)).compile.toList.unsafeRunSync()
res0: List[Int] = List(42)
scala> Stream.fromOption[SyncIO](None).compile.toList.unsafeRunSync()
res1: List[Nothing] = List()

Source

Stream.scala