Haskell Control

Making composable programs with multithreading, events and distributed computing

Compositional pipelines

Networked stream transducers

Anonymous records

Monad classes, using functional dependencies

Monads for free

A fast ECS for game engine programming

Generalized bananas, lenses and barbed wire

An Alternative to Monad Transformers

Provide a classy prelude including common Yesod functionality.

A typeclass-based Prelude.

Denotative, locally stateful programming DSL & platform

Implementation of a friendly effect system for Haskell.

Composable, streaming, and efficient left folds

Categories

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

Safe, consistent, and easy exception handling

Remote execution and map-reduce

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

Principled practical FRP

Compositional pipelines

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

Retry combinators for monadic actions that may fail

Serializable closures for distributed programming.

The Cloud Haskell Application Platform

An either monad transformer

The Cloud Haskell Application Platform

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

Parallel programming library

Bidirectional state monad transformer

Contravariant functors

Implementation of difficult monads made easy with operational semantics.

Extensible optionally-pure exceptions

put if statements within type constraints

Simplified error-handling

Lift control operations, like exception catching, through monad transformers

Deep evaluation of data structures

Implementation of effect system for Haskell.

Tutorial for the lens library

Distributed systems execution emulation

Monad morphisms

Composable objects

Monad transformers and classes

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

Type-safe effectful state machines in Haskell

Coveralls.io support for Haskell.

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

A library for writing Imperative style haskell.

Embeds effect systems into Haskell using graded monads

Parsing infrastructure for the pipes ecosystem

Embeds effect systems into Haskell using parameteric effect monads

Categories

A natural transformation package.

Safety for the pipes ecosystem

Typeclasses for representing monad transformer unlifting

Codecov.io support for Haskell.

Typeclasses for representing monad transformer unlifting

Scientific workflow management system

A convenient wrapper around EKG metrics

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

Add prefixes to your monad-logger output

Modular type class machinery for monad transformer stacks.

Initial project template from stack

Compositional, type-safe, polymorphic static values and closures

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

Haskell distributed parallel Haskell

Workflow patterns over a monad for thread state logging & recovery

List monad transformer

Monadic loops

Random-number generation monad.

Some convenience facilities for hoisting errors into a monad

A monad transformer for tracing provenience of errors

Functional reactive programming library

A free monad based on the Wadler/Leijen pretty printer

An undead monad

lifted IO operations from the base library

Cloud Haskell Async API

The Cloud Haskell Application Platform

Cloud Haskell Extras

Explicitly typed, checked exceptions with stack traces

Merged into 'speculation'. Use that instead.

FRP through value streams and monadic splines.

Simple zero-configuration backend for Cloud Haskell

A monad for managed values

ByteString support for pipes

IO without any non-error, synchronous exceptions

product-profunctors

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

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

Constraint Programming

Indexed functors, monads and comonads that require extensions to Haskell98

Manipulate FSMs and store them in PostgreSQL.

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

Supervisors for The Cloud Haskell Application Platform

A Typeable-free implementation of extensible effects

Daemons in Haskell made fun and easy

Exhaustive pattern matching using lenses, traversals, and prisms

Haskell98 indexed functors, monads, comonads

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

a parallel implementation of logic programming using distributed tree exploration

van Laarhoven encoded Free Monad with Extensible Effects

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

more flexible mtl

Memoization monad transformer

A color pretty printer with terminfo support

An applicative monad that batches commands for later more efficient execution

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

ListT done right

Haskell 98 invariant functors

Extra utilities for pipes

Cloud Haskell Extended Process Registry

Orphan instances for MonadBase and MonadBaseControl.

Tools for functors from Hask^k to Hask

...

Library for parallel programming in the Intel Concurrent Collections paradigm.

Adapters between MonadIO and MonadBase IO.

fast and simple operational monad

Execution Framework for The Cloud Haskell Application Platform

Group streams into substreams

ASCII-fied arrow notation

A faster variant of the RWS monad transformers.

Quiver finite stream processing library

An embedding of quantum computation as a Haskell arrow

Arrow based stream transducers

Playing with reified categorical composition

Lift computations from the bottom of a transformer stack

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

Folding data with multiple named passes

A quasi-quoter for typeful results of regex captures.

Computational Effects

WriteT and RWST monad transformers

Indexed Types

All hail the Royal Monad!

Stateful supply monad.

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

Exception safe resource management with dynamic regions

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

Explicit Sharing of Monadic Effects

ST monad with efficient explicit errors

Rematch support for unordered containers

Catching all exceptions from within an enclosed computation

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

A breadth-first list monad.

Simple, Fair and Terminating Backtracking Monad

MonadWriter orphan instances for writer-cps-transformers

Instances for Applicative

A basic library for rate-limiting IO actions.

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

Repackages standard type classes with the ConstraintKinds extension

A monad for using CryptoRandomGen

A few pipes to control the timing of yields

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

A nullary type class for partial functions

A higher-level interface to using concurrency with pipes

The Cloud Haskell implementation of Erlang/OTP gen_statem

Bifunctors over monad transformers.

...

A class for monads which can keep a monadic call trace

A new Prelude featuring first class modules

Selectors for reading and updating data.

A library to mock the current time.

Concurrency library in the style of Erlang/OTP

