Composes this stream with the specified stream to create a cartesian product of elements and keeps only the elements from the that stream. The that stream would be run multiple times, for every element in the this stream.

See also ZStream#zipWith and ZStream#<&> for the more common point-wise variant.

Composes this stream with the specified stream to create a cartesian product of elements and keeps only the elements from the this stream. The that stream would be run multiple times, for every element in the this stream.

See also ZStream#zipWith and ZStream#<&> for the more common point-wise variant.

Composes this stream with the specified stream to create a cartesian product of elements. The that stream would be run multiple times, for every element in the this stream.

See also ZStream#zip and ZStream#<&> for the more common point-wise variant.

Returns a stream that submerges the error case of an Either into the ZStream. Note that this combinator and either cancel each other, i.e. xs.either.absolve == xs and vice versa.

Aggregates elements of this stream using the provided sink for as long as the downstream operators on the stream are busy.

This operator divides the stream into two asynchronous "islands". Operators upstream of this operator run on one fiber, while downstream operators run on another. Whenever the downstream fiber is busy processing elements, the upstream fiber will feed elements into the sink until it signals completion.

Any sink can be used here, but see Sink.foldWeightedM and Sink.foldUntilM for sinks that cover the common usecases.

Uses aggregateAsyncWithinEither but only returns the Right results.

Aggregates elements using the provided sink until it signals completion, or the delay signalled by the schedule has passed.

This operator divides the stream into two asynchronous islands. Operators upstream of this operator run on one fiber, while downstream operators run on another. Elements will be aggregated by the sink until the downstream fiber pulls the aggregated value, or until the schedule's delay has passed.

Aggregated elements will be fed into the schedule to determine the delays between pulls.

Fan out the stream, producing a list of streams that have the same elements as this stream. The driver streamer will only ever advance of the maximumLag values before the slowest downstream stream.

Fan out the stream, producing a dynamic number of streams that have the same elements as this stream. The driver streamer will only ever advance of the maximumLag values before the slowest downstream stream.

Converts the stream to a managed list of queues. Every value will be replicated to every queue with the slowest queue being allowed to buffer maximumLag elements before the driver is backpressured. The downstream queues will be provided with elements in the same order they are returned, so the fastest queue might have seen up to (maximumLag + 1) elements more than the slowest queue if it has a lower index than the slowest queue.

Queues can unsubscribe from upstream by shutting down.

Converts the stream to a managed dynamic amount of queues. Every value will be replicated to every queue with the slowest queue being allowed to buffer maximumLag elements before the driver is backpressured. The downstream queues will be provided with elements in the same order they are returned, so the fastest queue might have seen up to (maximumLag + 1) elements more than the slowest queue if it has a lower index than the slowest queue.

Queues can unsubscribe from upstream by shutting down.

Allows a faster producer to progress independently of a slower consumer by buffering up to capacity elements in a queue.

Allows a faster producer to progress independently of a slower consumer by buffering up to capacity elements in a dropping queue.

Allows a faster producer to progress independently of a slower consumer by buffering up to capacity elements in a sliding queue.

Switches over to the stream produced by the provided function in case this one fails. Allows recovery from all causes of failure, including interruption of the stream is uninterruptible.

Chunks the stream with specified chunkSize

Combines this stream and the specified stream by repeatedly applying the function f0 to extract an element from the queues and conceptually "offer" it to the destination stream. f0 can maintain some internal state to control the combining process, with the initial state being specified by s1.

Appends another stream to this stream. The concatenated stream will first emit the elements of this stream, and then emit the elements of the other stream.

Composes this stream with the specified stream to create a cartesian product of elements. The that stream would be run multiple times, for every element in the this stream.

See also ZStream#zip and ZStream#<&> for the more common point-wise variant.

Composes this stream with the specified stream to create a cartesian product of elements with a specified function. The that stream would be run multiple times, for every element in the this stream.

See also ZStream#zip and ZStream#<&> for the more common point-wise variant.

More powerful version of ZStream#broadcast. Allows to provide a function that determines what queues should receive which elements. The decide function will receive the indices of the queues in the resulting list.

More powerful version of ZStream#distributedWith. This returns a function that will produce new queues and corresponding indices. You can also provide a function that will be executed after the final events are enqueued in all queues. Shutdown of the queues is handled by the driver. Downstream users can also shutdown queues manually. In this case the driver will continue but no longer backpressure on them.

Converts this stream to a stream that executes its effects but emits no elements. Useful for sequencing effects using streams:

(Stream(1, 2, 3).tap(i => ZIO(println(i))) ++
  Stream.fromEffect(ZIO(println("Done!"))).drain ++
  Stream(4, 5, 6).tap(i => ZIO(println(i)))).run(Sink.drain)

