Categories Concurrency

@hackage/async-combinators

Async combinators

@hackage/consumers

Concurrent PostgreSQL data consumers

@hackage/stm-conduit

Introduces conduits to channels, and promotes using conduits concurrently.

@hackage/concurrent-machines

Concurrent networked stream transducers

@hackage/timeout-snooze

Efficient timeout with reset

@hackage/chan

Some extra kit for Chans

@hackage/laminar

Run dependent IO actions asynchronously.

@hackage/chp-transformers

Transformers instances for the CHP library

@hackage/SafeSemaphore

Much safer replacement for QSemN, QSem, and SampleVar

@hackage/stm-promise

Simple STM Promises for IO computations and external processes

@hackage/concurrent-utilities

More utilities and broad-used datastructures for concurrency.

@hackage/forward-chan

Concurrent channels with a forwarding primitive

@hackage/bits-atomic

Atomic bit operations on memory locations for low-level synchronization

@hackage/conlogger

A logger for a concurrent program.

@hackage/thread-supervisor

A simplified implementation of Erlang/OTP like supervisor over thread

@hackage/haskell-bee-stm

STM broker implementation for haskell-bee

@hackage/massiv-scheduler

Work stealing scheduler for Massiv (Массив) and other parallel applications.

@hackage/streamly-fsevents

File system event notification API

@hackage/data-ivar

Write-once variables with concurrency support

@hackage/bits-extras

Efficient high-level bit operations not found in Data.Bits

@hackage/reactor

Reactor - task parallel reactive programming

@hackage/sharedio

Bundles shared calls to IO functions to perform them only once

@hackage/pipes-websockets

WebSockets in the Pipes framework.

@hackage/stm-lifted

Software Transactional Memory lifted to MonadIO

@hackage/concurrent-output

Ungarble output from several threads or commands

@hackage/hakka

Minimal akka-inspired actor library

@hackage/ochan

Owned channels in the Ownership Monad

@hackage/named-lock

A named lock that is created on demand.

@hackage/blocking-transactions

Composable, blocking transactions.

@hackage/CSPM-Interpreter

An interpreter for CSPM

@hackage/BoundedChan

Implementation of bounded channels.

@hackage/wait-handle

Wait handles are MVars which can only be written to once, and from which values can never be removed.

@hackage/companion

A Haskell library to provide companion threads.

@hackage/slave-thread

A fundamental solution to ghost threads and silent exceptions

@hackage/chp-spec

A mirror implementation of chp that generates a specification of the program

@hackage/cspmchecker

A command line type checker for CSPM files.

@hackage/threadmanager

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

@hackage/Stasis

A simple MVCC like library

@hackage/immortal

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

@hackage/supervisors

Monitor groups of threads with non-hierarchical lifetimes.

@hackage/CSPM-Frontend

A CSP-M parser compatible with FDR-2.91

@hackage/capataz

OTP-like supervision trees in Haskell

@hackage/keera-callbacks

Mutable memory locations with callbacks

@hackage/GraphHammer-examples

Test harness for TriangleCount analysis.

@hackage/ConcurrentUtils

Concurrent utilities

@hackage/lvar

TMVar that can be listened to

@hackage/HLogger

Simple, concurrent and easy-to-use logging library

@hackage/accelerate-llvm-native

Accelerate backend for multicore CPUs

@hackage/lawless-concurrent-machines

Concurrent networked stream transducers

@hackage/simple-actors

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

@hackage/twilight-stm

STM library with safe irrevocable I/O and inconsistency repair

@hackage/suspend

Simple package that allows for long thread suspensions.

@hackage/park-bench

A quick-and-dirty, low-friction benchmark tool with immediate feedback

@hackage/strict-checked-vars

Strict MVars and TVars with invariant checking for IO and IOSim

@hackage/concurrent-barrier

Simple thread barriers

@hackage/timeout

Generalized sleep and timeout functions

@hackage/sirkel

