Haskell Control

Compositional pipelines

Networked stream transducers

Making composable programs with multithreading, events and distributed computing

Anonymous records

Principled practical FRP

Monads for free

Categories

Denotative, locally stateful programming DSL & platform

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

Compositional pipelines

Composable, streaming, and efficient left folds

An Alternative to Monad Transformers

The Cloud Haskell Application Platform

A typeclass-based Prelude.

Monad classes, using functional dependencies

Safe, consistent, and easy exception handling

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

The Cloud Haskell Application Platform

Generalized bananas, lenses and barbed wire

Bidirectional state monad transformer

Remote execution and map-reduce

An either monad transformer

Retry combinators for monadic actions that may fail

Deep evaluation of data structures

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

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

Composable objects

Implementation of effect system for Haskell.

Parallel programming library

Implementation of difficult monads made easy with operational semantics.

Simplified error-handling

Coveralls.io support for Haskell.

Serializable closures for distributed programming.

Lift control operations, like exception catching, through monad transformers

Tutorial for the lens library

Extensible optionally-pure exceptions

A natural transformation package.

A library for writing Imperative style haskell.

Parsing infrastructure for the pipes ecosystem

put if statements within type constraints

Monad morphisms

Distributed systems execution emulation

Typeclasses for representing monad transformer unlifting

Typeclasses for representing monad transformer unlifting

Safety for the pipes ecosystem

Monad transformers and classes

List monad transformer

Contravariant functors

Categories

Modular type class machinery for monad transformer stacks.

Embeds effect systems into Haskell using graded monads

Embeds effect systems into Haskell using parameteric effect monads

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

Workflow patterns over a monad for thread state logging & recovery

Scientific workflow management system

Add prefixes to your monad-logger output

A monad transformer for tracing provenience of errors

Random-number generation monad.

Some convenience facilities for hoisting errors into a monad

Haskell distributed parallel Haskell

Compositional, type-safe, polymorphic static values and closures

A free monad based on the Wadler/Leijen pretty printer

A convenient wrapper around EKG metrics

Explicitly typed, checked exceptions with stack traces

Monadic loops

ByteString support for pipes

lifted IO operations from the base library

An undead monad

A Typeable-free implementation of extensible effects

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

Merged into 'speculation'. Use that instead.

A monad for managed values

FRP through value streams and monadic splines.

Simple zero-configuration backend for Cloud Haskell

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

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

Codecov.io support for Haskell.

Manipulate FSMs and store them in PostgreSQL.

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

Functional reactive programming library

Constraint Programming

Cloud Haskell Async API

Cloud Haskell Extras

Exhaustive pattern matching using lenses, traversals, and prisms

The Cloud Haskell Application Platform

Initial project template from stack

product-profunctors

van Laarhoven encoded Free Monad with Extensible Effects

IO without any non-error, synchronous exceptions

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

more flexible mtl

Cloud Haskell Extended Process Registry

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

A color pretty printer with terminfo support

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

Orphan instances for MonadBase and MonadBaseControl.

ASCII-fied arrow notation

Library for parallel programming in the Intel Concurrent Collections paradigm.

Extra utilities for pipes

...

fast and simple operational monad

Execution Framework for The Cloud Haskell Application Platform

An applicative monad that batches commands for later more efficient execution

Quiver finite stream processing library

Supervisors for The Cloud Haskell Application Platform

Group streams into substreams

Playing with reified categorical composition

A quasi-quoter for typeful results of regex captures.

Indexed Types

All hail the Royal Monad!

Arrow based stream transducers

Folding data with multiple named passes

Repackages standard type classes with the ConstraintKinds extension

Indexed functors, monads and comonads that require extensions to Haskell98

An embedding of quantum computation as a Haskell arrow

Instances for Applicative

Rematch support for unordered containers

Exception safe resource management with dynamic regions

Computational Effects

ListT done right

Pure logger typeclass and monad transformer

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

Explicit Sharing of Monadic Effects

Memoization monad transformer

Haskell 98 invariant functors

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

A class for monads which can keep a monadic call trace

ST monad with efficient explicit errors

Lift computations from the bottom of a transformer stack

Catching all exceptions from within an enclosed computation

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

A breadth-first list monad.

A basic library for rate-limiting IO actions.

Simple, Fair and Terminating Backtracking Monad

Resumption and reactive resumption monads for Haskell.

A few pipes to control the timing of yields

Conduit adapters

Deep evaluation of data structures without NFData

Free monads and monad transformers

Haskell98 indexed functors, monads, comonads

Stateful supply monad.

Initial project template from stack

Lens implementation. It is more small but adequately.

A monad for using CryptoRandomGen

Basic conditional and boolean operators with monadic variants.

