Haskell Control

Making composable programs with multithreading, events and distributed computing

Networked stream transducers

Compositional pipelines

A fast ECS for game engine programming

Monad classes, using functional dependencies

Monads for free

Anonymous records

Generalized bananas, lenses and barbed wire

Denotative, locally stateful programming DSL & platform

Implementation of a friendly effect system for Haskell.

A typeclass-based Prelude.

Composable, streaming, and efficient left folds

An Alternative to Monad Transformers

Provide a classy prelude including common Yesod functionality.

Categories

Safe, consistent, and easy exception handling

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

The Cloud Haskell Application Platform

An either monad transformer

Serializable closures for distributed programming.

Retry combinators for monadic actions that may fail

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

The Cloud Haskell Application Platform

Bidirectional state monad transformer

Parallel programming library

Contravariant functors

Implementation of difficult monads made easy with operational semantics.

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

Tutorial for the lens library

Simplified error-handling

Deep evaluation of data structures

put if statements within type constraints

Lift control operations, like exception catching, through monad transformers

Composable objects

Extensible optionally-pure exceptions

Distributed systems execution emulation

Implementation of effect system for Haskell.

Monad morphisms

Coveralls.io support for Haskell.

Type-safe effectful state machines in Haskell

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

Monad transformers and classes

Embeds effect systems into Haskell using graded monads

A library for writing Imperative style haskell.

Embeds effect systems into Haskell using parameteric effect monads

Parsing infrastructure for the pipes ecosystem

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

A natural transformation package.

Categories

Typeclasses for representing monad transformer unlifting

Typeclasses for representing monad transformer unlifting

Safety for the pipes ecosystem

Scientific workflow management system

Codecov.io support for Haskell.

A convenient wrapper around EKG metrics

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

Compositional, type-safe, polymorphic static values and closures

Add prefixes to your monad-logger output

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

Modular type class machinery for monad transformer stacks.

Monadic loops

List monad transformer

Initial project template from stack

Workflow patterns over a monad for thread state logging & recovery

Random-number generation monad.

Some convenience facilities for hoisting errors into a monad

Haskell distributed parallel Haskell

A monad transformer for tracing provenience of errors

Functional reactive programming library

A free monad based on the Wadler/Leijen pretty printer

An undead monad

The Cloud Haskell Application Platform

lifted IO operations from the base library

FRP through value streams and monadic splines.

Cloud Haskell Extras

Cloud Haskell Async API

Explicitly typed, checked exceptions with stack traces

Merged into 'speculation'. Use that instead.

ByteString support for pipes

Simple zero-configuration backend for Cloud Haskell

A monad for managed values

IO without any non-error, synchronous exceptions

product-profunctors

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

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

Constraint Programming

Manipulate FSMs and store them in PostgreSQL.

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

Indexed functors, monads and comonads that require extensions to Haskell98

A Typeable-free implementation of extensible effects

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 parallel implementation of logic programming using distributed tree exploration

Memoization monad transformer

ListT done right

A color pretty printer with terminfo support

more flexible mtl

van Laarhoven encoded Free Monad with Extensible Effects

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

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

Haskell98 indexed functors, monads, comonads

Haskell 98 invariant functors

An applicative monad that batches commands for later more efficient execution

Orphan instances for MonadBase and MonadBaseControl.

Cloud Haskell Extended Process Registry

Extra utilities for pipes

Library for parallel programming in the Intel Concurrent Collections paradigm.

ASCII-fied arrow notation

Adapters between MonadIO and MonadBase IO.

...

Tools for functors from Hask^k to Hask

fast and simple operational monad

Group streams into substreams

Execution Framework for The Cloud Haskell Application Platform

Arrow based stream transducers

A faster variant of the RWS monad transformers.

An embedding of quantum computation as a Haskell arrow

Playing with reified categorical composition

Quiver finite stream processing library

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

Folding data with multiple named passes

Indexed Types

Computational Effects

A quasi-quoter for typeful results of regex captures.

WriteT and RWST monad transformers

Lift computations from the bottom of a transformer stack

Exception safe resource management with dynamic regions

All hail the Royal Monad!

Stateful supply monad.

Explicit Sharing of Monadic Effects

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

ST monad with efficient explicit errors

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

MonadWriter orphan instances for writer-cps-transformers

Rematch support for unordered containers

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

Catching all exceptions from within an enclosed computation

Instances for Applicative

A breadth-first list monad.

Simple, Fair and Terminating Backtracking Monad

Repackages standard type classes with the ConstraintKinds extension

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

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

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

A higher-level interface to using concurrency with pipes

A library to mock the current time.

Reverse State monad transformer

Basic conditional and boolean operators with monadic variants.

A new Prelude featuring first class modules

Concurrency library in the style of Erlang/OTP

GHC.Generics-based Control.DeepSeq.rnf implementation

Selectors for reading and updating data.

Semigroupoids that depend on PolyKinds

