Haskell Concurrency

Run IO operations asynchronously and wait for their results

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

Beautiful Streaming, Concurrent and Reactive Composition

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

Run MonadConc operations asynchronously and wait for their results.

Model-view-controller

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

Cached and parallel data fetching.

Introduces conduits to channels, and promotes using conduits concurrently.

Concurrency for the pipes ecosystem

Running worker processes under system resource restrictions

A command line type checker for CSPM files.

Concurrent PostgreSQL data consumers

Containers for STM

Fork threads and wait for their result

OTP-like supervision trees in Haskell

Extra queue utilities for STM

Distributed, stateful, homogeneous microservice framework.

Run lifted IO operations asynchronously and wait for their results

Concurrent networked stream transducers

Extra concurrency primitives

A fast concurrent unique identifier supply with a pure API

Sirkel, a Chord DHT

Lazy demand-driven promises

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

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

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

Non-blocking concurrent map

Concurrent and combinable updates

Simple package that implements timers.

Unbounded thread delays and timeouts

Rate limiter using lazy bucket algorithm

Much safer replacement for QSemN, QSem, and SampleVar

Loop over an action but throttle it to a certain rate

Implementation of bounded channels.

Fully concurrent unique identifiers

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

Go-style channels

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

Unagi Chan IO-Streams

A monadic interface for async

Streaming to and from subprocesses using Pipes

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

Updatable timeouts as a Monad transformer

A concurrent utility inspired by Ticker in golang

Generalized sleep and timeout functions

Tiny library for concurrent computations

A fast, cache-efficient, concurrent bloom filter

A named lock that is created on demand.

Contention-free STM hash map

Kick Channels

Basic Erlang-like process support for Haskell

Chunked Communication Queues

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

Concurrent actions that may fail with a value.

Lightweight Erlang-style actors for Haskell.

Baisc, Erlang-like message passing supporting sockets.

Limit number of IO actions started per second

NCurses interface to view multiple ByteString streams in parallel.

Extra Utilities for the Async Library

A simple round-robin data type

Multiple-read / single-write locks

utility for collapsing adjacent writes

Simple package that allows for long thread suspensions.

Practical actors for Haskell.

Synchronize actions to a time pulse

Transactional I/O for duplex streams

Bundles shared calls to IO functions to perform them only once

Provides API for timer based execution of IO actions

Throttler between arbitrary IO producer and consumer functions

Concurrent channels with a forwarding primitive

Simple thread barriers

Useful concurrent combinators

Fast concurrent queues much inspired by unagi-chan

Thread delay and timeout functions with typed arguments

Minimalistic actor library

Heartbeats for io-streams

Simple Haskel thread management in hierarchical manner

STM's TChan split into sending and receiving halves.

Extra STM functions

A trivial lock based on MVar.

GraphHammer Haskell graph analyses framework inspired by STINGER.

mecha are the most complex composite machines known to humanity, lets build them well!