Haskell Concurrency

Run IO operations asynchronously and wait for their results

Parallel scheduler, LVar data structures, and infrastructure to build more.

Chase & Lev work-stealing lock-free double-ended queues (deques).

Model-view-controller

Fast concurrent queues with a Chan-like API, and more

Concurrency for the pipes ecosystem

Cached and parallel data fetching.

Introduces conduits to channels, and promotes using conduits concurrently.

Run MonadConc operations asynchronously and wait for their results.

Running worker processes under system resource restrictions

A command line type checker for CSPM files.

Concurrent PostgreSQL data consumers

Extra queue utilities for STM

Containers for STM

Fork threads and wait for their result

Distributed, stateful, homogeneous microservice framework.

Extra concurrency primitives

Run lifted IO operations asynchronously and wait for their results

Concurrent networked stream transducers

Sirkel, a Chord DHT

A fast concurrent unique identifier supply with a pure API

Simple, IO-based library for Erlang-style thread supervision

Spawn threads that never die (unless told to do so)

Lazy demand-driven promises

A typeclass for mutable references that have an atomic modify operation.

A principal solution to ghost threads and silent exceptions

(deprecated in favor of 'threads') Simple thread management

Concurrent and combinable updates

Unbounded thread delays and timeouts

Rate limiter using lazy bucket algorithm

Non-blocking concurrent map

Simple package that implements timers.

Much safer replacement for QSemN, QSem, and SampleVar

Loop over an action but throttle it to a certain rate

Control.Concurrent.Chan split into sending and receiving halves.

Go-style channels

Provides access to the dynamic pointer tagging bits used by GHC.

A library for more structured concurrent programming, based on the Actor Model

Streaming to and from subprocesses using Pipes

Fully concurrent unique identifiers

Tiny library for concurrent computations

A named lock that is created on demand.

Updatable timeouts as a Monad transformer

Kick Channels

Baisc, Erlang-like message passing supporting sockets.

A fast, cache-efficient, concurrent bloom filter

Generalized sleep and timeout functions

Lightweight Erlang-style actors for Haskell.

Contention-free STM hash map

Runs a time-limited computation alowing it to return intermediate results.

Chunked Communication Queues

A simple round-robin data type

Basic Erlang-like process support for Haskell

Concurrent actions that may fail with a value.

Implementation of bounded channels.

Extra Utilities for the Async Library

Limit number of IO actions started per second

NCurses interface to view multiple ByteString streams in parallel.

A monadic interface for async

Practical actors for Haskell.

utility for collapsing adjacent writes

Unagi Chan IO-Streams

Multiple-read / single-write locks

Bundles shared calls to IO functions to perform them only once

Transactional I/O for duplex streams

Simple package that allows for long thread suspensions.

Synchronize actions to a time pulse

Provides API for timer based execution of IO actions

Simple thread barriers

Thread delay and timeout functions with typed arguments

Fast concurrent queues much inspired by unagi-chan

Useful concurrent combinators

Extra STM functions

STM's TChan split into sending and receiving halves.