Haskell Control

Making composable programs with multithreading, events and distributed computing

Compositional pipelines

Networked stream transducers

Monad classes, using functional dependencies

Generalized bananas, lenses and barbed wire

Anonymous records

A fast ECS for game engine programming

Monads for free

A typeclass-based Prelude.

Composable, streaming, and efficient left folds

Implementation of a friendly effect system for Haskell.

Provide a classy prelude including common Yesod functionality.

Denotative, locally stateful programming DSL & platform

An Alternative to Monad Transformers

Categories

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

Safe, consistent, and easy exception handling

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

Remote execution and map-reduce

Principled practical FRP

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

Serializable closures for distributed programming.

Retry combinators for monadic actions that may fail

The Cloud Haskell Application Platform

Compositional pipelines

An either monad transformer

The Cloud Haskell Application Platform

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

Bidirectional state monad transformer

Contravariant functors

Parallel programming library

Implementation of difficult monads made easy with operational semantics.

Lift control operations, like exception catching, through monad transformers

put if statements within type constraints

Deep evaluation of data structures

Extensible optionally-pure exceptions

Simplified error-handling

Distributed systems execution emulation

Implementation of effect system for Haskell.

Monad morphisms

Tutorial for the lens library

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.

Embeds effect systems into Haskell using parameteric effect monads

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

Parsing infrastructure for the pipes ecosystem

Embeds effect systems into Haskell using graded monads

A library for writing Imperative style haskell.

A natural transformation package.

Categories

Safety for the pipes ecosystem

Typeclasses for representing monad transformer unlifting

Scientific workflow management system

Codecov.io support for Haskell.

Typeclasses for representing monad transformer unlifting

A convenient wrapper around EKG metrics

Initial project template from stack

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

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

Add prefixes to your monad-logger output

Compositional, type-safe, polymorphic static values and closures

Modular type class machinery for monad transformer stacks.

List monad transformer

Some convenience facilities for hoisting errors into a monad

Haskell distributed parallel Haskell

Monadic loops

Random-number generation monad.

Workflow patterns over a monad for thread state logging & recovery

A monad transformer for tracing provenience of errors

Functional reactive programming library

A free monad based on the Wadler/Leijen pretty printer

Cloud Haskell Async API

lifted IO operations from the base library

The Cloud Haskell Application Platform

An undead monad

Explicitly typed, checked exceptions with stack traces

Cloud Haskell Extras

Merged into 'speculation'. Use that instead.

FRP through value streams and monadic splines.

ByteString support for pipes

A monad for managed values

Simple zero-configuration backend for Cloud Haskell

IO without any non-error, synchronous exceptions

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

Constraint Programming

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

product-profunctors

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

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

Exhaustive pattern matching using lenses, traversals, and prisms

Haskell98 indexed functors, monads, comonads

a parallel implementation of logic programming using distributed tree exploration

more flexible mtl

van Laarhoven encoded Free Monad with Extensible Effects

Memoization monad transformer

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

An applicative monad that batches commands for later more efficient execution

A color pretty printer with terminfo support

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.

Adapters between MonadIO and MonadBase IO.

...

Tools for functors from Hask^k to Hask

Library for parallel programming in the Intel Concurrent Collections paradigm.

ASCII-fied arrow notation

Group streams into substreams

Execution Framework for The Cloud Haskell Application Platform

fast and simple operational monad

Quiver finite stream processing library

An embedding of quantum computation as a Haskell arrow

Arrow based stream transducers

A faster variant of the RWS monad transformers.

Playing with reified categorical composition

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

Lift computations from the bottom of a transformer stack

Folding data with multiple named passes

WriteT and RWST monad transformers

Indexed Types

Computational Effects

A quasi-quoter for typeful results of regex captures.

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

All hail the Royal Monad!

Exception safe resource management with dynamic regions

Stateful supply monad.

ST monad with efficient explicit errors

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

Explicit Sharing of Monadic Effects

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

Catching all exceptions from within an enclosed computation

Rematch support for unordered containers

MonadWriter orphan instances for writer-cps-transformers

Instances for Applicative

Simple, Fair and Terminating Backtracking Monad

A breadth-first list monad.

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

Repackages standard type classes with the ConstraintKinds extension

A basic library for rate-limiting IO actions.

A few pipes to control the timing of yields

A monad for using CryptoRandomGen

Bifunctors over monad transformers.

The Cloud Haskell implementation of Erlang/OTP gen_statem

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

A class for monads which can keep a monadic call trace

A new Prelude featuring first class modules

Reverse State monad transformer

A library to mock the current time.

Selectors for reading and updating data.

GHC.Generics-based Control.DeepSeq.rnf implementation

Basic conditional and boolean operators with monadic variants.

Concurrency library in the style of Erlang/OTP

Lens implementation. It is more small but adequately.

