Module

Queue.One

Queues with at most one handler - this is useful for sending messages to a single, solitary handler (user interface component, websocket connection, what have you).

#Queue 

newtype Queue (rw :: Row SCOPE) a

Represents a singleton queue, with at-most one handler.

Constructors

Instances

#new 

new :: forall a. Effect (Queue (read :: READ, write :: WRITE) a)

Re-exports from Queue.Types

#WRITE 

data WRITE :: SCOPE

#SCOPE 

data SCOPE

#READ 

data READ :: SCOPE

#Handler 

type Handler a = a -> Effect Unit

#Queue 

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

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

Members

  • putMany :: forall a rw t. 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 a rw. 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 a rw. 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 a rw. queue (write :: WRITE | rw) a -> Effect (Array a)

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

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

    Assign a handler to capture queue events.

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

    Removes a handler after first run.

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

    Removes all handlers from the queue, without affecting the cache.

  • read :: forall a rw. queue rw a -> Effect (Array a)

    Observes the values in the queue without deleting them.

  • length :: forall a rw. queue rw a -> Effect Int

    Length of the cache.

#QueueExtra 

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

#QueueScope 

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

Members

#take 

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

Take the first added event.

#put 

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

Put only one event.

#pop 

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

Pop the latest added event.

#draw 

draw :: forall rw a queue. 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 

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

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

Modules