Haskell Control

Compositional pipelines

Networked stream transducers

Making composable programs with multithreading, events and distributed computing

Anonymous records

Principled practical FRP

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

Monads for free

Categories

Denotative, locally stateful programming DSL & platform

Compositional pipelines

An Alternative to Monad Transformers

The Cloud Haskell Application Platform

Composable, streaming, and efficient left folds

Monad classes, using functional dependencies

Safe, consistent, and easy exception handling

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

A typeclass-based Prelude.

The Cloud Haskell Application Platform

Remote execution and map-reduce

Bidirectional state monad transformer

Generalized bananas, lenses and barbed wire

An either monad transformer

Retry combinators for monadic actions that may fail

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

Implementation of difficult monads made easy with operational semantics.

Parallel programming library

Deep evaluation of data structures

Simplified error-handling

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

Tutorial for the lens library

Lift control operations, like exception catching, through monad transformers

Coveralls.io support for Haskell.

Composable objects

Extensible optionally-pure exceptions

Implementation of effect system for Haskell.

A library for writing Imperative style haskell.

A natural transformation package.

Parsing infrastructure for the pipes ecosystem

Serializable closures for distributed programming.

Monad morphisms

Distributed systems execution emulation

put if statements within type constraints

Modular type class machinery for monad transformer stacks.

Categories

Safety for the pipes ecosystem

Contravariant functors

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

List monad transformer

Workflow patterns over a monad for thread state logging & recovery

Typeclasses for representing monad transformer unlifting

Typeclasses for representing monad transformer unlifting

Embeds effect systems into Haskell using graded monads

Scientific workflow management system

Monad transformers and classes

Embeds effect systems into Haskell using parameteric effect monads

A monad transformer for tracing provenience of errors

Compositional, type-safe, polymorphic static values and closures

Haskell distributed parallel Haskell

Random-number generation monad.

Some convenience facilities for hoisting errors into a monad

Add prefixes to your monad-logger output

A free monad based on the Wadler/Leijen pretty printer

Explicitly typed, checked exceptions with stack traces

Monadic loops

A convenient wrapper around EKG metrics

lifted IO operations from the base library

ByteString support for pipes

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

FRP through value streams and monadic splines.

A Typeable-free implementation of extensible effects

Simple zero-configuration backend for Cloud Haskell

Merged into 'speculation'. Use that instead.

Cloud Haskell Extras

Manipulate FSMs and store them in PostgreSQL.

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

Constraint Programming

A monad for managed values

Exhaustive pattern matching using lenses, traversals, and prisms

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

The Cloud Haskell Application Platform

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

IO without any non-error, synchronous exceptions

Codecov.io support for Haskell.

van Laarhoven encoded Free Monad with Extensible Effects

a parallel implementation of logic programming using distributed tree exploration

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

Daemons in Haskell made fun and easy

Cloud Haskell Async API

Cloud Haskell Extended Process Registry

Orphan instances for MonadBase and MonadBaseControl.

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

Initial project template from stack

product-profunctors

Functional reactive programming library

An undead monad

ASCII-fied arrow notation

Library for parallel programming in the Intel Concurrent Collections paradigm.

Extra utilities for pipes

Supervisors for The Cloud Haskell Application Platform

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

A color pretty printer with terminfo support

Execution Framework for The Cloud Haskell Application Platform

...

more flexible mtl

Quiver finite stream processing library

Playing with reified categorical composition

fast and simple operational monad

Arrow based stream transducers

Group streams into substreams

A quasi-quoter for typeful results of regex captures.

All hail the Royal Monad!

Indexed Types

An embedding of quantum computation as a Haskell arrow

An applicative monad that batches commands for later more efficient execution

Repackages standard type classes with the ConstraintKinds extension

Indexed functors, monads and comonads that require extensions to Haskell98

Instances for Applicative

Haskell 98 invariant functors

Pure logger typeclass and monad transformer

Folding data with multiple named passes

ListT done right

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

Exception safe resource management with dynamic regions

Lift computations from the bottom of a transformer stack

Memoization monad transformer

Rematch support for unordered containers

Explicit Sharing of Monadic Effects

A class for monads which can keep a monadic call trace

Basic conditional and boolean operators with monadic variants.

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

Catching all exceptions from within an enclosed computation

Computational Effects

Simple, Fair and Terminating Backtracking Monad

A basic library for rate-limiting IO actions.

A breadth-first list monad.

Resumption and reactive resumption monads for Haskell.

Conduit adapters

A few pipes to control the timing of yields

Deep evaluation of data structures without NFData

A monad for using CryptoRandomGen

Free monads and monad transformers

Lens implementation. It is more small but adequately.

