Haskell Control

Making composable programs with multithreading, events and distributed computing

Compositional pipelines

Networked stream transducers

A fast ECS for game engine programming

Anonymous records

Monads for free

Generalized bananas, lenses and barbed wire

Composable, streaming, and efficient left folds

Provide a classy prelude including common Yesod functionality.

An Alternative to Monad Transformers

Denotative, locally stateful programming DSL & platform

Categories

A typeclass-based Prelude.

Monad classes, using functional dependencies

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

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

Safe, consistent, and easy exception handling

Implementation of a friendly effect system for Haskell.

Principled practical FRP

Compositional pipelines

The Cloud Haskell Application Platform

Remote execution and map-reduce

Serializable closures for distributed programming.

An either monad transformer

Retry combinators for monadic actions that may fail

The Cloud Haskell Application Platform

Contravariant functors

Bidirectional state monad transformer

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

Implementation of difficult monads made easy with operational semantics.

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

Parallel programming library

Simplified error-handling

put if statements within type constraints

Lift control operations, like exception catching, through monad transformers

Implementation of effect system for Haskell.

Extensible optionally-pure exceptions

Tutorial for the lens library

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

Composable objects

Coveralls.io support for Haskell.

Deep evaluation of data structures

Embeds effect systems into Haskell using graded monads

Type-safe effectful state machines in Haskell

Monad transformers and classes

Embeds effect systems into Haskell using parameteric effect monads

Monad morphisms

A library for writing Imperative style haskell.

Parsing infrastructure for the pipes ecosystem

Categories

A natural transformation package.

A convenient wrapper around EKG metrics

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

Typeclasses for representing monad transformer unlifting

Distributed systems execution emulation

Safety for the pipes ecosystem

Typeclasses for representing monad transformer unlifting

Scientific workflow management system

Compositional, type-safe, polymorphic static values and closures

Codecov.io support for Haskell.

Modular type class machinery for monad transformer stacks.

Workflow patterns over a monad for thread state logging & recovery

List monad transformer

Monadic loops

Some convenience facilities for hoisting errors into a monad

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

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

Add prefixes to your monad-logger output

Random-number generation monad.

Functional reactive programming library

A monad transformer for tracing provenience of errors

Haskell distributed parallel Haskell

The Cloud Haskell Application Platform

Cloud Haskell Extras

A free monad based on the Wadler/Leijen pretty printer

Initial project template from stack

Explicitly typed, checked exceptions with stack traces

FRP through value streams and monadic splines.

Cloud Haskell Async API

Merged into 'speculation'. Use that instead.

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

A monad for managed values

lifted IO operations from the base library

ByteString support for pipes

An undead monad

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

IO without any non-error, synchronous exceptions

Simple zero-configuration backend for Cloud Haskell

Constraint Programming

product-profunctors

A Typeable-free implementation of extensible effects

Indexed functors, monads and comonads that require extensions to Haskell98

Manipulate FSMs and store them in PostgreSQL.

Supervisors for The Cloud Haskell Application Platform

Daemons in Haskell made fun and easy

Exhaustive pattern matching using lenses, traversals, and prisms

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

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

more flexible mtl

a parallel implementation of logic programming using distributed tree exploration

van Laarhoven encoded Free Monad with Extensible Effects

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

Memoization monad transformer

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

A color pretty printer with terminfo support

Extra utilities for pipes

Cloud Haskell Extended Process Registry

Orphan instances for MonadBase and MonadBaseControl.

Haskell98 indexed functors, monads, comonads

ListT done right

Execution Framework for The Cloud Haskell Application Platform

Library for parallel programming in the Intel Concurrent Collections paradigm.

...

An applicative monad that batches commands for later more efficient execution

Adapters between MonadIO and MonadBase IO.

Haskell 98 invariant functors

fast and simple operational monad

ASCII-fied arrow notation

An embedding of quantum computation as a Haskell arrow

Group streams into substreams

Quiver finite stream processing library

Playing with reified categorical composition

Folding data with multiple named passes

Arrow based stream transducers

Indexed Types

Computational Effects

All hail the Royal Monad!

A quasi-quoter for typeful results of regex captures.

Exception safe resource management with dynamic regions

Tools for functors from Hask^k to Hask

Stateful supply monad.

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

WriteT and RWST monad transformers

Repackages standard type classes with the ConstraintKinds extension

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

Lift computations from the bottom of a transformer stack

Instances for Applicative

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

A faster variant of the RWS monad transformers.

Rematch support for unordered containers

Simple, Fair and Terminating Backtracking Monad

Explicit Sharing of Monadic Effects

A basic library for rate-limiting IO actions.

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

Catching all exceptions from within an enclosed computation

ST monad with efficient explicit errors

A nullary type class for partial functions

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

A few pipes to control the timing of yields

The Cloud Haskell implementation of Erlang/OTP gen_statem

A class for monads which can keep a monadic call trace

...

Selectors for reading and updating data.

A breadth-first list monad.

MonadWriter orphan instances for writer-cps-transformers

GHC.Generics-based Control.DeepSeq.rnf implementation

Basic conditional and boolean operators with monadic variants.

Bifunctors over monad transformers.

A higher-level interface to using concurrency with pipes

