Haskell Control

Making composable programs with multithreading, events and distributed computing

Compositional pipelines

Networked stream transducers

Anonymous records

Generalized bananas, lenses and barbed wire

A fast ECS for game engine programming

Monads for free

Monad classes, using functional dependencies

Implementation of a friendly effect system for Haskell.

Denotative, locally stateful programming DSL & platform

Composable, streaming, and efficient left folds

An Alternative to Monad Transformers

Provide a classy prelude including common Yesod functionality.

A typeclass-based Prelude.

Safe, consistent, and easy exception handling

Categories

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

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

Principled practical FRP

Remote execution and map-reduce

Compositional pipelines

Serializable closures for distributed programming.

The Cloud Haskell Application Platform

Retry combinators for monadic actions that may fail

An either monad transformer

The Cloud Haskell Application Platform

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

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

Bidirectional state monad transformer

Parallel programming library

Contravariant functors

Implementation of difficult monads made easy with operational semantics.

Lift control operations, like exception catching, through monad transformers

put if statements within type constraints

Simplified error-handling

Implementation of effect system for Haskell.

Deep evaluation of data structures

Composable objects

Extensible optionally-pure exceptions

Tutorial for the lens library

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

Coveralls.io support for Haskell.

Type-safe effectful state machines in Haskell

Monad morphisms

Monad transformers and classes

Embeds effect systems into Haskell using graded monads

A library for writing Imperative style haskell.

Parsing infrastructure for the pipes ecosystem

Embeds effect systems into Haskell using parameteric effect monads

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

Categories

A natural transformation package.

Safety for the pipes ecosystem

Typeclasses for representing monad transformer unlifting

A convenient wrapper around EKG metrics

Codecov.io support for Haskell.

Typeclasses for representing monad transformer unlifting

Scientific workflow management system

Distributed systems execution emulation

Modular type class machinery for monad transformer stacks.

Add prefixes to your monad-logger output

Monadic loops

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

List monad transformer

Workflow patterns over a monad for thread state logging & recovery

Initial project template from stack

Some convenience facilities for hoisting errors into a monad

Haskell distributed parallel Haskell

Compositional, type-safe, polymorphic static values and closures

Functional reactive programming library

A free monad based on the Wadler/Leijen pretty printer

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

Random-number generation monad.

A monad transformer for tracing provenience of errors

FRP through value streams and monadic splines.

Cloud Haskell Async API

The Cloud Haskell Application Platform

Cloud Haskell Extras

Merged into 'speculation'. Use that instead.

lifted IO operations from the base library

An undead monad

Explicitly typed, checked exceptions with stack traces

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

IO without any non-error, synchronous exceptions

ByteString support for pipes

A monad for managed values

Constraint Programming

Simple zero-configuration backend for Cloud Haskell

Indexed functors, monads and comonads that require extensions to Haskell98

product-profunctors

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

Manipulate FSMs and store them in PostgreSQL.

Supervisors for The Cloud Haskell Application Platform

A Typeable-free implementation of extensible effects

Daemons in Haskell made fun and easy

a parallel implementation of logic programming using distributed tree exploration

Exhaustive pattern matching using lenses, traversals, and prisms

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

van Laarhoven encoded Free Monad with Extensible Effects

Memoization monad transformer

more flexible mtl

A color pretty printer with terminfo support

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

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

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

Extra utilities for pipes

Orphan instances for MonadBase and MonadBaseControl.

Haskell98 indexed functors, monads, comonads

An applicative monad that batches commands for later more efficient execution

Cloud Haskell Extended Process Registry

ListT done right

Tools for functors from Hask^k to Hask

...

Library for parallel programming in the Intel Concurrent Collections paradigm.

Adapters between MonadIO and MonadBase IO.

Execution Framework for The Cloud Haskell Application Platform

Haskell 98 invariant functors

fast and simple operational monad

Arrow based stream transducers

An embedding of quantum computation as a Haskell arrow

Group streams into substreams

Quiver finite stream processing library

ASCII-fied arrow notation

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

Playing with reified categorical composition

Folding data with multiple named passes

Stateful supply monad.

Indexed Types

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

A quasi-quoter for typeful results of regex captures.

WriteT and RWST monad transformers

Computational Effects

All hail the Royal Monad!

Exception safe resource management with dynamic regions

ST monad with efficient explicit errors

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

Repackages standard type classes with the ConstraintKinds extension

Explicit Sharing of Monadic Effects

Lift computations from the bottom of a transformer stack

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

Rematch support for unordered containers

Instances for Applicative

A faster variant of the RWS monad transformers.

Simple, Fair and Terminating Backtracking Monad

Catching all exceptions from within an enclosed computation

A basic library for rate-limiting IO actions.

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

A monad for using CryptoRandomGen

A few pipes to control the timing of yields

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

A higher-level interface to using concurrency with pipes

A nullary type class for partial functions

A class for monads which can keep a monadic call trace

Bifunctors over monad transformers.

...

The Cloud Haskell implementation of Erlang/OTP gen_statem

MonadWriter orphan instances for writer-cps-transformers

A new Prelude featuring first class modules

GHC.Generics-based Control.DeepSeq.rnf implementation