Haskell98 indexed functors, monads, comonads

Transducers for foldl folds.

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

Template Haskell based deriver for optimised NFData instances

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

GHC.Generics-based Control.DeepSeq.rnf implementation

Helpers for Control.Exception.assert

The Cloud Haskell implementation of Erlang/OTP gen_statem

WriteT and RWST monad transformers

Monad transformers that mirror worker-wrapper transformations.

Fast imperative-style loops

Open recursion for when you need it

Non-Determinism Monad for Tree Search

List arrows for Haskell.

Stateful supply monad.

Simple monad transformer for imperative-style loops

A faster variant of the RWS monad transformers.

A higher-level interface to using concurrency with pipes

Constraint Functional-Logic Programming in Haskell

MTL classes without the functional dependency

Optics for xml-conduit and html-conduit

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

Instance derivers for newtype wrappers

Specific levels of monad transformers

Non-Determinism Monad for Level-Wise Search

A type class for monads with references using functional dependencies.

Better, more general Prelude exporting common utilities.

Initial project template from stack

Composable replication schemes of applicative functors

A library for tracking the consumption of a lazy ByteString

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

...

Pipes integration for ZeroMQ messaging

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

MonadWriter orphan instances for writer-cps-transformers

Semigroupoids that depend on PolyKinds

Extra utility functions for working with monads

Package implementing core logic for refreshing of expiring access tokens

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

A weighted nondeterministic search monad

Selectors for reading and updating data.

Free monad transformers

A new Prelude featuring first class modules

An extension removing the sequentiality from monads

A preprocessor for generating monadic call traces

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

Type classes and monads for unchecked extensible exceptions.

Arrows with holes.

MTL-like library using TVars

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

A type class for monads with references using type families.

Arrow Transformer Library

Provides a MonadST class

Utilities for working with ArrowApply instances more naturally

Extract underlying monads from monad transformers

Monadic functions which provide Choice and Parallelism.

Parser Effect for the Control.Effects Library

Interfacing pipes with foldl folds.

ST monad with efficient explicit errors

Just size Operational Monad implementation.

Lift control operations like exception catching through monad transformers

Adapter to stream over HTTP(s) with quiver

Strict Identity Monad, handy for writing fast code!

Immediately lifts to a desired level

...

Monads with an unsaveInterleaveIO-like operation.

Stream Processer Arrow

Generalized stream processors

Parallel Tree Search

Reversibly allow monad transformer stacks to run in IO

A nullary type class for partial functions

Various proxies for streaming data into vectors

Permutations of effectful computations

Reverse State monad transformer

A template haskell deriver to create Control.Newtype instances.

Constraint Programming

The Observer pattern

Quiver combinators for cellular CSV data processing

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

Generalizing lift to monad stacks

Monadic loops for STM

Skeleton library around the IO monad.

Attoparsec and foldl-transduce integration.

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

Fork of the monad-parallel package using monad-control

Invariants and contract monitoring

Quiver combinators for cellular data processing

Code review tool

MonadWriter orphan instances for writer-cps-transformers

An extensible log effect using extensible-effects

Group and chunk values within a Quiver

Syntactic sugar improving 'assert' and 'error'

Universal converter between values of different types

a Paralell-DEVS implementaion based on distributed-process

A transformer for generic requests

a tiny library for using shared lens fields

Writer monad which uses semiring constraint

Quiver combinators for bytestring streaming

Bridge between Quiver and Iteratee paradigms

Useful combinators for boolean expressions

Lens instances for the stricter CPS WriterT and RWST

Applicative/Arrow for resource estimation and progress tracking.

Safe, checked exceptions

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

Package implementing core logic for refreshing of expiring data.

Exhaustivity Checking Library

A bidirectional bridge between pipes and iteratees

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

Pipes-based combinators for cellular data processing

A Library for Writing Multi-Pass Algorithms.

Typeclasses and instances for monads with constraints.

Monads-tf instances for the RegionT monad transformer

An applicative functor to manage successors

Abstract Application Interface.

mtl instances for the RegionT monad transformer

indexed monads for free

A monad and monadic transformer providing "abort" functionality

Graph indexed monads.

Efficient pipes-based cellular CSV codec

Extra utilities for alternatives

Control flow data type and monad transformer.

WriteT and RWST monad transformers (Reexport with all dependencies)

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

Essentially the Maybe type with error messages.

A variation on the ST monad with two type parameters.

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

Some conviencience type functions for manipulating constraints.

Allows instances for Category, Arrow and ArrowChoice for Pipes.

Extra functions for Control.Arrow

Miscellaneous utilities for pipes, required by glazier-tutorial

Handy functions when using transformers

MFunctor instance for CPS style WriterT and RWST

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