Basic conditional and boolean operators with monadic variants.

Reverse State monad transformer

GHC.Generics-based Control.DeepSeq.rnf implementation

Type classes and monads for unchecked extensible exceptions.

Semigroupoids that depend on PolyKinds

Conduit adapters

Initial project template from stack

Helpers for Control.Exception.assert

Free monads and monad transformers

Pure logger typeclass and monad transformer

Various proxies for streaming data into vectors

Provides a MonadST class

Lens implementation. It is more small but adequately.

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

Monad transformers that mirror worker-wrapper transformations.

Optics for xml-conduit and html-conduit

Non-Determinism Monad for Tree Search

Template Haskell based deriver for optimised NFData instances

Extra utility functions for working with monads

Composable replication schemes of applicative functors

Pipes integration for ZeroMQ messaging

Deep evaluation of data structures without NFData

Constraint Functional-Logic Programming in Haskell

Simple monad transformer for imperative-style loops

Safe, checked exceptions

MTL classes without the functional dependency

Fast imperative-style loops

Resumption and reactive resumption monads for Haskell.

Transducers for foldl folds.

Package implementing core logic for refreshing of expiring access tokens

List arrows for Haskell.

Generalized stream processors

A type class for monads with references using functional dependencies.

Open recursion for when you need it

A type class for monads with references using type families.

Strict Identity Monad, handy for writing fast code!

MTL-like library using TVars

Non-Determinism Monad for Level-Wise Search

throwable-exceptions gives the exception's value constructors

Specific levels of monad transformers

Free categories

A library for tracking the consumption of a lazy ByteString

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

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

Instance derivers for newtype wrappers

Immediately lifts to a desired level

Universal converter between values of different types

Arrows with holes.

An extensible log effect using extensible-effects

...

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

Constraint Handling Rules

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

A preprocessor for generating monadic call traces

An extension removing the sequentiality from monads

Arrow Transformer Library

Extensible records and polymorphic variants.

Constraint Programming

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

The Observer pattern

Interfacing pipes with foldl folds.

MonadWriter orphan instances for writer-cps-transformers

mtl instances for the RegionT monad transformer

Monads-tf instances for the RegionT monad transformer

A weighted nondeterministic search monad

Utilities for working with ArrowApply instances more naturally

A template haskell deriver to create Control.Newtype instances.

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

WriteT and RWST monad transformers (Reexport with all dependencies)

Free monad transformers

Session types library

Parser Effect for the Control.Effects Library

Permutations of effectful computations

Package implementing core logic for refreshing of expiring data.

Reversibly allow monad transformer stacks to run in IO

Lens instances for the stricter CPS WriterT and RWST

Session types distributed

indexed monads for free

Adapter to stream over HTTP(s) with quiver

Useful combinators for boolean expressions

Parallel Tree Search

Monads with an unsaveInterleaveIO-like operation.

An applicative functor to manage successors

Just size Operational Monad implementation.

Quiver combinators for cellular data processing

Monadic loops for STM

Stream Processer Arrow

Extract underlying monads from monad transformers

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

Invariants and contract monitoring

The VarMonad typeclass, generalizing types of references.

Monad transformer for exit codes

Quiver combinators for cellular CSV data processing

Attoparsec and foldl-transduce integration.

Skeleton library around the IO monad.

Monadic functions which provide Choice and Parallelism.

Lift control operations like exception catching through monad transformers

Generalizing lift to monad stacks

Code review tool

A transformer for generic requests

a Paralell-DEVS implementaion based on distributed-process

Graph indexed monads.

a tiny library for using shared lens fields

A monad and monadic transformer providing "abort" functionality

Syntactic sugar improving 'assert' and 'error'

Abstract Application Interface.

Control flow data type and monad transformer.

Group and chunk values within a Quiver

A bidirectional bridge between pipes and iteratees

Quiver combinators for bytestring streaming

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

...

Allows storing different resource-releasing actions together.

Bridge between Quiver and Iteratee paradigms

Writer monad which uses semiring constraint

Applicative/Arrow for resource estimation and progress tracking.

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

Exhaustivity Checking Library

Allows instances for Category, Arrow and ArrowChoice for Pipes.

A Library for Writing Multi-Pass Algorithms.

Miscellaneous utilities for pipes, required by glazier-tutorial

Handy functions when using transformers

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

Efficient pipes-based cellular CSV codec

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

Pipes-based combinators for cellular data processing

Typeclasses and instances for monads with constraints.

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

get stuff out of stuff

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

Fork of the monad-parallel package using monad-control

Essentially the Maybe type with error messages.

ByteString support for machines

Extra functions for Control.Arrow

Extra utilities for alternatives

A variation on the ST monad with two type parameters.

Bracket-like functions for ExceptT over IO monad.

Guard monadic computations with cleanup actions

Some conviencience type functions for manipulating constraints.

Serialisable static pointers to functions

An extensible effects library

The trivial monad and comonad

Sensible conversions between some of the monad transformers

incremental folds

Distinguish between synchronous and asynchronous exceptions

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

A useful type for collecting error messages.

An orphan Eq instance for ErrorCall

A library accelerates imperative style programming.

MFunctor instance for CPS style WriterT and RWST

Break from a loop