Template Haskell based deriver for optimised NFData instances

Transducers for foldl folds.

The Cloud Haskell implementation of Erlang/OTP gen_statem

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

WriteT and RWST monad transformers

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

GHC.Generics-based Control.DeepSeq.rnf implementation

Helpers for Control.Exception.assert

Package implementing core logic for refreshing of expiring access tokens

Fast imperative-style loops

Non-Determinism Monad for Tree Search

Simple monad transformer for imperative-style loops

List arrows for Haskell.

A higher-level interface to using concurrency with pipes

Open recursion for when you need it

Constraint Functional-Logic Programming in Haskell

MTL classes without the functional dependency

A faster variant of the RWS monad transformers.

Monad transformers that mirror worker-wrapper transformations.

Better, more general Prelude exporting common utilities.

Specific levels of monad transformers

Optics for xml-conduit and html-conduit

Instance derivers for newtype wrappers

Strict Identity Monad, handy for writing fast code!

Immediately lifts to a desired level

throwable-exceptions gives the exception's value constructors

A type class for monads with references using functional dependencies.

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

Non-Determinism Monad for Level-Wise Search

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

A library for tracking the consumption of a lazy ByteString

MonadWriter orphan instances for writer-cps-transformers

Extra utility functions for working with monads

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

Composable replication schemes of applicative functors

...

Semigroupoids that depend on PolyKinds

Pipes integration for ZeroMQ messaging

Provides a MonadST class

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

A type class for monads with references using type families.

Selectors for reading and updating data.

Lift control operations like exception catching through monad transformers

An extension removing the sequentiality from monads

Free monad transformers

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

A preprocessor for generating monadic call traces

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

Arrows with holes.

MTL-like library using TVars

A new Prelude featuring first class modules

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

A weighted nondeterministic search monad

Arrow Transformer Library

Utilities for working with ArrowApply instances more naturally

Type classes and monads for unchecked extensible exceptions.

Reversibly allow monad transformer stacks to run in IO

Stream Processer Arrow

Interfacing pipes with foldl folds.

Just size Operational Monad implementation.

Monads with an unsaveInterleaveIO-like operation.

Parser Effect for the Control.Effects Library

Extract underlying monads from monad transformers

Monadic functions which provide Choice and Parallelism.

Parallel Tree Search

Adapter to stream over HTTP(s) with quiver

Useful combinators for boolean expressions

Generalized stream processors

Various proxies for streaming data into vectors

...

Lens instances for the stricter CPS WriterT and RWST

A nullary type class for partial functions

Permutations of effectful computations

Quiver combinators for cellular data processing

Monadic loops for STM

Constraint Programming

Skeleton library around the IO monad.

Generalizing lift to monad stacks

Attoparsec and foldl-transduce integration.

Quiver combinators for cellular CSV data processing

Invariants and contract monitoring

indexed monads for free

A template haskell deriver to create Control.Newtype instances.

Package implementing core logic for refreshing of expiring data.

Reverse State monad transformer

The Observer pattern

An applicative functor to manage successors

a tiny library for using shared lens fields

Group and chunk values within a Quiver

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

mtl instances for the RegionT monad transformer

MonadWriter orphan instances for writer-cps-transformers

Safe, checked exceptions

A transformer for generic requests

a Paralell-DEVS implementaion based on distributed-process

An extensible log effect using extensible-effects

Fork of the monad-parallel package using monad-control

Syntactic sugar improving 'assert' and 'error'

Code review tool

Monads-tf instances for the RegionT monad transformer

WriteT and RWST monad transformers (Reexport with all dependencies)

Universal converter between values of different types

Bridge between Quiver and Iteratee paradigms

Quiver combinators for bytestring streaming

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

Exhaustivity Checking Library

Writer monad which uses semiring constraint

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

Applicative/Arrow for resource estimation and progress tracking.

Bifunctors over monad transformers.

A bidirectional bridge between pipes and iteratees

Allows instances for Category, Arrow and ArrowChoice for Pipes.

Efficient pipes-based cellular CSV codec

Graph indexed monads.

A monad and monadic transformer providing "abort" functionality

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

A Library for Writing Multi-Pass Algorithms.

Pipes-based combinators for cellular data processing

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

Abstract Application Interface.

Control flow data type and monad transformer.

Miscellaneous utilities for pipes, required by glazier-tutorial

Typeclasses and instances for monads with constraints.

Extra utilities for alternatives

Handy functions when using transformers

Extra functions for Control.Arrow

Essentially the Maybe type with error messages.

ByteString support for machines

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

A variation on the ST monad with two type parameters.

Some conviencience type functions for manipulating constraints.

MFunctor instance for CPS style WriterT and RWST

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