Queue

object Queue
Companion
class
class Object
trait Matchable
class Any

Type members

Classlikes

final class InPartiallyApplied[G <: ([_$23] =>> Any)](val G: Sync[G]) extends AnyVal

Value members

Methods

def in[G <: ([_$42] =>> Any)](G: Sync[G]): InPartiallyApplied[G]
Provides constructors for Queue with state initialized using
another Sync datatype.
{{{
val queue = Queue.in[SyncIO] .unbounded[IO, String]
}}}
def unbounded[F <: ([_$43] =>> Any), A](F: Concurrent[F]): F[Queue[F, A]]
Creates a queue with no size bound.
def fairUnbounded[F <: ([_$44] =>> Any), A](fairSize: Int)(F: Concurrent[F]): F[Queue[F, A]]
Creates an unbounded queue that distributed always at max fairSize elements to any subscriber.
def bounded[F <: ([_$45] =>> Any), A](maxSize: Int)(F: Concurrent[F]): F[Queue[F, A]]
Creates a queue with the specified size bound.
def boundedNoneTerminated[F <: ([_$46] =>> Any), A](maxSize: Int)(F: Concurrent[F]): F[NoneTerminatedQueue[F, A]]
Creates a bounded queue terminated by enqueueing None. All elements before None are preserved.
def circularBuffer[F <: ([_$47] =>> Any), A](maxSize: Int)(F: 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 <: ([_$48] =>> Any), A](maxSize: Int)(F: 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 <: ([_$49] =>> Any), A](maxSize: Int, fairSize: Int)(F: Concurrent[F]): F[Queue[F, A]]
Created a bounded queue that distributed always at max fairSize elements to any subscriber.
def noneTerminated[F <: ([_$50] =>> Any), A](F: Concurrent[F]): F[NoneTerminatedQueue[F, A]]
Created an unbounded queue terminated by enqueueing None. All elements before None.
def synchronous[F <: ([_$51] =>> Any), A](F: 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 <: ([_$52] =>> Any), A](F: Concurrent[F]): F[NoneTerminatedQueue[F, A]]
Like synchronous, except that any enqueue of None will never block and cancels any dequeue operation.