Queue.Types

data SCOPE :: Type

data READ :: SCOPE

data WRITE :: SCOPE

type Handler a = a -> Effect Unit

class QueueScope (q :: Row SCOPE -> Type -> Type)  where

Members

• readOnly :: forall a rw. q (read :: READ | rw) a -> q (read :: READ) a
• writeOnly :: forall a rw. q (write :: WRITE | rw) a -> q (write :: WRITE) a
• allowWriting :: forall a rw. q (read :: READ) a -> q (read :: READ | rw) a
• allowReading :: forall a rw. q (write :: WRITE) a -> q (write :: WRITE | rw) a

class QueueExtra (queue :: Row SCOPE -> Type -> Type)  where

Members

• debounceStatic :: forall a. Milliseconds -> queue (read :: READ) a -> Aff { input :: queue (write :: WRITE) a, writer :: Fiber Unit }
• throttleStatic :: forall a. Milliseconds -> queue (read :: READ) a -> Aff { input :: queue (write :: WRITE) a, writer :: Fiber Unit }
• intersperseStatic :: forall a. Milliseconds -> Aff a -> queue (read :: READ) a -> Aff { input :: queue (write :: WRITE) a, listener :: Fiber Unit, writer :: Fiber Unit }

class Queue (queue :: Row SCOPE -> Type -> Type)  where

Represents an un-indexed queue - such that identifying handlers is not supported.

Members

• new :: forall a. Effect (queue (read :: READ, write :: WRITE) a)
• putMany :: forall t rw a. Traversable t => queue (write :: WRITE | rw) a -> t a -> Effect Unit

  Pushes multiple values on the stack of pending values, or traverses through the handler(s).

• popMany :: forall rw a. queue (write :: WRITE | rw) a -> Int -> Effect (Array a)

  Pops as many values as indicated off the stack of pending values, if any, in the reverse order they were added - i.e. youngest first.

• takeMany :: forall rw a. queue (write :: WRITE | rw) a -> Int -> Effect (Array a)

  Pops as many values as indicated off the stack of pending values, if any, in the same order they were added - i.e. oldest first.

• takeAll :: forall rw a. queue (write :: WRITE | rw) a -> Effect (Array a)

  Equivalent to length q >>= takeMany q, but without the overhead.

• on :: forall rw a. queue (read :: READ | rw) a -> Handler a -> Effect Unit

  Assign a handler to capture queue events

• once :: forall a rw. queue (read :: READ | rw) a -> Handler a -> Effect Unit

  Removes a handler after first run

• del :: forall rw a. queue (read :: READ | rw) a -> Effect Unit
• read :: forall rw a. queue rw a -> Effect (Array a)
• length :: forall rw a. queue rw a -> Effect Int

put :: forall queue rw a. Queue queue => queue (write :: WRITE | rw) a -> a -> Effect Unit

Put only one event.

pop :: forall queue rw a. Queue queue => queue (write :: WRITE | rw) a -> Effect (Maybe a)

Pop the latest added event.

take :: forall queue rw a. Queue queue => queue (write :: WRITE | rw) a -> Effect (Maybe a)

Take the first added event.

draw :: forall queue a rw. Queue queue => queue (read :: READ | rw) a -> Aff a

Pull the next asynchronous value out of a queue. Doesn't affect existing handlers (they will all receive the value as well). If this action is canceled, all handlers will be removed from the queue, because this interface is un-indexed.

drain :: forall queue a rw. Queue queue => queue (read :: READ | rw) a -> Effect Unit

Adds a listener that does nothing, and "drains" any pending messages.