This package provides a GHC.Generics-based Control.DeepSeq.Generics.genericRnf function which can be used for providing an rnf implementation.

This package allows you to have a README.md that at the same time is a literate Haskell program.

PCG is a family of simple fast space-efficient statistically good algorithms for random number generation. Unlike many general-purpose RNGs, they are also hard to predict. . This library implements bindings to the standard C implementation. This includes the standard, unique, fast and single variants in the pcg family. There is a pure implementation that can be used as a generator with the random package as well as a faster primitive api that includes functions for generating common types. . The generators in this module are suitable for use in parallel but make sure threads don't share the same generator or things will go horribly wrong.

This library implements mid-level Haskell bindings to the MySQL mysqlclient client library. It is aimed at speed and ease of use.

Text.Regex.Base provides the interface API for regex-posix, regex-pcre, regex-parsec, regex-tdfa, regex-dfa.

This package provides type classes, a monad and a monad transformer that support unchecked extensible exceptions as well as asynchronous exceptions. It is compatible with the transformers package.

This Haskell package contains code for generating high quality random numbers that follow either a uniform or normal distribution. The generated numbers are suitable for use in statistical applications.

The uniform PRNG uses Marsaglia's MWC256 (also known as MWC8222) multiply-with-carry generator, which has a period of 2^8222 and fares well in tests of randomness. It is also extremely fast, between 2 and 3 times faster than the Mersenne Twister.

This is an industrial-strength monadic parser combinator library. Megaparsec is a feature-rich package that strikes a nice balance between speed, flexibility, and quality of parse errors.

Clear to write, read and edit Haskell DSL for HTML.

• Names are consistent, and do not conflict with base or are keywords (all have suffix -).

• Same combinator can be used for attributes and elements (e.g. style_).

The module Data.CaseInsensitive provides the CI type constructor which can be parameterised by a string-like type like: String, ByteString, Text, etc. Comparisons of values of the resulting type will be insensitive to cases.

Haskell bindings to the International Components for Unicode (ICU) libraries. These libraries provide robust and full-featured Unicode services on a wide variety of platforms. . Features include: . * Both pure and impure bindings, to allow for fine control over efficiency and ease of use. . * Breaking of strings on character, word, sentence, and line boundaries. . * Access to the Unicode Character Database (UCD) of character metadata. . * String collation functions, for locales where the conventions for lexicographic ordering differ from the simple numeric ordering of character codes. . * Character set conversion functions, allowing conversion between Unicode and over 220 character encodings. . * Unicode normalization. (When implementations keep strings in a normalized form, they can be assured that equivalent strings have a unique binary representation.) . * Regular expression search and replace. . * Security checks for visually confusable (spoofable) strings. . * Bidirectional Unicode algorithm . * Calendar objects holding dates and times. . * Number and calendar formatting.

Set- and Map-like types that remember the order elements were inserted

This Haskell package provides striped pooling abstraction for managing flexibly-sized collections of resources such as database connections.

Uniplate is a library for writing simple and concise generic operations. Uniplate has similar goals to the original Scrap Your Boilerplate work, but is substantially simpler and faster.

This Haskell package provides a validator that can validate an email address string against RFC 5322.

GLib is a collection of C data structures and utility functions for the GObject system, main loop implementation, for strings and common data structures dealing with Unicode. This package only binds as much functionality as required to support the packages that wrap libraries that are themselves based on GLib.

This package contains a MonadRef type class that abstracts over the details of manipulating references, allowing one to write code that can operate in either the ST monad or the IO monad.

Reasonably fast data encoding library.

Rose (n-ary) trees with both upwards- (i.e. cached) and downwards-traveling (i.e. accumulating) monoidal annotations. This is used as the core data structure underlying the diagrams framework, but potentially has other applications as well.

Simple yet powerful monadic streams that are used as a backbone for vector package fusion functionality.

Derive instances of Arbitrary for QuickCheck, with various options to customize implementations.

Automating the arbitrary boilerplate also ensures that when a type changes to have more or fewer constructors, then the generator either fixes itself to generate that new case (when using the uniform distribution) or causes a compilation error so you remember to fix it (when using an explicit distribution).

This package also offers a simple (optional) strategy to ensure termination for recursive types: make Test.QuickCheck.Gen's size parameter decrease at every recursive call; when it reaches zero, sample directly from a trivially terminating generator given explicitly (genericArbitraryRec and withBaseCase) or implicitly (genericArbitrary').

This package implements selective applicative functors, which allow you to declare your effects statically, and select which to execute dynamically. See the paper on selective functors for more details.

This package implements utilities to perform atomic output so as to avoid the problem of partial intermediate files.

This Haskell library provides a function for computing the difference between (expression) trees. It also provides a way to compute the difference between arbitrary abstract datatypes (ADTs) using Generics-derivable helpers.