Haskell Concurrency

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

Dataflow programming and declarative concurrency

Run IO operations asynchronously and wait for their results

Systematic concurrency testing meets Haskell.

Systematic concurrency testing meets Haskell.

The LVish Haskell library

A collection of different packages for CAS based data structures.

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

Model-view-controller

lifted IO operations from the threads library

Cached and parallel data fetching.

Concurrent PostgreSQL data consumers

Concurrency for the pipes ecosystem

OTP-like supervision trees in Haskell

Containers for STM

STM-based channels for conduits.

A work stealing scheduler

A lightweight, structured concurrency library

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

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

Interactive-diagrams

Run lifted IO operations asynchronously and wait for their results

...

Async combinators

Fork threads and wait for their result

Safe, programmable, speculative evaluation for Haskell

Extra utilities for STM queues

Distributed, stateful, homogeneous microservice framework.

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

lazy promises

Concurrency features for the Haskell machines package

Extra concurrency primitives

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

A fast globally unique variable supply with a pure API

A principal solution to ghost threads and silent exceptions

Unbounded thread delays and timeouts

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

Incubator for my Haskell libraries

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

File locking

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

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

Haskell rate limiter library using lazy token bucket algorithm

A thread-safe hash table in Haskell

Non-blocking concurrent hashmap for Haskell

Simple thread management

fast unique variables

Concurrent and combinable updates

Bounded channels with invalidating readers

Unagi-chan channels for io-streams.

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

A contention-free STM hash map for Haskell

Implicit monadic dataflow parallelism

Loop over an action but throttle it to a certain rate

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

STM-specialised Hash Array Mapped Trie

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

Generalized sleep and timeout functions

Provides access to GHC's dynamic pointer tag bits

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

A monadic interface for async

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

Go-style channels for Haskell (WIP)

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

Bounded (limited capacity) channels for Haskell

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.

A tiny Haskell library for concurrent computations

Concurrently + Either

Simple Haskel thread management in hierarchical manner

Haskell: Synchronize multiple actions to be triggered as parallel as possible

simple and general quantity semaphores in ghc haskell

Baisc, Erlang-like message passing for Haskell.

Periodic timers based on async API.

set a maximum on the number of concurrent actions

Limit number of IO actions started per second

A simple round-robin data type

A named lock that is created on demand.

Updatable timeouts as a Monad transformer

Extra utilities for async

A simple implementation of a multiple-reader / single-writer locks using STM

utility for collapsing adjacent writes

A message passing concurrency extensible-effect

DEPRECATED - Stream data to and from subprocesses using Pipes

Minimalistic actor library for Haskell

Throttler between a producer and a consumer function

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

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

Practical actors for Haskell.

Haskell: Various concurrent combinators

Thread delay and timeout functions with typed arguments

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

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

Haskell channels with the forwarding primitive

Heartbeats for io-streams

Simple and fast implementation of Future

Bundles shared calls to IO functions to perform them only once

Transactional I/O for duplex streams

Build a Queue-Processing Worker Pool using Immortal

A distributed computation monad transformer

Fast concurrent queues much inspired by unagi-chan