Haskell Control

Compositional pipelines

Making composable programs with multithreading, events and distributed computing

Networked stream transducers

Anonymous records

Monads for free

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

Principled practical FRP

Denotative, locally stateful programming DSL & platform

Categories

An Alternative to Monad Transformers

Compositional pipelines

The Cloud Haskell Application Platform

Composable, streaming, and efficient left folds

A typeclass-based Prelude.

Safe, consistent, and easy exception handling

Monad classes, using functional dependencies

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

Remote execution and map-reduce

Generalized bananas, lenses and barbed wire

The Cloud Haskell Application Platform

Bidirectional state monad transformer

A fast ECS for game engine programming

Simplified error-handling

Implementation of effect system for Haskell.

An either monad transformer

Retry combinators for monadic actions that may fail

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

Parallel programming library

Coveralls.io support for Haskell.

Implementation of difficult monads made easy with operational semantics.

Lift control operations, like exception catching, through monad transformers

Deep evaluation of data structures

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

Composable objects

Serializable closures for distributed programming.

Tutorial for the lens library

Extensible optionally-pure exceptions

A library for writing Imperative style haskell.

Distributed systems execution emulation

Parsing infrastructure for the pipes ecosystem

Typeclasses for representing monad transformer unlifting

Typeclasses for representing monad transformer unlifting

put if statements within type constraints

Monad morphisms

A natural transformation package.

Contravariant functors

Safety for the pipes ecosystem

Monad transformers and classes

Modular type class machinery for monad transformer stacks.

Categories

Embeds effect systems into Haskell using graded monads

Scientific workflow management system

Embeds effect systems into Haskell using parameteric effect monads

Add prefixes to your monad-logger output

List monad transformer

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

Compositional, type-safe, polymorphic static values and closures

A convenient wrapper around EKG metrics

Workflow patterns over a monad for thread state logging & recovery

Random-number generation monad.

A monad transformer for tracing provenience of errors

Some convenience facilities for hoisting errors into a monad

A free monad based on the Wadler/Leijen pretty printer

Haskell distributed parallel Haskell

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

lifted IO operations from the base library

An undead monad

Explicitly typed, checked exceptions with stack traces

Monadic loops

ByteString support for pipes

Merged into 'speculation'. Use that instead.

FRP through value streams and monadic splines.

A Typeable-free implementation of extensible effects

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

Simple zero-configuration backend for Cloud Haskell

Codecov.io support for Haskell.

A monad for managed values

Initial project template from stack

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

Cloud Haskell Extras

Manipulate FSMs and store them in PostgreSQL.

Constraint Programming

Cloud Haskell Async API

The Cloud Haskell Application Platform

Functional reactive programming library

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

Exhaustive pattern matching using lenses, traversals, and prisms

IO without any non-error, synchronous exceptions

more flexible mtl

van Laarhoven encoded Free Monad with Extensible Effects

product-profunctors

a parallel implementation of logic programming using distributed tree exploration

A color pretty printer with terminfo support

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

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

Orphan instances for MonadBase and MonadBaseControl.

Daemons in Haskell made fun and easy

Cloud Haskell Extended Process Registry

fast and simple operational monad

Extra utilities for pipes

An applicative monad that batches commands for later more efficient execution

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

ASCII-fied arrow notation

Library for parallel programming in the Intel Concurrent Collections paradigm.

...

Supervisors for The Cloud Haskell Application Platform

Execution Framework for The Cloud Haskell Application Platform

Quiver finite stream processing library

Folding data with multiple named passes

Indexed functors, monads and comonads that require extensions to Haskell98

Playing with reified categorical composition

Group streams into substreams

All hail the Royal Monad!

A quasi-quoter for typeful results of regex captures.

An embedding of quantum computation as a Haskell arrow

Indexed Types

Memoization monad transformer

Repackages standard type classes with the ConstraintKinds extension

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

Arrow based stream transducers

Computational Effects

Exception safe resource management with dynamic regions

A faster variant of the RWS monad transformers.

Instances for Applicative

Rematch support for unordered containers

Haskell98 indexed functors, monads, comonads

ListT done right

Pure logger typeclass and monad transformer

A basic library for rate-limiting IO actions.

Explicit Sharing of Monadic Effects

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

Haskell 98 invariant functors

Catching all exceptions from within an enclosed computation

A breadth-first list monad.

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

ST monad with efficient explicit errors

A class for monads which can keep a monadic call trace

Lift computations from the bottom of a transformer stack

WriteT and RWST monad transformers

Resumption and reactive resumption monads for Haskell.

Conduit adapters

Simple, Fair and Terminating Backtracking Monad

A few pipes to control the timing of yields

Basic conditional and boolean operators with monadic variants.

Deep evaluation of data structures without NFData

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

Free monads and monad transformers

A monad for using CryptoRandomGen

Lens implementation. It is more small but adequately.