Sirkel, a Chord DHT

@hackage/accelerate

An embedded language for accelerated array processing

@hackage/hasql-listen-notify

LISTEN/NOTIFY with hasql

@hackage/atomic-counter

Mutable counters that can be modified with atomic operatinos

@hackage/global-lock

A global lock implemented without unsafePerformIO

@hackage/net-concurrent

Concurrent over the network execution library

@hackage/lifted-stm

STM operations lifted through monad transformer stacks

@hackage/throttled-io-loop

Loop over an action but throttle it to a certain rate

@hackage/strict-stm

Strict STM interface polymorphic over stm implementation.

@hackage/mvar-lock

A trivial lock based on MVar

@cardano/strict-checked-vars

Strict MVars and TVars with invariant checking for IO and IOSim

@hackage/stm-queue-extras

Extra queue utilities for STM

@hackage/skip-var

Skip variables

@hackage/GraphHammer

GraphHammer Haskell graph analyses framework inspired by STINGER.

@hackage/haskell-bee

A lightweight library for asynchronous job workers with multiple broker backends

@hackage/unliftio-messagebox

Fast and robust message queues for concurrent processes

@hackage/atomic-modify-general

Generalizations of atomicModifyIORef

@hackage/parallel-io

Combinators for executing IO actions in parallel on a thread pool.

@hackage/timeout-with-results

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

@hackage/threaded

Manage concurrently operating threads without having to spark them

@hackage/pulse

Synchronize actions to a time pulse

@hackage/stm-incremental

A library for constructing incremental computations

@hackage/prefetch

Prefetch stdin even before stdout is ready

@hackage/haxl

A Haskell library for efficient, concurrent, and concise data access.

@hackage/qsem

quantity semaphores

@hackage/accelerate-cuda

Accelerate backend for NVIDIA GPUs

@hackage/lockpool

set a maximum on the number of concurrent actions

@hackage/async-dejafu

Run MonadConc operations asynchronously and wait for their results.

@hackage/oath

Composable concurrent computation done right

@hackage/transient

composing programs with multithreading, events and distributed computing

@hackage/drama

Actor library for Haskell

@hackage/waitfree

A wrapping library for waitfree computation.

@hackage/free-concurrent

Free monads suitable for concurrent computation

@hackage/tskiplist

A Skip List Implementation in Software Transactional Memory (STM)

@hackage/libcspm

A library providing a parser, type checker and evaluator for CSPM.

@hackage/atomic-primops-vector

Atomic operations on Data.Vector types

@hackage/scc

Streaming component combinators

@hackage/accelerate-examples

Examples using the Accelerate library

@hackage/concurrent-hashtable

Thread-safe hash tables for multi-cores!

@hackage/unlift-stm

(un)lifted classes and functions for the STM monad

@hackage/haskell-throttle

A simple throttling library, which drops messages from same group.

@hackage/stm-hamt

STM-specialised Hash Array Mapped Trie

@hackage/concurrent-rpc

An abstraction for inter-thread RPC based on MVars

@hackage/unagi-streams

Unagi Chan IO-Streams

@hackage/collapse-util

utility for collapsing adjacent writes

@hackage/roundRobin

A simple round-robin data type

@hackage/TCache

A Transactional cache with user-defined persistence

@hackage/ki-effectful

Adaptation of the ki library for the effectful ecosystem.

@hackage/data-timeout

64-bit timeouts of nanosecond precision

@hackage/stm-containers

Containers for STM

@hackage/stm-chunked-queues

Chunked Communication Queues

@hackage/stm

Software Transactional Memory

@hackage/async-timer

Provides API for timer based execution of IO actions

@hackage/haxl-facebook

An example Haxl data source for accessing the Facebook Graph API

@hackage/cio

A monad for concurrent IO on a thread pool

@hackage/priority-sync

Cooperative task prioritization.

@hackage/data-concurrent-queue

A Library for directional queues

@hackage/accelerate-llvm

Accelerate backend component generating LLVM IR

@hackage/hoare

Simple tools for communicating sequential processes

@hackage/gochan

Go-style channels

@hackage/temporal-sdk

@hackage/mvc-updates

Concurrent and combinable updates

@hackage/CSPM-FiringRules

Firing rules semantic of CSPM

@hackage/timers

Simple package that implements timers.

@hackage/privileged-concurrency

Provides privilege separated versions of the concurrency primitives.

@hackage/synchronous-channels

Synchronous communication channels

@hackage/accelerate-fft

FFT using the Accelerate library

@hackage/consumers-metrics-prometheus

Prometheus metrics for the consumers library

@hackage/om-actor

Actor pattern utilities.

@hackage/delay

More useful and humain delaying functions

@hackage/polysemy-conc

Polysemy effects for concurrency

@hackage/ctrie

Non-blocking concurrent map

@hackage/thread-utils-finalizers

Perform finalization for threads.

@hackage/lukko

File locking

@hackage/lazy-async

Asynchronous actions that don't start right away

@hackage/io-throttle

Limit number of IO actions started per second

@hackage/lrucaching-haxl

Combine lrucaching and haxl.

@hackage/unfork

Make any action thread safe

@hackage/split-tchan

STM's TChan split into sending and receiving halves.

@hackage/throttle-io-stream

Throttler between arbitrary IO producer and consumer functions

@hackage/fudgets

The Fudgets Library

@hackage/async-manager

A thread manager for async

@hackage/accelerate-llvm-ptx

Accelerate backend for NVIDIA GPUs

@hackage/stm-stats

retry statistics for STM transactions

@hackage/theatre

Minimalistic actor library

@hackage/heartbeat-streams

Heartbeats for io-streams

@hackage/chp-plus

A set of high-level concurrency utilities built on Communicating Haskell Processes

@hackage/stm-extras

Extra STM functions

@hackage/epass

Baisc, Erlang-like message passing supporting sockets.

@hackage/lifted-threads

lifted IO operations from the threads library

@hackage/token-limiter

Fast rate limiting using the token bucket algorithm (BSD)

@hackage/threads-supervisor

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

@hackage/post-mess-age

Send messages to a handle concurrently without getting them mixed.

@hackage/scheduler

Work stealing scheduler.

@hackage/unbounded-delays

Unbounded thread delays and timeouts

@hackage/rio-process-pool

A library for process pools coupled with asynchronous message queues

@hackage/eprocess

Basic Erlang-like process support for Haskell

@hackage/festung

Remote multi-db SQLCipher server

@hackage/ki

A lightweight structured concurrency library

@hackage/monadIO

Overloading of concurrency variables

@hackage/conceit

Concurrent actions that may fail with a value.

@hackage/atomic-modify

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

@hackage/accelerate-bignum

Fixed-length large integer arithmetic for Accelerate

@hackage/join

Parallel Join Patterns with Guards and Propagation

@hackage/bounded-qsem

Bounded quantity semaphores.

@hackage/monad-schedule

A new, simple, composable concurrency abstraction.

@hackage/concurrent-extra

Extra concurrency primitives

@hackage/async-extras

Extra Utilities for the Async Library

@hackage/equeue

Application level triggered, and edge triggered event multiqueues.

@hackage/stm-orelse-io

Choose between the return value of an STM operation and an IO action.

@hackage/butter

Monad Transformer for Asyncronous Message Passing

@hackage/stm-chans

Additional types of channels for STM.

@hackage/timeout-control

Updatable timeouts as a Monad transformer

@hackage/hydra-print

NCurses interface to view multiple ByteString streams in parallel.

@hackage/stc-lang

A library for implicit, monadic dataflow parallelism

@hackage/semaphore-plus

Various concurrency abstractions built on top of semaphores

@hackage/ttrie

Contention-free STM hash map

@hackage/speculation

A framework for safe, programmable, speculative parallelism

@hackage/arbor-lru-cache

LRU cache based on STM

@hackage/future

Supposed to mimics and enhance proposed C++ "future" features

@hackage/concurrent-sa

Concurrent simulated annealing system.

@hackage/kickchan

Kick Channels: bounded channels with non-blocking writes

@hackage/linear-accelerate

Lifting linear vector spaces into Accelerate

@hackage/accelerate-io

Convert between Accelerate arrays and raw pointers

@hackage/lub

information operators: least upper bound (lub) and greatest lower bound (glb)

@hackage/theatre-dev

Minimalistic actor library experiments

@hackage/unamb

Unambiguous choice

@hackage/spectacle

Embedded specification language & model checker in Haskell.

@hackage/rawlock

A writer-biased RAW lock.

@hackage/unamb-custom

Functional concurrency with unamb using a custom scheduler.

@hackage/alarmclock

Wake up and perform an action at a certain time.

@hackage/strict-mvar

Strict MVars for IO and IOSim

@hackage/fraxl

Cached and parallel data fetching.

@hackage/persistent-map

A thread-safe (STM) persistency interface for finite map types.

@hackage/Mecha

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

@hackage/AVar

Mutable variables with Exception handling and concurrency support.

@hackage/Workflow

Workflow patterns over a monad for thread state logging & recovery

@hackage/actor

Actors with multi-headed receive clauses

@hackage/chp

An implementation of concurrency ideas from Communicating Sequential Processes

@hackage/caf

A library of Concurrency Abstractions using Futures.

@hackage/token-bucket

Rate limiter using lazy bucket algorithm

@hackage/lifted-async

Run lifted IO operations asynchronously and wait for their results

@hackage/ivar-simple

Write once concurrency primitives.

@hackage/kazura-queue

Fast concurrent queues much inspired by unagi-chan

@hackage/hint-server

A server process that runs hint.

@hackage/pipes-concurrency

Concurrency for the pipes ecosystem

@hackage/thread-hierarchy

Simple Haskell thread management in hierarchical manner

@hackage/streamly-examples

Examples for Streamly

@hackage/extensible-effects-concurrent

Message passing concurrency as extensible-effect

@hackage/concurrent-supply

A fast concurrent unique identifier supply with a pure API

@hackage/tag-bits

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

@hackage/stmcontrol

Control communication among retrying transactions

@hackage/concurrency

Typeclasses, functions, and data types for concurrency and STM.

@hackage/ticker

A concurrent utility inspired by Ticker in golang

@hackage/thespian

Lightweight Erlang-style actors for Haskell

@hackage/multisetrewrite

Multi-set rewrite rules with guards and a parallel execution scheme

@hackage/streamly

Streaming data pipelines with declarative concurrency

@hackage/chaselev-deque

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

@hackage/coroutine-enumerator

Bridge between the monad-coroutine and enumerator packages.

@hackage/PriorityChansConverger

Read single output from an array of inputs - channels with priorities

@hackage/mech

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

@hackage/pipes-cliff

Streaming to and from subprocesses using Pipes

@hackage/lvish

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

@hackage/promises

Lazy demand-driven promises

@hackage/singnal

Singnal

@hackage/iothread

run IOs in a single thread

@hackage/temporal-sdk-core

@hackage/immortal-worker

Create worker threads that logs exceptions and restarts.

@hackage/chan-split

Concurrent Chans as read/write pairs. Also provides generic Chan pair class.

@hackage/unsafe-promises

Create pure futures using lazy IO.

@hackage/bounded-tchan

Bounded Transactional channels (queues)

@hackage/HasChor

Functional choreographic programming in Haskell

@hackage/chp-mtl

MTL class instances for the CHP library

@hackage/scotty-haxl

Combine scotty and haxl

@hackage/legion

Distributed, stateful, homogeneous microservice framework.

@hackage/orderly-workers

Fork concurrent worker threads and produce ordered results

@hackage/event

Monoidal, monadic and first-class events

@hackage/spawn

Tiny library for concurrent computations

@hackage/haskell-bee-pgmq

PostgreSQL/PGMQ broker implementation for haskell-bee

@hackage/CSPM-cspm

cspm command line tool for analyzing CSPM specifications.

@hackage/async

Run IO operations asynchronously and wait for their results

@hackage/bitset-word8

Space efficient set of Word8 and some pre-canned sets useful for parsing HTTP

@hackage/hactors

Practical actors for Haskell.

@hackage/stm-io-hooks

Launch your IO-actions from within the STM monad

@hackage/thread-utils-context

Garbage-collected thread local storage

@hackage/dejafu

A library for unit-testing concurrent programs.

@hackage/mechs

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

@hackage/haskell-bee-tests

Reusable test suite for any haskell-bee Broker implementation

@hackage/concurrent-split

MVars and Channels with distinguished input and output side

@hackage/throttled

Concurrent processing of a Foldable, throttled by CPU count.

@hackage/stm-split

TMVars, TVars and TChans with distinguished input and output side

@hackage/CSPM-CoreLanguage

Definition of a CSP core-language.

@hackage/mvc

Model-view-controller

@hackage/haskell-bee-redis

Redis broker implementation for haskell-bee

@hackage/promise

A monadic interface for async

@hackage/Graph500

Graph500 benchmark-related definitions and data set generator.

@hackage/flush-queue

Concurrent bouded blocking queues optimized for flushing. Both IO and STM implementations.

@hackage/ki-unlifted

A lightweight structured concurrency library

@hackage/rwlock

Multiple-read / single-write locks

@hackage/lockfree-queue

Michael and Scott lock-free queues.

@hackage/immortal-queue

Build a pool of queue-processing worker threads.

@hackage/ThreadObjects

Mutable objects that reside in their own threads.

@hackage/Concurrent-Cache

A Cached variable for IO functions.

@hackage/Mechs

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

@hackage/futures

Simple and fast implementation of Future

@hackage/forkable-monad

An implementation of forkIO for monad stacks.

@hackage/timers-updatable

timers which are updatable in the remaining time

@hackage/cgroup-rts-threads

A container-/cgroup-aware substitute for the GHC RTS `-N` flag

@hackage/coroutine-iteratee

Bridge between the monad-coroutine and iteratee packages.

@hackage/typed-duration

Thread delay and timeout functions with typed arguments

@hackage/unagi-bloomfilter

A fast, cache-efficient, concurrent bloom filter

@hackage/par-traverse

Traverse a directory in parallel

@hackage/inc-ref

A STM reference useful for incremental computing

@hackage/sync

A fast implementation of synchronous channels with a CML-like API

@hackage/parallel-tree-search

Parallel Tree Search

@hackage/expiring-mvar

Create values which expire after a period of time.

@hackage/hlogger

Simple, concurrent, extendable and easy-to-use logging library

@hackage/polysemy-process

Polysemy effects for system processes

@hackage/monad-coroutine

Coroutine monad transformer for suspending and resuming monadic computations

@hackage/clocked

timer functionality to clock IO commands

@hackage/cfuture

A Future type that is easy to represent and handle in C/C++.

@hackage/cml

Events and Channels as in Concurrent ML

@hackage/hactor

Lightweight Erlang-style actors for Haskell.

@hackage/unique

Fully concurrent unique identifiers

@hackage/threads

Fork threads and wait for their result

@hackage/restricted-workers

Running worker processes under system resource restrictions

@hackage/mstate

MState: A consistent State monad for concurrent applications.

@hackage/nano-erl

Small library for Erlang-style actor semantics

@hackage/split-channel

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

@hackage/stm-channelize

Transactional I/O for duplex streams

@hackage/unagi-chan

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

@hackage/unclogging

a library which implements easy, concurrent and pretty logging

@hackage/midair

Hot-swappable FRP

@hackage/tbox

Transactional variables and data structures with IO hooks