Pure logger typeclass and monad transformer

A monad for using CryptoRandomGen

Initial project template from stack

Provides a MonadST class

Free monads and monad transformers

Lens implementation. It is more small but adequately.

Conduit adapters

A library to mock the current time.

Semigroupoids that depend on PolyKinds

Concurrency library in the style of Erlang/OTP

Extra utility functions for working with monads

Non-Determinism Monad for Tree Search

Template Haskell based deriver for optimised NFData instances

Deep evaluation of data structures without NFData

Composable replication schemes of applicative functors

Monad transformers that mirror worker-wrapper transformations.

Optics for xml-conduit and html-conduit

Pipes integration for ZeroMQ messaging

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

Transducers for foldl folds.

Simple monad transformer for imperative-style loops

Safe, checked exceptions

A new Prelude featuring first class modules

Helpers for Control.Exception.assert

Fast imperative-style loops

Resumption and reactive resumption monads for Haskell.

List arrows for Haskell.

Reverse State monad transformer

Open recursion for when you need it

Constraint Functional-Logic Programming in Haskell

MTL classes without the functional dependency

Type classes and monads for unchecked extensible exceptions.

Package implementing core logic for refreshing of expiring access tokens

Generalized stream processors

MTL-like library using TVars

Strict Identity Monad, handy for writing fast code!

throwable-exceptions gives the exception's value constructors

A type class for monads with references using type families.

A type class for monads with references using functional dependencies.

Immediately lifts to a desired level

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

Non-Determinism Monad for Level-Wise Search

Specific levels of monad transformers

Instance derivers for newtype wrappers

A library for tracking the consumption of a lazy ByteString

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

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

...

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

Various proxies for streaming data into vectors

An extensible log effect using extensible-effects

Arrows with holes.

A preprocessor for generating monadic call traces

Parser Effect for the Control.Effects Library

MonadWriter orphan instances for writer-cps-transformers

The Observer pattern

Extensible records and polymorphic variants.

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

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

A template haskell deriver to create Control.Newtype instances.

Constraint Programming

Utilities for working with ArrowApply instances more naturally

Arrow Transformer Library

Interfacing pipes with foldl folds.

Free monad transformers

An extension removing the sequentiality from monads

A weighted nondeterministic search monad

WriteT and RWST monad transformers (Reexport with all dependencies)

Parallel Tree Search

Reversibly allow monad transformer stacks to run in IO

Monadic functions which provide Choice and Parallelism.

Adapter to stream over HTTP(s) with quiver

Permutations of effectful computations

Useful combinators for boolean expressions

indexed monads for free

Monads with an unsaveInterleaveIO-like operation.

Extract underlying monads from monad transformers

Lens instances for the stricter CPS WriterT and RWST

Package implementing core logic for refreshing of expiring data.

Session types distributed

Session types library

Just size Operational Monad implementation.

Lift control operations like exception catching through monad transformers

Quiver combinators for cellular data processing

Generalizing lift to monad stacks

Monadic loops for STM

Stream Processer Arrow

Invariants and contract monitoring

Skeleton library around the IO monad.

Monad transformer for exit codes

Quiver combinators for cellular CSV data processing

The VarMonad typeclass, generalizing types of references.

Attoparsec and foldl-transduce integration.

A monad and monadic transformer providing "abort" functionality

mtl instances for the RegionT monad transformer

Universal converter between values of different types

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

Control flow data type and monad transformer.

a tiny library for using shared lens fields

Monads-tf instances for the RegionT monad transformer

Group and chunk values within a Quiver

Code review tool

A transformer for generic requests

a Paralell-DEVS implementaion based on distributed-process

Syntactic sugar improving 'assert' and 'error'

An applicative functor to manage successors

A bidirectional bridge between pipes and iteratees

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

Quiver combinators for bytestring streaming

Exhaustivity Checking Library

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

Writer monad which uses semiring constraint

...

Bridge between Quiver and Iteratee paradigms

Allows storing different resource-releasing actions together.

Applicative/Arrow for resource estimation and progress tracking.

Fork of the monad-parallel package using monad-control

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

Allows instances for Category, Arrow and ArrowChoice for Pipes.

Graph indexed monads.

Miscellaneous utilities for pipes, required by glazier-tutorial

A Library for Writing Multi-Pass Algorithms.

get stuff out of stuff

Typeclasses and instances for monads with constraints.

Efficient pipes-based cellular CSV codec

Abstract Application Interface.

Constraint Handling Rules

Pipes-based combinators for cellular data processing

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

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

Handy functions when using transformers

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

Essentially the Maybe type with error messages.

Bracket-like functions for ExceptT over IO monad.

ByteString support for machines

Guard monadic computations with cleanup actions

Extra utilities for alternatives

Extra functions for Control.Arrow

A variation on the ST monad with two type parameters.

Some conviencience type functions for manipulating constraints.

Serialisable static pointers to functions

An extensible effects library

incremental folds

The trivial monad and comonad

An orphan Eq instance for ErrorCall

Distinguish between synchronous and asynchronous exceptions

A useful type for collecting error messages.

Sensible conversions between some of the monad transformers

Break from a loop

MFunctor instance for CPS style WriterT and RWST

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

A library accelerates imperative style programming.