fs2-core/fs2.concurrent

fs2.concurrent

package fs2.concurrent

Type members

Classlikes

object Balance
Provides mechanisms for balancing the distribution of chunks across multiple streams.
object Broadcast
Provides mechanisms for broadcast distribution of elements to multiple streams.
trait Dequeue[F <: ([_$6] =>> Any), A]
Provides the ability to dequeue chunks of elements from a Queue as streams.
trait Dequeue1[F <: ([_$3] =>> Any), A]
Provides the ability to dequeue individual elements from a Queue.
trait DequeueChunk1[F <: ([_$4] =>> Any), G <: ([_$5] =>> Any), A]
Provides the ability to dequeue individual chunks from a Queue.
trait Enqueue[F <: ([_$1] =>> Any), A]
Provides the ability to enqueue elements to a Queue.
@deprecated("Use cats.effect.std.Queue instead", "3.0.0")
trait InspectableQueue[F <: ([_$46] =>> Any), A] extends Queue[F, A]
Extension of Queue that allows peeking and inspection of the current size.
Companion
object
@deprecated("Use cats.effect.std.Queue instead", "3.0.0")
object InspectableQueue
Companion
class
trait NoneTerminatedQueue[F <: ([_$13] =>> Any), A] extends Enqueue[F, Option[A]] with Dequeue1[F, Option[A]] with DequeueChunk1[F, [A] =>> Option[A], A] with Dequeue[F, A]
Like Queue, but allows allows signalling of no further enqueues by enqueueing None.
Optimizes dequeue to minimum possible boxing.
@deprecated("Use cats.effect.std.Queue instead", "3.0.0")
trait Queue[F <: ([_$7] =>> Any), A] extends Enqueue[F, A] with Dequeue1[F, A] with DequeueChunk1[F, Id, A] with Dequeue[F, A]
A queue of elements. Operations are all nonblocking in their
implementations, but may be 'semantically' blocking. For instance,
a queue may have a bound on its size, in which case enqueuing may
block (be delayed asynchronously) until there is an offsetting dequeue.
Companion
object
@deprecated("Use cats.effect.std.Queue instead", "3.0.0")
object Queue
Companion
class
trait Signal[F <: ([_$1] =>> Any), A]
Pure holder of a single value of type A that can be read in the effect F.
Companion
object
object Signal extends SignalInstances
Companion
class
abstract class SignallingRef[F <: ([_$6] =>> Any), A] extends Ref[F, A] with Signal[F, A]
Pure holder of a single value of type A that can be both read
and updated in the effect F.
The update methods have the same semantics as Ref, as well as
propagating changes to discrete (with a last-update-wins policy
in case of very fast updates).
The access method differs slightly from Ref in that the update
function, in the presence of discrete, can return false and
need looping even without any other writers.
Companion
object
object SignallingRef
Companion
class
abstract class Topic[F <: ([_$1] =>> Any), A]
Asynchronous Topic.
Topic allows you to distribute A published by arbitrary number of publishers to arbitrary number of subscribers.
Topic has built-in back-pressure support implemented as maximum bound (maxQueued) that a subscriber is allowed to enqueue.
Once that bound is hit, publishing may semantically block until the lagging subscriber consumes some of its queued elements.
Additionally the subscriber has possibility to terminate whenever size of enqueued elements is over certain size
by using subscribeSize.
Companion
object
object Topic
Companion
class