A higher-level interface to using concurrency with pipes

Initial project template from stack

Stateful supply monad.

The Cloud Haskell implementation of Erlang/OTP gen_statem

Extra utility functions for working with monads

Template Haskell based deriver for optimised NFData instances

Transducers for foldl folds.

GHC.Generics-based Control.DeepSeq.rnf implementation

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

Provides a MonadST class

MonadWriter orphan instances for writer-cps-transformers

Helpers for Control.Exception.assert

A new Prelude featuring first class modules

Semigroupoids that depend on PolyKinds

Constraint Functional-Logic Programming in Haskell

Pipes integration for ZeroMQ messaging

Non-Determinism Monad for Tree Search

Monad transformers that mirror worker-wrapper transformations.

Open recursion for when you need it

Fast imperative-style loops

Package implementing core logic for refreshing of expiring access tokens

List arrows for Haskell.

MTL classes without the functional dependency

Simple monad transformer for imperative-style loops

Better, more general Prelude exporting common utilities.

throwable-exceptions gives the exception's value constructors

Strict Identity Monad, handy for writing fast code!

Optics for xml-conduit and html-conduit

Generalized stream processors

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

Immediately lifts to a desired level

A type class for monads with references using functional dependencies.

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 monad and monad transformer for pushing things onto a stack very fast.

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

Composable replication schemes of applicative functors

Safe, checked exceptions

...

WriteT and RWST monad transformers (Reexport with all dependencies)

Free monad transformers

MonadWriter orphan instances for writer-cps-transformers

Type classes and monads for unchecked extensible exceptions.

Parser Effect for the Control.Effects Library

Lift control operations like exception catching through monad transformers

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

MTL-like library using TVars

A preprocessor for generating monadic call traces

Arrow Transformer Library

Selectors for reading and updating data.

An extension removing the sequentiality from monads

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

Arrows with holes.

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

A type class for monads with references using type families.

Utilities for working with ArrowApply instances more naturally

A weighted nondeterministic search monad

Stream Processer Arrow

Parallel Tree Search

Extract underlying monads from monad transformers

Just size Operational Monad implementation.

Interfacing pipes with foldl folds.

indexed monads for free

Various proxies for streaming data into vectors

Adapter to stream over HTTP(s) with quiver

...

Permutations of effectful computations

Reversibly allow monad transformer stacks to run in IO

Monads with an unsaveInterleaveIO-like operation.

Bifunctors over monad transformers.

Lens instances for the stricter CPS WriterT and RWST

Useful combinators for boolean expressions

Monadic functions which provide Choice and Parallelism.

Quiver combinators for cellular data processing

Invariants and contract monitoring

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

Skeleton library around the IO monad.

Package implementing core logic for refreshing of expiring data.

Generalizing lift to monad stacks

Reverse State monad transformer

A template haskell deriver to create Control.Newtype instances.

Quiver combinators for cellular CSV data processing

Constraint Programming

Monadic loops for STM

An applicative functor to manage successors

The Observer pattern

Attoparsec and foldl-transduce integration.

An extensible log effect using extensible-effects

a Paralell-DEVS implementaion based on distributed-process

Code review tool

Universal converter between values of different types

Syntactic sugar improving 'assert' and 'error'

mtl instances for the RegionT monad transformer

A transformer for generic requests

Group and chunk values within a Quiver

Monads-tf instances for the RegionT monad transformer

a tiny library for using shared lens fields

Bridge between Quiver and Iteratee paradigms

Quiver combinators for bytestring streaming

A nullary type class for partial functions

Applicative/Arrow for resource estimation and progress tracking.

A bidirectional bridge between pipes and iteratees

Writer monad which uses semiring constraint

Exhaustivity Checking Library

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

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

Monad transformer for exit codes

Allows instances for Category, Arrow and ArrowChoice for Pipes.

Efficient pipes-based cellular CSV codec

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

A monad and monadic transformer providing "abort" functionality

Typeclasses and instances for monads with constraints.

Pipes-based combinators for cellular data processing

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

Graph indexed monads.

Miscellaneous utilities for pipes, required by glazier-tutorial

A Library for Writing Multi-Pass Algorithms.

Abstract Application Interface.

Control flow data type and monad transformer.

The VarMonad typeclass, generalizing types of references.

Fork of the monad-parallel package using monad-control

Extra functions for Control.Arrow

ByteString support for machines

A variation on the ST monad with two type parameters.

Essentially the Maybe type with error messages.

Handy functions when using transformers

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

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

Extra utilities for alternatives

Some conviencience type functions for manipulating constraints.

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

Sensible conversions between some of the monad transformers

Break from a loop

MFunctor instance for CPS style WriterT and RWST

incremental folds

A library accelerates imperative style programming.

Distinguish between synchronous and asynchronous exceptions

An orphan Eq instance for ErrorCall

The trivial monad and comonad

A useful type for collecting error messages.