Drains the provided stream in the background for as long as this stream is running. If this stream ends before other, other will be interrupted. If other fails, this stream will fail with that error.

Returns a stream whose failures and successes have been lifted into an Either. The resulting stream cannot fail, because the failures have been exposed as part of the Either success case.

Maps each element of this stream to another stream and returns the non-deterministic merge of those streams, executing up to n inner streams concurrently. Up to outputBuffer elements of the produced streams may be buffered in memory by this operator.

Maps each element of this stream to another stream and returns the non-deterministic merge of those streams, executing up to n inner streams concurrently. When a new stream is created from an element of the source stream, the oldest executing stream is cancelled. Up to bufferSize elements of the produced streams may be buffered in memory by this operator.

Executes a pure fold over the stream of values. Returns a Managed value that represents the scope of the stream.

Executes an effectful fold over the stream of values. Returns a Managed value that represents the scope of the stream.

Reduces the elements in the stream to a value of type S. Stops the fold early when the condition is not fulfilled. Example:

Stream(1).forever.foldWhile(0)(_ <= 4)(_ + _) // UIO[Int] == 5

Executes an effectful fold over the stream of values. Stops the fold early when the condition is not fulfilled. Example:

Stream(1)
  .forever                                // an infinite Stream of 1's
  .fold(0)(_ <= 4)((s, a) => UIO(s + a))  // UIO[Int] == 5

Executes a pure fold over the stream of values. Returns a Managed value that represents the scope of the stream. Stops the fold early when the condition is not fulfilled.

Executes an effectful fold over the stream of values. Returns a Managed value that represents the scope of the stream. Stops the fold early when the condition is not fulfilled. Example:

Stream(1)
  .forever                                // an infinite Stream of 1's
  .fold(0)(_ <= 4)((s, a) => UIO(s + a))  // Managed[Nothing, Int]
  .use(ZIO.succeed)                       // UIO[Int] == 5

Partition a stream using a function and process each stream individually. This returns a data structure that can be used to further filter down which groups shall be processed.

After calling apply on the GroupBy object, the remaining groups will be processed in parallel and the resulting streams merged in a nondeterministic fashion.

Up to buffer elements may be buffered in any group stream before the producer is backpressured. Take care to consume from all streams in order to prevent deadlocks.

Example: Collect the first 2 words for every starting letter from a stream of words.

