Haskell Control

Making composable programs with multithreading, events and distributed computing

Compositional pipelines

Networked stream transducers

Monads for free

An Alternative to Monad Transformers

Anonymous records

A fast ECS for game engine programming

Categories

A typeclass-based Prelude.

Monad classes, using functional dependencies

Generalized bananas, lenses and barbed wire

Denotative, locally stateful programming DSL & platform

Provide a classy prelude including common Yesod functionality.

Safe, consistent, and easy exception handling

Principled practical FRP

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

Composable, streaming, and efficient left folds

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

Compositional pipelines

The Cloud Haskell Application Platform

Remote execution and map-reduce

Retry combinators for monadic actions that may fail

Serializable closures for distributed programming.

An either monad transformer

Bidirectional state monad transformer

The Cloud Haskell Application Platform

Parallel programming library

Lift control operations, like exception catching, through monad transformers

Contravariant functors

Simplified error-handling

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

Implementation of difficult monads made easy with operational semantics.

Tutorial for the lens library

put if statements within type constraints

Composable objects

Deep evaluation of data structures

Implementation of effect system for Haskell.

Extensible optionally-pure exceptions

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

Coveralls.io support for Haskell.

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

Implementation of a friendly effect system for Haskell.

Embeds effect systems into Haskell using graded monads

Embeds effect systems into Haskell using parameteric effect monads

Monad morphisms

A library for writing Imperative style haskell.

Monad transformers and classes

A natural transformation package.

Parsing infrastructure for the pipes ecosystem

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

Distributed systems execution emulation

Categories

Typeclasses for representing monad transformer unlifting

Typeclasses for representing monad transformer unlifting

A convenient wrapper around EKG metrics

Scientific workflow management system

Safety for the pipes ecosystem

Add prefixes to your monad-logger output

Type-safe effectful state machines in Haskell

Modular type class machinery for monad transformer stacks.

List monad transformer

Workflow patterns over a monad for thread state logging & recovery

Compositional, type-safe, polymorphic static values and closures

Some convenience facilities for hoisting errors into a monad

Random-number generation monad.

Codecov.io support for Haskell.

A monad transformer for tracing provenience of errors

A free monad based on the Wadler/Leijen pretty printer

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

Haskell distributed parallel Haskell

Monadic loops

The Cloud Haskell Application Platform

Functional reactive programming library

A Typeable-free implementation of extensible effects

An undead monad

Initial project template from stack

Cloud Haskell Async API

FRP through value streams and monadic splines.

Merged into 'speculation'. Use that instead.

Explicitly typed, checked exceptions with stack traces

Cloud Haskell Extras

lifted IO operations from the base library

Simple zero-configuration backend for Cloud Haskell

A monad for managed values

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

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

ByteString support for pipes

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

Constraint Programming

product-profunctors

Indexed functors, monads and comonads that require extensions to Haskell98

Manipulate FSMs and store them in PostgreSQL.

IO without any non-error, synchronous exceptions

more flexible mtl

Exhaustive pattern matching using lenses, traversals, and prisms

Daemons in Haskell made fun and easy

van Laarhoven encoded Free Monad with Extensible Effects

Supervisors for The Cloud Haskell Application Platform

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

a parallel implementation of logic programming using distributed tree exploration

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

A color pretty printer with terminfo support

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

Extra utilities for pipes

Cloud Haskell Extended Process Registry

Orphan instances for MonadBase and MonadBaseControl.

Haskell98 indexed functors, monads, comonads

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

Library for parallel programming in the Intel Concurrent Collections paradigm.

ListT done right

Memoization monad transformer

An applicative monad that batches commands for later more efficient execution

Execution Framework for The Cloud Haskell Application Platform

fast and simple operational monad

Group streams into substreams

ASCII-fied arrow notation

Adapters between MonadIO and MonadBase IO.

Quiver finite stream processing library

...

Folding data with multiple named passes

Exception safe resource management with dynamic regions

Arrow based stream transducers

An embedding of quantum computation as a Haskell arrow

Playing with reified categorical composition

Indexed Types

All hail the Royal Monad!

A quasi-quoter for typeful results of regex captures.

Haskell 98 invariant functors

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

A faster variant of the RWS monad transformers.

Repackages standard type classes with the ConstraintKinds extension

Lift computations from the bottom of a transformer stack

Computational Effects

Tools for functors from Hask^k to Hask

Simple, Fair and Terminating Backtracking Monad

Instances for Applicative

Rematch support for unordered containers

Stateful supply monad.

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

Explicit Sharing of Monadic Effects

A basic library for rate-limiting IO actions.

WriteT and RWST monad transformers

Catching all exceptions from within an enclosed computation

ST monad with efficient explicit errors

A few pipes to control the timing of yields

A class for monads which can keep a monadic call trace

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

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

Pure logger typeclass and monad transformer

A nullary type class for partial functions

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

Conduit adapters

GHC.Generics-based Control.DeepSeq.rnf implementation

A breadth-first list monad.

Resumption and reactive resumption monads for Haskell.

Basic conditional and boolean operators with monadic variants.

Initial project template from stack

Lens implementation. It is more small but adequately.

A monad for using CryptoRandomGen

Free monads and monad transformers

