Haskell Concurrency

High performance, concurrent functional programming abstractions

A structured concurrency library

A work stealing scheduler

A Haskell library that simplifies access to remote data, such as databases or web-based services.

A very simple interface for incremental computation using STM in Haskell.

Systematic concurrency testing meets Haskell.

Systematic concurrency testing meets Haskell.

A simplified implementation of Erlang/OTP like supervisor for GHC thread

Run lifted IO operations asynchronously and wait for their results

Simple Haskel thread management in hierarchical manner

File locking

Minimalistic actor library for Haskell

Build a Queue-Processing Worker Pool using Immortal

Run IO operations asynchronously and wait for their results

Unagi-chan channels for io-streams.

Monitor groups of threads with non-hierarchical lifetimes.

Concurrent PostgreSQL data consumers

A collection of different packages for CAS based data structures.

The library FDR3 uses for parsing, type checking and evaluating machine CSP.

The library FDR3 uses for parsing, type checking and evaluating machine CSP.

Can we realize Rust's ownership model as a monad in Haskell?

Simple package that implements timers. Both "one-shot" and "repeating" timers are implemented.

Manage concurrently operating threads without having to spark them

A thread-safe hash table in Haskell

A message passing concurrency extensible-effect

Actor pattern utilities for Haskell.

Concurrency for the pipes ecosystem

Implementation of skip variables (a special case of skip channels)

SafeSemaphore is a Haskell library replacing non-exception safe libraries like QSem, QSemN, SampleVar

Bundles shared calls to IO functions to perform them only once

A Haskell library providing an idiomatic implementation of the actor model of concurrency

Sirkel; a Chord DHT in haskell. Node failure, replication and batteries included!

A principal solution to ghost threads and silent exceptions

A tiny Haskell library for concurrent computations

Transactional I/O for duplex streams

Thread communication queues that group items/requests that occur close together in time

STM-based channels for conduits.

Containers for STM

Extra utilities for STM queues

Simple package that allows for long thread suspensions. Uses newtype wrapper (of Int64 at the moment) to represent delay.

Simple thread management

Fork threads and wait for their result

Simple, IO-based Haskell library for Erlang-inspired thread supervisors

Generalized sleep and timeout functions

Updatable timeouts as a Monad transformer

Allows timeouting a computation while allowing it to return partial results. Useful for making AI-like algorithms that should return the best result found within a time limit.

Haskell rate limiter library using lazy token bucket algorithm

A contention-free STM hash map for Haskell

A fast, cache-efficient, concurrent bloom filter in Haskell

Unbounded thread delays and timeouts

fast unique variables

Haskell: Various concurrent combinators

Haskell - Extra functions for STM

Simple concurrency barriers

Hactor is a rewrite of thespian, a library which aims to provide lightweight Erlang-style actors for Haskell.

Fast concurrent queues much inspired by unagi-chan

The LVish Haskell library

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

GHC STM's TChan split into sending and receiving halves.

Provides access to GHC's dynamic pointer tag bits

A haskell library implementing fast and scalable concurrent queues for x86, with a Chan-like API

Go-style channels for Haskell (WIP)

Incubator for my Haskell libraries

Periodic timers based on async API.

Thread delay and timeout functions with typed arguments

Haskell channels with the forwarding primitive

A utility for concurrent programming in Haskell, insipired by Ticker in golang.

Throttler between a producer and a consumer function

Heartbeats for io-streams

OTP-like supervision trees in Haskell

A trivial lock based on MVar

DISCONTINUED. Async combinators

A distributed computation monad transformer

...

Simple and fast implementation of Future

Lifted STM operations

DISCONTINUED. set a maximum on the number of concurrent actions

simple and general quantity semaphores in ghc haskell

Implicit monadic dataflow parallelism

STM-specialised Hash Array Mapped Trie

Fast rate limiting for Haskell using the token bucket algorithm. BSD-licensed.

Safe, programmable, speculative evaluation for Haskell

Extra utilities for async

Bounded (limited capacity) channels for Haskell

utility for collapsing adjacent writes

Concurrently + Either

Extra concurrency primitives

Concurrency features for the Haskell machines package

A fast globally unique variable supply with a pure API

Non-blocking concurrent hashmap for Haskell

Baisc, Erlang-like message passing for Haskell.

*Very* basic erlang-like process support for Haskell

Cached and parallel data fetching.

Practical actors for Haskell.

Output from parallel subprocesses is an ugly, many-headed beast. Piping though hydra-print provides a NCurses interface to a dynamic set output streams, displayed without interleaving.

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

Limit number of IO actions started per second

Bounded channels with invalidating readers

Model-view-controller

Concurrent and combinable updates