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

Run MonadConc operations asynchronously and wait for their results.

Concurrency for the pipes ecosystem

Introduces conduits to channels, and promotes using conduits concurrently.

Cached and parallel data fetching.

Running worker processes under system resource restrictions

A command line type checker for CSPM files.

Concurrent PostgreSQL data consumers

Extra queue utilities for STM

Fork threads and wait for their result

Containers for STM

Distributed, stateful, homogeneous microservice framework.

Extra concurrency primitives

Concurrent networked stream transducers

A fast concurrent unique identifier supply with a pure API

Run lifted IO operations asynchronously and wait for their results

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

Sirkel, a Chord DHT

Lazy demand-driven promises

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

Concurrent and combinable updates

Unbounded thread delays and timeouts

Non-blocking concurrent map

Rate limiter using lazy bucket algorithm

Much safer replacement for QSemN, QSem, and SampleVar

Fully concurrent unique identifiers

Simple package that implements timers.

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

Implementation of bounded channels.

Loop over an action but throttle it to a certain rate

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

Unagi Chan IO-Streams

Go-style channels

Updatable timeouts as a Monad transformer

Streaming to and from subprocesses using Pipes

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

Tiny library for concurrent computations

A named lock that is created on demand.

Concurrent actions that may fail with a value.

Baisc, Erlang-like message passing supporting sockets.

Kick Channels

A fast, cache-efficient, concurrent bloom filter

A concurrent utility inspired by Ticker in golang

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

Contention-free STM hash map

Chunked Communication Queues

A simple round-robin data type

Lightweight Erlang-style actors for Haskell.

A monadic interface for async

Basic Erlang-like process support for Haskell

Generalized sleep and timeout functions

Limit number of IO actions started per second

Extra Utilities for the Async Library

NCurses interface to view multiple ByteString streams in parallel.

utility for collapsing adjacent writes

Practical actors for Haskell.

Multiple-read / single-write locks

Simple package that allows for long thread suspensions.

Bundles shared calls to IO functions to perform them only once

Transactional I/O for duplex streams

Synchronize actions to a time pulse

Concurrent channels with a forwarding primitive

Throttler between arbitrary IO producer and consumer functions

Simple thread barriers

Provides API for timer based execution of IO actions

Thread delay and timeout functions with typed arguments

Useful concurrent combinators

Fast concurrent queues much inspired by unagi-chan

Extra STM functions

STM's TChan split into sending and receiving halves.

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

GraphHammer Haskell graph analyses framework inspired by STINGER.