Module

Queue

Package
purescript-queue
Repository
athanclark/purescript-queue

Un-indexed queues with a set of handlers - this is useful for broadcasting messages to a set of recipients, where removing them individually from the queue isn't necessary (but incremental additions are). This could be useful in interfaces where the list of handlers strictly increases, then gets wiped all at once if desired (i.e. a feed of social media posts).

#Queue Source

newtype Queue (rw :: Row SCOPE) a

Either a non empty set of handlers, or a possibly empty set of pending values.

Constructors

Instances

#new Source

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

Re-exports from Queue.Types

#WRITE Source

data WRITE :: SCOPE

#READ Source

data READ :: SCOPE

#Handler Source

type Handler a = a -> Effect Unit

#Queue Source

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

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

Members

  • 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

#QueueExtra Source

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

#QueueScope Source

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

Members

#take Source

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

Take the first added event.

#put Source

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

Put only one event.

#pop Source

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

Pop the latest added event.

#draw Source

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 Source

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.

#SCOPE Source

data SCOPE :: Type
Modules
IOQueues
IxQueue
IxQueue.IOQueues
Queue
Queue.One
Queue.Types