ZStream.fromIterable(List("hello", "world", "hi", "holla"))
 .groupByKey(_.head) { case (k, s) => s.take(2).map((k, _)) }
 .runCollect
 .map(_ == List(('h', "hello"), ('h', "hi"), ('w', "world"))

Partitions the stream with specified chunkSize

Halts the evaluation of this stream when the provided promise resolves.

If the promise completes with a failure, the stream will emit that failure.

Interleaves this stream and the specified stream deterministically by alternating pulling values from this stream and the specified stream. When one stream is exhausted all remaining values in the other stream will be pulled.

Combines this stream and the specified stream deterministically using the stream of boolean values b to control which stream to pull from next. true indicates to pull from this stream and false indicates to pull from the specified stream. Only consumes as many elements as requested by b. If either this stream or the specified stream are exhausted further requests for values from that stream will be ignored.

Interrupts the evaluation of this stream when the provided promise resolves. This combinator will also interrupt any in-progress element being pulled from upstream.

If the promise completes with a failure, the stream will emit that failure.

Enqueues elements of this stream into a queue. Stream failure and ending will also be signalled.

Maps over elements of the stream with the specified effectful function, executing up to n invocations of f concurrently. Transformed elements will be emitted in the original order.

Maps over elements of the stream with the specified effectful function, executing up to n invocations of f concurrently. The element order is not enforced by this combinator, and elements may be reordered.

Maps over elements of the stream with the specified effectful function, partitioned by p executing invocations of f concurrently. The number of concurrent invocations of f is determined by the number of different outputs of type K. Up to buffer elements may be buffered per partition. Transformed elements may be reordered but the order within a partition is maintained.

Switches to the provided stream in case this one fails with a typed error.

See also ZStream#catchAll.

Partition a stream using a predicate. The first stream will contain all element evaluated to true and the second one will contain all element evaluated to false. The faster stream may advance by up to buffer elements further than the slower one.

Split a stream by a predicate. The faster stream may advance by up to buffer elements further than the slower one.

Peels off enough material from the stream to construct an R using the provided ZSink and then returns both the R and the remainder of the ZStream in a managed resource. Like all ZManaged values, the provided remainder is valid only within the scope of ZManaged.

process is a low-level consumption method, usually used for creating combinators and constructors. For most usage, ZStream#fold, ZStream#foreach or ZStream#run should be preferred.

The contract for the returned Pull is as follows: - It must not be evaluated concurrently from multiple fibers - it is (usually) not thread-safe; - If an evaluation of the Pull is interrupted, it is not safe to evaluate it again - it is (usually) not interruption-safe; - Once the Pull has failed with a None, it is not safe to evaluate it again.

The managed Pull can be used to read from the stream until it is empty (or possibly forever, if the stream is infinite). The provided Pull is valid only inside the scope of the managed resource.

Provides the part of the environment that is not part of the ZEnv, leaving a stream that only depends on the ZEnv.

val loggingLayer: ZLayer[Any, Nothing, Logging] = ???

val stream: ZStream[ZEnv with Logging, Nothing, Unit] = ???

val stream2 = stream.provideCustomLayer(loggingLayer)

Splits the environment into two parts, providing one part using the specified layer and leaving the remainder R0.

val clockLayer: ZLayer[Any, Nothing, Clock] = ???

val stream: ZStream[Clock with Random, Nothing, Unit] = ???

val stream2 = stream.provideSomeLayer[Random](clockLayer)

Repeats the entire stream using the specified schedule. The stream will execute normally, and then repeat again according to the provided schedule.

Repeats the entire stream using the specified schedule. The stream will execute normally, and then repeat again according to the provided schedule. The schedule output will be emitted at the end of each repetition.

Repeats the entire stream using the specified schedule. The stream will execute normally, and then repeat again according to the provided schedule. The schedule output will be emitted at the end of each repetition and can be unified with the stream elements using the provided functions.

Runs the stream and collects all of its elements in a list.

Equivalent to run(Sink.collectAll[A]).

Runs the stream and emits the number of elements processed

Equivalent to run(ZSink.count)

Runs the stream purely for its effects. Any elements emitted by the stream are discarded.

Equivalent to run(Sink.drain).

Runs the stream returning the first element of the stream. Later elements will not be consumed / have effects run

Runs the stream to a sink which sums elements, provided they are Numeric.

Equivalent to run(Sink.sum[A])

Repeats each element of the stream using the provided schedule, additionally emitting the schedule's output each time a schedule is completed. Repeats are done in addition to the first execution, so that scheduleElements(Schedule.once) means "emit element and if not short circuited, repeat element once".

Repeats each element of the stream using the provided schedule, additionally emitting the schedule's output each time a schedule is completed. Repeats are done in addition to the first execution, so that scheduleElements(Schedule.once) means "emit element and if not short circuited, repeat element once".

Repeats each element of the stream using the provided schedule, additionally emitting the schedule's output each time a schedule is completed. Repeats are done in addition to the first execution, so that scheduleElements(Schedule.once) means "emit element and if not short circuited, repeat element once". Uses the provided functions to align the stream and schedule outputs on a common type.

Schedules the output of the stream using the provided schedule and emits its output at the end (if schedule is finite). Uses the provided function to align the stream and schedule outputs on the same type.

Throttles elements of type A according to the given bandwidth parameters using the token bucket algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate tokens up to a units + burst threshold. Elements that do not meet the bandwidth constraints are dropped. The weight of each element is determined by the costFn function.

Throttles elements of type A according to the given bandwidth parameters using the token bucket algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate tokens up to a units + burst threshold. Elements that do not meet the bandwidth constraints are dropped. The weight of each element is determined by the costFn effectful function.

Delays elements of type A according to the given bandwidth parameters using the token bucket algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate tokens up to a units + burst threshold. The weight of each element is determined by the costFn function.

Delays elements of type A according to the given bandwidth parameters using the token bucket algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate tokens up to a units + burst threshold. The weight of each element is determined by the costFn effectful function.

Converts this stream of bytes into a java.io.InputStream wrapped in a ZManaged. The returned input stream will only be valid within the scope of the ZManaged.

Converts this stream into a scala.collection.Iterator wrapped in a ZManaged. The returned iterator will only be valid within the scope of the ZManaged.

Converts the stream to a managed queue. After the managed queue is used, the queue will never again produce values and should be discarded.

Converts the stream into an unbounded managed queue. After the managed queue is used, the queue will never again produce values and should be discarded.

An effectual version of provide, useful when the act of provision requires an effect.

Uses the given Managed to provide the environment required to run this stream, leaving no outstanding environments.

Provides some of the environment required to run this effect, leaving the remainder R0.

Uses the given ZManaged to provide some of the environment required to run this stream, leaving the remainder R0.