Selectors for reading and updating data.

Basic conditional and boolean operators with monadic variants.

A breadth-first list monad.

Reverse State monad transformer

Lens implementation. It is more small but adequately.

Free monads and monad transformers

Provides a MonadST class

Conduit adapters

A library to mock the current time.

Semigroupoids that depend on PolyKinds

Initial project template from stack

Pure logger typeclass and monad transformer

Concurrency library in the style of Erlang/OTP

Non-Determinism Monad for Tree Search

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

Optics for xml-conduit and html-conduit

Pipes integration for ZeroMQ messaging

Composable replication schemes of applicative functors

Monad transformers that mirror worker-wrapper transformations.

Template Haskell based deriver for optimised NFData instances

Extra utility functions for working with monads

Deep evaluation of data structures without NFData

Fast imperative-style loops

Helpers for Control.Exception.assert

Safe, checked exceptions

Various proxies for streaming data into vectors

Resumption and reactive resumption monads for Haskell.

Simple monad transformer for imperative-style loops

Transducers for foldl folds.

MTL classes without the functional dependency

Package implementing core logic for refreshing of expiring access tokens

List arrows for Haskell.

Constraint Functional-Logic Programming in Haskell

Type classes and monads for unchecked extensible exceptions.

Open recursion for when you need it

Generalized stream processors

A type class for monads with references using functional dependencies.

Non-Determinism Monad for Level-Wise Search

Specific levels of monad transformers

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

Immediately lifts to a desired level

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)

Strict Identity Monad, handy for writing fast code!

Free categories

A type class for monads with references using type families.

A library for tracking the consumption of a lazy ByteString

throwable-exceptions gives the exception's value constructors

Arrows with holes.

An extensible log effect using extensible-effects

...

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

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

A preprocessor for generating monadic call traces

A weighted nondeterministic search monad

Session types library

Interfacing pipes with foldl folds.

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

Extensible records and polymorphic variants.

Utilities for working with ArrowApply instances more naturally

The Observer pattern

mtl instances for the RegionT monad transformer

Arrow Transformer Library

An extension removing the sequentiality from monads

Free monad transformers

Monads-tf instances for the RegionT monad transformer

Parser Effect for the Control.Effects Library

MonadWriter orphan instances for writer-cps-transformers

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

A template haskell deriver to create Control.Newtype instances.

Constraint Programming

WriteT and RWST monad transformers (Reexport with all dependencies)

Permutations of effectful computations

indexed monads for free

Session types distributed

Parallel Tree Search

Adapter to stream over HTTP(s) with quiver

An applicative functor to manage successors

Package implementing core logic for refreshing of expiring data.

Reversibly allow monad transformer stacks to run in IO

Useful combinators for boolean expressions

Just size Operational Monad implementation.

Monads with an unsaveInterleaveIO-like operation.

Lens instances for the stricter CPS WriterT and RWST

Constraint Handling Rules

Stream Processer Arrow

Quiver combinators for cellular CSV data processing

Quiver combinators for cellular data processing

Lift control operations like exception catching through monad transformers

Attoparsec and foldl-transduce integration.

Generalizing lift to monad stacks

Extract underlying monads from monad transformers

Invariants and contract monitoring

Monadic loops for STM

The VarMonad typeclass, generalizing types of references.

Monad transformer for exit codes

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

Monadic functions which provide Choice and Parallelism.

Skeleton library around the IO monad.

Code review tool

A transformer for generic requests

Group and chunk values within a Quiver

Graph indexed monads.

Syntactic sugar improving 'assert' and 'error'

Abstract Application Interface.

Control flow data type and monad transformer.

A monad and monadic transformer providing "abort" functionality

a tiny library for using shared lens fields

a Paralell-DEVS implementaion based on distributed-process

A bidirectional bridge between pipes and iteratees

Bridge between Quiver and Iteratee paradigms

Exhaustivity Checking Library

Applicative/Arrow for resource estimation and progress tracking.

Allows storing different resource-releasing actions together.

...

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

Writer monad which uses semiring constraint

Quiver combinators for bytestring streaming

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

Miscellaneous utilities for pipes, required by glazier-tutorial

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

get stuff out of stuff

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

Fork of the monad-parallel package using monad-control

A Library for Writing Multi-Pass Algorithms.

Handy functions when using transformers

Allows instances for Category, Arrow and ArrowChoice for Pipes.

Efficient pipes-based cellular CSV codec

Pipes-based combinators for cellular data processing

Typeclasses and instances for monads with constraints.

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

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

Bracket-like functions for ExceptT over IO monad.

Essentially the Maybe type with error messages.

ByteString support for machines

Guard monadic computations with cleanup actions

A variation on the ST monad with two type parameters.

Extra functions for Control.Arrow

Extra utilities for alternatives

Serialisable static pointers to functions

Some conviencience type functions for manipulating constraints.

An extensible effects library

A useful type for collecting error messages.

Sensible conversions between some of the monad transformers

Break from a loop

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

Distinguish between synchronous and asynchronous exceptions

A library accelerates imperative style programming.

incremental folds

MFunctor instance for CPS style WriterT and RWST

The trivial monad and comonad

An orphan Eq instance for ErrorCall