Haskell Control

Making composable programs with multithreading, events and distributed computing

Compositional pipelines

Networked stream transducers

Anonymous records

Monads for free

Provide a classy prelude including common Yesod functionality.

Denotative, locally stateful programming DSL & platform

Categories

Monad classes, using functional dependencies

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

An Alternative to Monad Transformers

A fast ECS for game engine programming

A typeclass-based Prelude.

Generalized bananas, lenses and barbed wire

Composable, streaming, and efficient left folds

Principled practical FRP

Safe, consistent, and easy exception handling

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

The Cloud Haskell Application Platform

Compositional pipelines

Remote execution and map-reduce

Retry combinators for monadic actions that may fail

An either monad transformer

Bidirectional state monad transformer

The Cloud Haskell Application Platform

put if statements within type constraints

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

Parallel programming library

Lift control operations, like exception catching, through monad transformers

Deep evaluation of data structures

Serializable closures for distributed programming.

Implementation of difficult monads made easy with operational semantics.

Contravariant functors

Extensible optionally-pure exceptions

Implementation of effect system for Haskell.

Simplified error-handling

Composable objects

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

Coveralls.io support for Haskell.

Tutorial for the lens library

A library for writing Imperative style haskell.

Embeds effect systems into Haskell using graded monads

Embeds effect systems into Haskell using parameteric effect monads

Monad transformers and classes

A natural transformation package.

Typeclasses for representing monad transformer unlifting

Distributed systems execution emulation

Typeclasses for representing monad transformer unlifting

Parsing infrastructure for the pipes ecosystem

Monad morphisms

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

Implementation of a friendly effect system for Haskell.

Categories

Add prefixes to your monad-logger output

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

Scientific workflow management system

Modular type class machinery for monad transformer stacks.

Safety for the pipes ecosystem

A convenient wrapper around EKG metrics

Workflow patterns over a monad for thread state logging & recovery

Codecov.io support for Haskell.

List monad transformer

Compositional, type-safe, polymorphic static values and closures

Some convenience facilities for hoisting errors into a monad

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

Random-number generation monad.

A free monad based on the Wadler/Leijen pretty printer

A monad transformer for tracing provenience of errors

Haskell distributed parallel Haskell

Monadic loops

Initial project template from stack

lifted IO operations from the base library

An undead monad

A Typeable-free implementation of extensible effects

Type-safe effectful state machines in Haskell

Merged into 'speculation'. Use that instead.

Cloud Haskell Async API

Explicitly typed, checked exceptions with stack traces

FRP through value streams and monadic splines.

ByteString support for pipes

Cloud Haskell Extras

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

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

Simple zero-configuration backend for Cloud Haskell

A monad for managed values

Functional reactive programming library

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

Constraint Programming

The Cloud Haskell Application Platform

Manipulate FSMs and store them in PostgreSQL.

Exhaustive pattern matching using lenses, traversals, and prisms

product-profunctors

more flexible mtl

a parallel implementation of logic programming using distributed tree exploration

Daemons in Haskell made fun and easy

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

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

van Laarhoven encoded Free Monad with Extensible Effects

IO without any non-error, synchronous exceptions

Supervisors for The Cloud Haskell Application Platform

Indexed functors, monads and comonads that require extensions to Haskell98

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.

Library for parallel programming in the Intel Concurrent Collections paradigm.

An applicative monad that batches commands for later more efficient execution

Memoization monad transformer

ListT done right

fast and simple operational monad

Execution Framework for The Cloud Haskell Application Platform

ASCII-fied arrow notation

Adapters between MonadIO and MonadBase IO.

Haskell98 indexed functors, monads, comonads

...

Group streams into substreams

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

Quiver finite stream processing library

Exception safe resource management with dynamic regions

An embedding of quantum computation as a Haskell arrow

Folding data with multiple named passes

Arrow based stream transducers

Playing with reified categorical composition

Indexed Types

A quasi-quoter for typeful results of regex captures.

All hail the Royal Monad!

Repackages standard type classes with the ConstraintKinds extension

A faster variant of the RWS monad transformers.

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

Tools for functors from Hask^k to Hask

Computational Effects

Haskell 98 invariant functors

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

Simple, Fair and Terminating Backtracking Monad

Rematch support for unordered containers

Explicit Sharing of Monadic Effects

Stateful supply monad.

Instances for Applicative

WriteT and RWST monad transformers

Pure logger typeclass and monad transformer

Lift computations from the bottom of a transformer stack

A basic library for rate-limiting IO actions.

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

A few pipes to control the timing of yields

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

Catching all exceptions from within an enclosed computation

A class for monads which can keep a monadic call trace

A nullary type class for partial functions

GHC.Generics-based Control.DeepSeq.rnf implementation

Basic conditional and boolean operators with monadic variants.

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

A breadth-first list monad.

Resumption and reactive resumption monads for Haskell.

ST monad with efficient explicit errors

Conduit adapters

Initial project template from stack

Free monads and monad transformers

A monad for using CryptoRandomGen

MonadWriter orphan instances for writer-cps-transformers

Lens implementation. It is more small but adequately.

A higher-level interface to using concurrency with pipes

The Cloud Haskell implementation of Erlang/OTP gen_statem

Bifunctors over monad transformers.

Extra utility functions for working with monads

Template Haskell based deriver for optimised NFData instances

Deep evaluation of data structures without NFData

Optics for xml-conduit and html-conduit

A library to mock the current time.

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

Simple monad transformer for imperative-style loops

A new Prelude featuring first class modules

Provides a MonadST class

Semigroupoids that depend on PolyKinds

Helpers for Control.Exception.assert

Transducers for foldl folds.

Type classes and monads for unchecked extensible exceptions.

Safe, checked exceptions

Constraint Functional-Logic Programming in Haskell

Open recursion for when you need it

Pipes integration for ZeroMQ messaging

List arrows for Haskell.

Fast imperative-style loops

Package implementing core logic for refreshing of expiring access tokens

MTL classes without the functional dependency

Immediately lifts to a desired level

throwable-exceptions gives the exception's value constructors

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 functional dependencies.

Specific levels of monad transformers

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

Generalized stream processors

Non-Determinism Monad for Level-Wise Search

Instance derivers for newtype wrappers

Composable replication schemes of applicative functors

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 library for tracking the consumption of a lazy ByteString

Arrows with holes.

A type class for monads with references using type families.

Selectors for reading and updating data.

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

Parser Effect for the Control.Effects Library

MTL-like library using TVars

Arrow Transformer Library

Free monad transformers

The Observer pattern

MonadWriter orphan instances for writer-cps-transformers

Interfacing pipes with foldl folds.

WriteT and RWST monad transformers (Reexport with all dependencies)

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.

Extensible records and polymorphic variants.

Reverse State monad transformer

A weighted nondeterministic search monad

Utilities for working with ArrowApply instances more naturally

A preprocessor for generating monadic call traces

Various proxies for streaming data into vectors

Lens instances for the stricter CPS WriterT and RWST

Permutations of effectful computations

indexed monads for free

Extract underlying monads from monad transformers

Reversibly allow monad transformer stacks to run in IO

Just size Operational Monad implementation.

An applicative functor to manage successors

Session types distributed

Adapter to stream over HTTP(s) with quiver

An extensible log effect using extensible-effects

Parallel Tree Search

Monadic functions which provide Choice and Parallelism.

Monads with an unsaveInterleaveIO-like operation.

Concurrency library in the style of Erlang/OTP

Session types library

...

Useful combinators for boolean expressions

Package implementing core logic for refreshing of expiring data.

Quiver combinators for cellular data processing

Monad transformer for exit codes

Attoparsec and foldl-transduce integration.

The VarMonad typeclass, generalizing types of references.

Monadic loops for STM

Stream Processer Arrow

Quiver combinators for cellular CSV data processing

Skeleton library around the IO monad.

Lift control operations like exception catching through monad transformers

Constraint Programming

Generalizing lift to monad stacks

Invariants and contract monitoring

Code review tool

mtl instances for the RegionT monad transformer

Universal converter between values of different types

a Paralell-DEVS implementaion based on distributed-process

Group and chunk values within a Quiver

Monads-tf instances for the RegionT monad transformer

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

a tiny library for using shared lens fields

Control flow data type and monad transformer.

Syntactic sugar improving 'assert' and 'error'

A transformer for generic requests

Exhaustivity Checking Library

Bridge between Quiver and Iteratee paradigms

Applicative/Arrow for resource estimation and progress tracking.

A bidirectional bridge between pipes and iteratees

...

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

Writer monad which uses semiring constraint

Allows storing different resource-releasing actions together.

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

Quiver combinators for bytestring streaming

Typeclasses and instances for monads with constraints.

A Library for Writing Multi-Pass Algorithms.

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

A monad and monadic transformer providing "abort" functionality

Efficient pipes-based cellular CSV codec

Miscellaneous utilities for pipes, required by glazier-tutorial

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

Allows instances for Category, Arrow and ArrowChoice for Pipes.

Pipes-based combinators for cellular data processing

Graph indexed monads.

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

Fork of the monad-parallel package using monad-control

Abstract Application Interface.

get stuff out of stuff

Handy functions when using transformers

Guard monadic computations with cleanup actions

Extra utilities for alternatives

Essentially the Maybe type with error messages.

A variation on the ST monad with two type parameters.

Extra functions for Control.Arrow

Bracket-like functions for ExceptT over IO monad.

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

ByteString support for machines

Constraint Handling Rules

Some conviencience type functions for manipulating constraints.

Serialisable static pointers to functions

An extensible effects library

A useful type for collecting error messages.

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

Sensible conversions between some of the monad transformers

MFunctor instance for CPS style WriterT and RWST

Break from a loop