Provides a MonadST class

Pure logger typeclass and monad transformer

Initial project template from stack

Helpers for Control.Exception.assert

Free monads and monad transformers

Conduit adapters

Lens implementation. It is more small but adequately.

Deep evaluation of data structures without NFData

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

Optics for xml-conduit and html-conduit

Monad transformers that mirror worker-wrapper transformations.

Composable replication schemes of applicative functors

Constraint Functional-Logic Programming in Haskell

Extra utility functions for working with monads

Non-Determinism Monad for Tree Search

Pipes integration for ZeroMQ messaging

Template Haskell based deriver for optimised NFData instances

Simple monad transformer for imperative-style loops

Fast imperative-style loops

Various proxies for streaming data into vectors

Resumption and reactive resumption monads for Haskell.

Transducers for foldl folds.

Safe, checked exceptions

MTL classes without the functional dependency

List arrows for Haskell.

A type class for monads with references using functional dependencies.

Type classes and monads for unchecked extensible exceptions.

Open recursion for when you need it

Package implementing core logic for refreshing of expiring access tokens

Generalized stream processors

Free categories

Immediately lifts to a desired level

Universal converter between values of different types

throwable-exceptions gives the exception's value constructors

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

MTL-like library using TVars

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

Strict Identity Monad, handy for writing fast code!

A type class for monads with references using type families.

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

Arrows with holes.

...

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

Constraint Handling Rules

An extensible log effect using extensible-effects

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

A preprocessor for generating monadic call traces

Interfacing pipes with foldl folds.

Session types library

Constraint Programming

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

mtl instances for the RegionT monad transformer

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

Monads-tf instances for the RegionT monad transformer

Free monad transformers

A template haskell deriver to create Control.Newtype instances.

Arrow Transformer Library

WriteT and RWST monad transformers (Reexport with all dependencies)

The Observer pattern

Parser Effect for the Control.Effects Library

Extensible records and polymorphic variants.

A weighted nondeterministic search monad

MonadWriter orphan instances for writer-cps-transformers

Utilities for working with ArrowApply instances more naturally

An extension removing the sequentiality from monads

Session types distributed

Reversibly allow monad transformer stacks to run in IO

Parallel Tree Search

Just size Operational Monad implementation.

Adapter to stream over HTTP(s) with quiver

Useful combinators for boolean expressions

Permutations of effectful computations

Package implementing core logic for refreshing of expiring data.

indexed monads for free

An applicative functor to manage successors

Monads with an unsaveInterleaveIO-like operation.

Lens instances for the stricter CPS WriterT and RWST

Quiver combinators for cellular data processing

Invariants and contract monitoring

Generalizing lift to monad stacks

Monadic loops for STM

Monad transformer for exit codes

Extract underlying monads from monad transformers

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

Quiver combinators for cellular CSV data processing

The VarMonad typeclass, generalizing types of references.

Skeleton library around the IO monad.

Stream Processer Arrow

Lift control operations like exception catching through monad transformers

Attoparsec and foldl-transduce integration.

Monadic functions which provide Choice and Parallelism.

Code review tool

a Paralell-DEVS implementaion based on distributed-process

a tiny library for using shared lens fields

Graph indexed monads.

Abstract Application Interface.

Syntactic sugar improving 'assert' and 'error'

Group and chunk values within a Quiver

A transformer for generic requests

A monad and monadic transformer providing "abort" functionality

Control flow data type and monad transformer.

A bidirectional bridge between pipes and iteratees

Exhaustivity Checking Library

Allows storing different resource-releasing actions together.

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

Writer monad which uses semiring constraint

...

Bridge between Quiver and Iteratee paradigms

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

Quiver combinators for bytestring streaming

Applicative/Arrow for resource estimation and progress tracking.

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

A Library for Writing Multi-Pass Algorithms.

Typeclasses and instances for monads with constraints.

Efficient pipes-based cellular CSV codec

Miscellaneous utilities for pipes, required by glazier-tutorial

Pipes-based combinators for cellular data processing

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

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

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

Handy functions when using transformers

get stuff out of stuff

Fork of the monad-parallel package using monad-control

Allows instances for Category, Arrow and ArrowChoice for Pipes.

Extra utilities for alternatives

Essentially the Maybe type with error messages.

A variation on the ST monad with two type parameters.

Guard monadic computations with cleanup actions

Extra functions for Control.Arrow

Bracket-like functions for ExceptT over IO monad.

ByteString support for machines

Some conviencience type functions for manipulating constraints.

Serialisable static pointers to functions

An extensible effects library

The trivial monad and comonad

A useful type for collecting error messages.

A library accelerates imperative style programming.

Sensible conversions between some of the monad transformers

Distinguish between synchronous and asynchronous exceptions

Break from a loop

MFunctor instance for CPS style WriterT and RWST

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

An orphan Eq instance for ErrorCall

incremental folds