Queue

@deprecated("Use cats.effect.std.Queue instead", "3.0.0") object Queue
Companion
class
class Object
trait Matchable
class Any

Type members

Classlikes

object Strategy

Value members

Methods

def unbounded[F <: ([_$23] =>> Any), A](evidence$1: Concurrent[F]): F[Queue[F, A]]
Creates a queue with no size bound.
def fairUnbounded[F <: ([_$24] =>> Any), A](fairSize: Int)(evidence$2: Concurrent[F]): F[Queue[F, A]]
Creates an unbounded queue that distributed always at max fairSize elements to any subscriber.
def bounded[F <: ([_$26] =>> Any), A](maxSize: Int)(evidence$3: Concurrent[F]): F[Queue[F, A]]
Creates a queue with the specified size bound.
def boundedNoneTerminated[F <: ([_$27] =>> Any), A](maxSize: Int)(evidence$4: Concurrent[F]): F[NoneTerminatedQueue[F, A]]
Creates a bounded queue terminated by enqueueing None. All elements before None are preserved.
def circularBuffer[F <: ([_$28] =>> Any), A](maxSize: Int)(evidence$5: Concurrent[F]): F[Queue[F, A]]
Creates a queue which stores the last maxSize enqueued elements and which never blocks on enqueue.
def circularBufferNoneTerminated[F <: ([_$29] =>> Any), A](maxSize: Int)(evidence$6: Concurrent[F]): F[NoneTerminatedQueue[F, A]]
Creates a queue terminated by enqueueing None. All elements before None are preserved and never blocks on enqueue.
def fairBounded[F <: ([_$30] =>> Any), A](maxSize: Int, fairSize: Int)(evidence$7: Concurrent[F]): F[Queue[F, A]]
Created a bounded queue that distributed always at max fairSize elements to any subscriber.
def noneTerminated[F <: ([_$32] =>> Any), A](evidence$8: Concurrent[F]): F[NoneTerminatedQueue[F, A]]
Created an unbounded queue terminated by enqueueing None. All elements before None.
def synchronous[F <: ([_$33] =>> Any), A](evidence$9: Concurrent[F]): F[Queue[F, A]]
Creates a queue which allows at most a single element to be enqueued at any time.
def synchronousNoneTerminated[F <: ([_$34] =>> Any), A](evidence$10: Concurrent[F]): F[NoneTerminatedQueue[F, A]]
Like synchronous, except that any enqueue of None will never block and cancels any dequeue operation.
def create[F <: ([_$35] =>> Any), S, A](strategy: Strategy[A, Chunk[A], S, Int])(evidence$11: Concurrent[F]): F[Queue[F, A]]
def createNoneTerminated[F <: ([_$38] =>> Any), S, A](strategy: Strategy[Option[A], Option[Chunk[A]], S, Int])(F: Concurrent[F]): F[NoneTerminatedQueue[F, A]]