Queue

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def bounded[F[_], A](maxSize: Int)(implicit F: Concurrent[F]): F[Queue[F, A]]

Creates a queue with the specified size bound.

def boundedNoneTerminated[F[_], A](maxSize: Int)(implicit F: Concurrent[F]): F[NoneTerminatedQueue[F, A]]

Creates a bounded queue terminated by enqueueing None.

def circularBuffer[F[_], A](maxSize: Int)(implicit F: Concurrent[F]): F[Queue[F, A]]

Creates a queue which stores the last maxSize enqueued elements and which never blocks on enqueue.

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fairBounded[F[_], A](maxSize: Int, fairSize: Int)(implicit F: Concurrent[F]): F[Queue[F, A]]

Created a bounded queue that distributed always at max fairSize elements to any subscriber.

def fairUnbounded[F[_], A](fairSize: Int)(implicit F: Concurrent[F]): F[Queue[F, A]]

Creates an unbounded queue that distributed always at max fairSize elements to any subscriber.

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def noneTerminated[F[_], A](implicit F: Concurrent[F]): F[NoneTerminatedQueue[F, A]]

Created an unbounded queue terminated by enqueueing None.

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def synchronous[F[_], A](implicit 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[_], A](implicit F: Concurrent[F]): F[NoneTerminatedQueue[F, A]]

Like synchronous, except that any enqueue of None will never block and cancels any dequeue operation.

def toString(): String

def unbounded[F[_], A](implicit F: Concurrent[F]): F[Queue[F, A]]

Creates a queue with no size bound.

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit