Haskell Control

Making composable programs with multithreading, events and distributed computing

Compositional pipelines

Networked stream transducers

Anonymous records

A fast ECS for game engine programming

Monad classes, using functional dependencies

Monads for free

An Alternative to Monad Transformers

Composable, streaming, and efficient left folds

Denotative, locally stateful programming DSL & platform

A typeclass-based Prelude.

Generalized bananas, lenses and barbed wire

Provide a classy prelude including common Yesod functionality.

Implementation of a friendly effect system for Haskell.

Safe, consistent, and easy exception handling

Type classes generalizing the functionality of the 'monad-par' library.

Categories

A library for expressing spreadsheet-like computations as the fixed-points of comonads.

Remote execution and map-reduce

Principled practical FRP

The Cloud Haskell Application Platform

Compositional pipelines

Retry combinators for monadic actions that may fail

An either monad transformer

Serializable closures for distributed programming.

The Cloud Haskell Application Platform

Contravariant functors

Parallel programming library

Bidirectional state monad transformer

The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)

An either-or-both data type & a generalized 'zip with padding' typeclass

Implementation of difficult monads made easy with operational semantics.

Simplified error-handling

Implementation of effect system for Haskell.

put if statements within type constraints

Lift control operations, like exception catching, through monad transformers

Deep evaluation of data structures

Extensible optionally-pure exceptions

An enhanced core prelude; a common foundation for alternate preludes.

Tutorial for the lens library

Composable objects

Coveralls.io support for Haskell.

Monad transformers and classes

Type-safe effectful state machines in Haskell

Monad morphisms

Embeds effect systems into Haskell using parameteric effect monads

Embeds effect systems into Haskell using graded monads

A library for writing Imperative style haskell.

Parsing infrastructure for the pipes ecosystem

A natural transformation package.

Categories

Safety for the pipes ecosystem

A convenient wrapper around EKG metrics

Typeclasses for representing monad transformer unlifting

Typeclasses for representing monad transformer unlifting

Type class for monads which carry the notion of the current time.

Distributed systems execution emulation

Scientific workflow management system

Modular type class machinery for monad transformer stacks.

Codecov.io support for Haskell.

Workflow patterns over a monad for thread state logging & recovery

List monad transformer

Just like monad-control, except less efficient, ...

Add prefixes to your monad-logger output

Some convenience facilities for hoisting errors into a monad

Monadic loops

Provides the region monad for safely opening and working with scarce resources.

Compositional, type-safe, polymorphic static values and closures

A free monad based on the Wadler/Leijen pretty printer

Initial project template from stack

Random-number generation monad.

Haskell distributed parallel Haskell

Functional reactive programming library

A monad transformer for tracing provenience of errors

Cloud Haskell Extras

An undead monad

Merged into 'speculation'. Use that instead.

The Cloud Haskell Application Platform

Cloud Haskell Async API

References which can be joined and on which lenses can be applied

lifted IO operations from the base library

FRP through value streams and monadic splines.

Explicitly typed, checked exceptions with stack traces

A monad for managed values

IO without any non-error, synchronous exceptions

Operational Applicative, Alternative, Monad and MonadPlus from free types.

ByteString support for pipes

Simple zero-configuration backend for Cloud Haskell

Indexed functors, monads and comonads that require extensions to Haskell98

A Typeable-free implementation of extensible effects

product-profunctors

Constraint Programming

Manipulate FSMs and store them in PostgreSQL.

Supervisors for The Cloud Haskell Application Platform

Daemons in Haskell made fun and easy

Exhaustive pattern matching using lenses, traversals, and prisms

more flexible mtl

a parallel implementation of logic programming using distributed tree exploration

A typeclass and set of functions for working with newtypes, with generics support.

a mirror image of some standard type classes, with methods of rank 2 types

van Laarhoven encoded Free Monad with Extensible Effects

An approach to managing composable effects, ala mtl/transformers/extensible-effects/Eff

A color pretty printer with terminfo support