Conduit adapters

Provides a MonadST class

Semigroupoids that depend on PolyKinds

Various proxies for streaming data into vectors

Pure logger typeclass and monad transformer

Type classes and monads for unchecked extensible exceptions.

Free monads and monad transformers

Helpers for Control.Exception.assert

Initial project template from stack

Monad transformers that mirror worker-wrapper transformations.

Optics for xml-conduit and html-conduit

Composable replication schemes of applicative functors

Pipes integration for ZeroMQ messaging

Constraint Functional-Logic Programming in Haskell

Extra utility functions for working with monads

Non-Determinism Monad for Tree Search

Deep evaluation of data structures without NFData

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

Template Haskell based deriver for optimised NFData instances

Transducers for foldl folds.

Simple monad transformer for imperative-style loops

Resumption and reactive resumption monads for Haskell.

Safe, checked exceptions

Fast imperative-style loops

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.

Generalized stream processors

A type class for monads with references using functional dependencies.

throwable-exceptions gives the exception's value constructors

Immediately lifts to a desired level

A type class for monads with references using type families.

A library for tracking the consumption of a lazy ByteString

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

Free categories

Strict Identity Monad, handy for writing fast code!

Non-Determinism Monad for Level-Wise Search

Specific levels of monad transformers

Instance derivers for newtype wrappers

MTL-like library using TVars

Universal converter between values of different types

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

Arrows with holes.

An extensible log effect using extensible-effects

Constraint Handling Rules

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

...

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

A preprocessor for generating monadic call traces

A weighted nondeterministic search monad

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

An extension removing the sequentiality from monads

Extensible records and polymorphic variants.

The Observer pattern

Arrow Transformer Library

Free monad transformers

A template haskell deriver to create Control.Newtype instances.

MonadWriter orphan instances for writer-cps-transformers

Interfacing pipes with foldl folds.

WriteT and RWST monad transformers (Reexport with all dependencies)

Constraint Programming

Utilities for working with ArrowApply instances more naturally

Parser Effect for the Control.Effects Library

mtl instances for the RegionT monad transformer

Monads-tf instances for the RegionT monad transformer

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

Session types library

Monads with an unsaveInterleaveIO-like operation.

Permutations of effectful computations

An applicative functor to manage successors

Reversibly allow monad transformer stacks to run in IO

Just size Operational Monad implementation.

Lens instances for the stricter CPS WriterT and RWST

Useful combinators for boolean expressions

indexed monads for free

Package implementing core logic for refreshing of expiring data.

Parallel Tree Search

Adapter to stream over HTTP(s) with quiver

Session types distributed

Quiver combinators for cellular data processing

Attoparsec and foldl-transduce integration.

Quiver combinators for cellular CSV data processing

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

Invariants and contract monitoring

The VarMonad typeclass, generalizing types of references.

Lift control operations like exception catching through monad transformers

Monadic functions which provide Choice and Parallelism.

Stream Processer Arrow

Monad transformer for exit codes

Generalizing lift to monad stacks

Extract underlying monads from monad transformers

Monadic loops for STM

Skeleton library around the IO monad.

Code review tool

a tiny library for using shared lens fields

Control flow data type and monad transformer.

Graph indexed monads.

Group and chunk values within a Quiver

Syntactic sugar improving 'assert' and 'error'

A monad and monadic transformer providing "abort" functionality

a Paralell-DEVS implementaion based on distributed-process

A transformer for generic requests

Abstract Application Interface.

A bidirectional bridge between pipes and iteratees

Exhaustivity Checking Library

Writer monad which uses semiring constraint

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

...

Bridge between Quiver and Iteratee paradigms

Quiver combinators for bytestring streaming

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.

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

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

Handy functions when using transformers

A Library for Writing Multi-Pass Algorithms.

Miscellaneous utilities for pipes, required by glazier-tutorial

Allows instances for Category, Arrow and ArrowChoice for Pipes.

Typeclasses and instances for monads with constraints.

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

Efficient pipes-based cellular CSV codec

Pipes-based combinators for cellular data processing

Fork of the monad-parallel package using monad-control

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

get stuff out of stuff

Extra functions for Control.Arrow

Extra utilities for alternatives

Essentially the Maybe type with error messages.

Bracket-like functions for ExceptT over IO monad.

Guard monadic computations with cleanup actions

A variation on the ST monad with two type parameters.

ByteString support for machines

Some conviencience type functions for manipulating constraints.

Serialisable static pointers to functions

An extensible effects library

Distinguish between synchronous and asynchronous exceptions

A useful type for collecting error messages.

An orphan Eq instance for ErrorCall

Sensible conversions between some of the monad transformers

The trivial monad and comonad

Break from a loop

MFunctor instance for CPS style WriterT and RWST

incremental folds

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

A library accelerates imperative style programming.