Align instance for Stream. * @example

scala> import cats.syntax.all._
scala> Stream(1,2,3).align(Stream("A","B","C","D","E")).toList
res0: List[cats.data.Ior[Int,String]] = List(Both(1,A), Both(2,B), Both(3,C), Right(D), Right(E))

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

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.

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.

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.

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.

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

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

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

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.

Creates a singleton pure stream that emits the supplied value.

Creates a pure stream that emits the supplied values.

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.

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.

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

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(d).repeat.

Discrete stream that emits a unit every d.

See fixedDelay for an alternative that sleeps d between elements.

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

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

Lifts an Option[A] to an effectful Stream.

FunctionK instance for F ~> Stream[F, *]

FunctorFilter instance for Stream.

Gets the current scope, allowing manual leasing or interruption. This is a low-level method and generally should not be used by user code.

An infinite Stream that repeatedly applies a given function to a start value. start is the first value emitted, followed by f(start), then f(f(start)), and so on.

Like iterate, but takes an effectful function for producing the next state. start is the first value emitted.

MonadError instance for Stream.

Creates a stream that, when run, fails with the supplied exception.

The F type must be explicitly provided (e.g., via raiseError[IO] or raiseError[Fallible]).

Creates a random stream of integers using the supplied seed. Returns a pure stream, as the pseudo random number generator is deterministic based on the supplied seed.

Lazily produce the range [start, stopExclusive). If you want to produce the sequence in one chunk, instead of lazily, use emits(start until stopExclusive).

Lazily produce a sequence of nonoverlapping ranges, where each range contains size integers, assuming the upper bound is exclusive. Example: ranges(0, 1000, 10) results in the pairs (0, 10), (10, 20), (20, 30) ... (990, 1000)

Note: The last emitted range may be truncated at stopExclusive. For instance, ranges(0,5,4) results in (0,4), (4,5).

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

Scopes can be manually introduced via scope if desired.

Retries fo on failure, returning a singleton stream with the result of fo as soon as it succeeds.

Alias for sleep(d).drain. Often used in conjunction with ++ (i.e., sleep_(..) ++ s) as a more performant version of sleep(..) >> s.

Returns a stream that evaluates the supplied by-name each time the stream is used, allowing use of a mutable value in stream computations.

Note: it's generally easier to reason about such computations using effectful values. That is, allocate the mutable value in an effect and then use Stream.eval(fa).flatMap { a => ??? }.

Creates a stream by successively applying f until a None is returned, emitting each output O and using each output S as input to the next invocation of f.

Like unfold but each invocation of f provides a chunk of output.

Creates a stream by successively applying f to a S, emitting each output O and using each output S as input to the next invocation of f if it is Some, or terminating on None

Creates a stream that evaluates the supplied fa for its effect, discarding the output value. As a result, the returned stream emits no elements and hence has output type INothing.

Alias for eval(fa).drain.