MonadWriter orphan instances for writer-cps-transformers

Semigroupoids that depend on PolyKinds

A higher-level interface to using concurrency with pipes

Bifunctors over monad transformers.

The Cloud Haskell implementation of Erlang/OTP gen_statem

Monad transformers that mirror worker-wrapper transformations.

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

Non-Determinism Monad for Tree Search

A library to mock the current time.

Pipes integration for ZeroMQ messaging

Template Haskell based deriver for optimised NFData instances

Deep evaluation of data structures without NFData

Optics for xml-conduit and html-conduit

Extra utility functions for working with monads

Helpers for Control.Exception.assert

Safe, checked exceptions

A new Prelude featuring first class modules

Transducers for foldl folds.

Simple monad transformer for imperative-style loops

Provides a MonadST class

Constraint Functional-Logic Programming in Haskell

Type classes and monads for unchecked extensible exceptions.

MTL classes without the functional dependency

Package implementing core logic for refreshing of expiring access tokens

Open recursion for when you need it

List arrows for Haskell.

Reverse State monad transformer

Fast imperative-style loops

...

Instance derivers for newtype wrappers

Immediately lifts to a desired level

Strict Identity Monad, handy for writing fast code!

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

throwable-exceptions gives the exception's value constructors

Specific levels of monad transformers

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

Generalized stream processors

Non-Determinism Monad for Level-Wise Search

A type class for monads with references using functional dependencies.

A library for tracking the consumption of a lazy ByteString

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

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

...

Composable replication schemes of applicative functors

Arrows with holes.

Parser Effect for the Control.Effects Library

WriteT and RWST monad transformers (Reexport with all dependencies)

Interfacing pipes with foldl folds.

Free monad transformers

Selectors for reading and updating data.

A preprocessor for generating monadic call traces

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

MonadWriter orphan instances for writer-cps-transformers

Utilities for working with ArrowApply instances more naturally

MTL-like library using TVars

Arrow Transformer Library

Extensible records and polymorphic variants.

A type class for monads with references using type families.

The Observer pattern

A weighted nondeterministic search monad

An extension removing the sequentiality from monads

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

A template haskell deriver to create Control.Newtype instances.

Constraint Programming

An extensible log effect using extensible-effects

Reversibly allow monad transformer stacks to run in IO

Session types library

Session types distributed

Monads with an unsaveInterleaveIO-like operation.

An applicative functor to manage successors

Concurrency library in the style of Erlang/OTP

Package implementing core logic for refreshing of expiring data.

Various proxies for streaming data into vectors

Lens instances for the stricter CPS WriterT and RWST

Parallel Tree Search

Monadic functions which provide Choice and Parallelism.

Useful combinators for boolean expressions

Extract underlying monads from monad transformers

Adapter to stream over HTTP(s) with quiver

indexed monads for free

Permutations of effectful computations

Just size Operational Monad implementation.

Stream Processer Arrow

Invariants and contract monitoring

Quiver combinators for cellular CSV data processing

The VarMonad typeclass, generalizing types of references.

Generalizing lift to monad stacks

Attoparsec and foldl-transduce integration.

Lift control operations like exception catching through monad transformers

Monad transformer for exit codes

Skeleton library around the IO monad.

Monadic loops for STM

Quiver combinators for cellular data processing

mtl instances for the RegionT monad transformer

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

Control flow data type and monad transformer.

A monad and monadic transformer providing "abort" functionality

Universal converter between values of different types

Syntactic sugar improving 'assert' and 'error'

a tiny library for using shared lens fields

Group and chunk values within a Quiver

Monads-tf instances for the RegionT monad transformer

Code review tool

A transformer for generic requests

a Paralell-DEVS implementaion based on distributed-process

Writer monad which uses semiring constraint

Bridge between Quiver and Iteratee paradigms

A bidirectional bridge between pipes and iteratees

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

Allows storing different resource-releasing actions together.

...

Applicative/Arrow for resource estimation and progress tracking.

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

Quiver combinators for bytestring streaming

Exhaustivity Checking Library

Pipes-based combinators for cellular data processing

Allows instances for Category, Arrow and ArrowChoice for Pipes.

Abstract Application Interface.

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

Miscellaneous utilities for pipes, required by glazier-tutorial

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

Efficient pipes-based cellular CSV codec

A Library for Writing Multi-Pass Algorithms.

Typeclasses and instances for monads with constraints.

get stuff out of stuff

Graph indexed monads.

Fork of the monad-parallel package using monad-control

Handy functions when using transformers

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

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

Guard monadic computations with cleanup actions

A variation on the ST monad with two type parameters.

Constraint Handling Rules

Extra utilities for alternatives

Extra functions for Control.Arrow

ByteString support for machines

Essentially the Maybe type with error messages.

Bracket-like functions for ExceptT over IO monad.

Some conviencience type functions for manipulating constraints.

An extensible effects library

Serialisable static pointers to functions

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

An orphan Eq instance for ErrorCall

The trivial monad and comonad

incremental folds

A library accelerates imperative style programming.

Distinguish between synchronous and asynchronous exceptions

MFunctor instance for CPS style WriterT and RWST

Break from a loop

Sensible conversions between some of the monad transformers

A useful type for collecting error messages.