fs2-core/fs2.concurrent/NoneTerminatedQueue

NoneTerminatedQueue

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.
trait Dequeue[F, A]
trait DequeueChunk1[F, [A] =>> Option[A], A]
trait Dequeue1[F, Option[A]]
trait Enqueue[F, Option[A]]
class Object
trait Matchable
class Any

Value members

Methods

def imap[B](f: A => B)(g: B => A)(F: Functor[F]): NoneTerminatedQueue[F, B]
Returns an alternate view of this NoneTerminatedQueue where its elements are of type B,
given two functions, A => B and B => A.

Inherited methods

def offer1(a: A): F[Boolean]
Offers one element to this Queue.
Evaluates to false if the queue is full, indicating the a was not queued up.
Evaluates to true if the a was queued up successfully.
Value Params
a
A to enqueue
Inhertied from
Enqueue
def dequeueBatch: (F, Int) => A
Provides a pipe that converts a stream of batch sizes in to a stream of elements by dequeuing
batches of the specified size.
Inhertied from
Dequeue
def dequeueChunk(maxSize: Int): Stream[F, A]
Dequeues elements from the queue, ensuring elements are dequeued in chunks not exceeding maxSize.
Inhertied from
Dequeue
def dequeueChunk1(maxSize: Int): F[G[Chunk[A]]]
Dequeues one Chunk[A] with no more than maxSize elements. Completes once one is ready.
Inhertied from
DequeueChunk1
def enqueue1(a: A): F[Unit]
Enqueues one element to this Queue.
If the queue is full this waits until queue has space.
This completes after a has been successfully enqueued to this Queue
Inhertied from
Enqueue
def dequeue1: F[A]
Dequeues one A from this queue. Completes once one is ready.
Inhertied from
Dequeue1
def dequeue: Stream[F, A]
Dequeues elements from the queue.
Inhertied from
Dequeue
def tryDequeue1: F[Option[A]]
Tries to dequeue a single element. Unlike dequeue1, this method does not semantically
block until a chunk is available - instead, None is returned immediately.
Inhertied from
Dequeue1
def enqueue: (F, A) => Unit
Enqueues each element of the input stream to this queue by
calling enqueue1 on each element. Emits a unit for each element enqueued.
Inhertied from
Enqueue
def tryDequeueChunk1(maxSize: Int): F[Option[G[Chunk[A]]]]
Tries to dequeue a single chunk of no more than max size elements.
Unlike dequeueChunk1, this method does not semantically block until a chunk is available -
instead, None is returned immediately.
Inhertied from
DequeueChunk1