Fast loops (for when GHC can't optimize forM_)

Memoization monad transformer

Orphan instances for MonadBase and MonadBaseControl.

Cloud Haskell Extended Process Registry

Extra utilities for pipes

Haskell98 indexed functors, monads, comonads

ListT done right

An applicative monad that batches commands for later more efficient execution

Library for parallel programming in the Intel Concurrent Collections paradigm.

...

Execution Framework for The Cloud Haskell Application Platform

Adapters between MonadIO and MonadBase IO.

Haskell 98 invariant functors

fast and simple operational monad

ASCII-fied arrow notation

Arrow based stream transducers

Quiver finite stream processing library

Group streams into substreams

An embedding of quantum computation as a Haskell arrow

Stateful supply monad.

Tools for functors from Hask^k to Hask

Folding data with multiple named passes

Playing with reified categorical composition

Computational Effects

Indexed Types

A quasi-quoter for typeful results of regex captures.

All hail the Royal Monad!

Exception safe resource management with dynamic regions

A simple type class for success/failure computations. (deprecated)

ST monad with efficient explicit errors

Constrained clones of the category-theory type classes, using ConstraintKinds.

WriteT and RWST monad transformers

Repackages standard type classes with the ConstraintKinds extension

Universal algebra approach to free algebras including higher kinded algebraic structures like functors, applicative functors or monads.

Explicit Sharing of Monadic Effects

Rematch support for unordered containers

Lift computations from the bottom of a transformer stack

like mtl's ReaderT / WriterT / StateT, but more than one contained value/type.

Simple, Fair and Terminating Backtracking Monad

Instances for Applicative

A faster variant of the RWS monad transformers.

A monad transformer that turns event processing into co-routine programming.

Catching all exceptions from within an enclosed computation

A basic library for rate-limiting IO actions.

A few pipes to control the timing of yields

Monad (and transformer) for deferred-effect pure prompt-response queries

A class for monads which can keep a monadic call trace

A nullary type class for partial functions

Bifunctors over monad transformers.

...

A higher-level interface to using concurrency with pipes

The Cloud Haskell implementation of Erlang/OTP gen_statem

GHC.Generics-based Control.DeepSeq.rnf implementation

A breadth-first list monad.

MonadWriter orphan instances for writer-cps-transformers

Selectors for reading and updating data.

Basic conditional and boolean operators with monadic variants.

Lens implementation. It is more small but adequately.

Pure logger typeclass and monad transformer

Initial project template from stack

A monad for using CryptoRandomGen

Concurrency library in the style of Erlang/OTP

Provides a MonadST class

Conduit adapters

A library to mock the current time.

Semigroupoids that depend on PolyKinds

Free monads and monad transformers

Pipes integration for ZeroMQ messaging

Optics for xml-conduit and html-conduit

Template Haskell based deriver for optimised NFData instances

Non-Determinism Monad for Tree Search

Write stream processing computations with side effects in a series of tubes.

Composable replication schemes of applicative functors

Monad transformers that mirror worker-wrapper transformations.

Extra utility functions for working with monads

Deep evaluation of data structures without NFData

Simple monad transformer for imperative-style loops

Transducers for foldl folds.

Reverse State monad transformer

Safe, checked exceptions

A new Prelude featuring first class modules

Resumption and reactive resumption monads for Haskell.

Fast imperative-style loops

Helpers for Control.Exception.assert

MTL classes without the functional dependency

Package implementing core logic for refreshing of expiring access tokens

Type classes and monads for unchecked extensible exceptions.

List arrows for Haskell.

Open recursion for when you need it

Constraint Functional-Logic Programming in Haskell

Generalized stream processors

A type class for monads with references using functional dependencies.

A library for tracking the consumption of a lazy ByteString

throwable-exceptions gives the exception's value constructors

Non-Determinism Monad for Level-Wise Search

Specific levels of monad transformers

Instance derivers for newtype wrappers

Universal converter between values of different types

MTL-like library using TVars

Immediately lifts to a desired level

Strict Identity Monad, handy for writing fast code!

A class for monads which can fail with an error. (deprecated)

Free categories

A simple job scheduler, which just runs some IO action at a given time.

A type class for monads with references using type families.

An extensible log effect using extensible-effects

Various proxies for streaming data into vectors

...

A monad and monad transformer for pushing things onto a stack very fast.

Convert JuicyPixel images into RGBA format, flip, trim and so on

Arrows with holes.

A preprocessor for generating monadic call traces

Parser Effect for the Control.Effects Library

The Observer pattern

Arrow Transformer Library

Utilities for working with ArrowApply instances more naturally

A port of the package 'resourcet' for extensible effects.

Free monad transformers

An extension removing the sequentiality from monads

Session types library

MonadWriter orphan instances for writer-cps-transformers

Constraint Programming

WriteT and RWST monad transformers (Reexport with all dependencies)

Simple control structure to re-try an action with exponential backoff

Interfacing pipes with foldl folds.

A weighted nondeterministic search monad

Extensible records and polymorphic variants.

A template haskell deriver to create Control.Newtype instances.

Just size Operational Monad implementation.

Permutations of effectful computations

Package implementing core logic for refreshing of expiring data.

indexed monads for free

Adapter to stream over HTTP(s) with quiver

An applicative functor to manage successors

Monads with an unsaveInterleaveIO-like operation.

Lens instances for the stricter CPS WriterT and RWST

Useful combinators for boolean expressions

Parallel Tree Search

Session types distributed

Reversibly allow monad transformer stacks to run in IO

Lift control operations like exception catching through monad transformers

Extract underlying monads from monad transformers

Stream Processer Arrow

Skeleton library around the IO monad.

Monadic loops for STM

Attoparsec and foldl-transduce integration.

Quiver combinators for cellular CSV data processing

Generalizing lift to monad stacks

Monadic functions which provide Choice and Parallelism.

Monad transformer for exit codes

Quiver combinators for cellular data processing

Invariants and contract monitoring

The VarMonad typeclass, generalizing types of references.

Code review tool

mtl instances for the RegionT monad transformer

a tiny library for using shared lens fields

Syntactic sugar improving 'assert' and 'error'

Group and chunk values within a Quiver

Monads-tf instances for the RegionT monad transformer

A transformer for generic requests

A monad and monadic transformer providing "abort" functionality

Control flow data type and monad transformer.

Reactively combines Producers so that a value is yielded as soon as possible.

a Paralell-DEVS implementaion based on distributed-process

A bidirectional bridge between pipes and iteratees

Applicative/Arrow for resource estimation and progress tracking.

Exhaustivity Checking Library

Allows storing different resource-releasing actions together.

A stricter writer, which uses StateT in order to avoid space leaks.

Bridge between Quiver and Iteratee paradigms

Quiver combinators for bytestring streaming

...

Writer monad which uses semiring constraint

Constraint Handling Rules

Write applicative programs in direct style (generalizes idiom brackets).

Pipes-based combinators for cellular data processing

Miscellaneous utilities for pipes, required by glazier-tutorial

Handy functions when using transformers

Abstract Application Interface.

Pipes to group by any delimiter (such as lines with carriage returns)

A Library for Writing Multi-Pass Algorithms.

Typeclasses and instances for monads with constraints.

get stuff out of stuff

Fork of the monad-parallel package using monad-control

Haskell operator `g ... f = \x1 .. xn -> g (f x1 .. xn)`.

Allows instances for Category, Arrow and ArrowChoice for Pipes.

A series of type families and constraints for "indexable" types.

A polymorphic, type-safe, json-structured tracing library

Efficient pipes-based cellular CSV codec

Graph indexed monads.

Extra utilities for alternatives

Guard monadic computations with cleanup actions

Bracket-like functions for ExceptT over IO monad.

Essentially the Maybe type with error messages.

A variation on the ST monad with two type parameters.

ByteString support for machines

Extra functions for Control.Arrow

Some conviencience type functions for manipulating constraints.

Serialisable static pointers to functions

An extensible effects library

A library accelerates imperative style programming.

incremental folds

The trivial monad and comonad

A useful type for collecting error messages.

Sensible conversions between some of the monad transformers

Control an internal monad execution for trace generation, backtrakcking, ...

Break from a loop

MFunctor instance for CPS style WriterT and RWST

An orphan Eq instance for ErrorCall

Distinguish between synchronous and asynchronous exceptions