This Haskell library contains type definitions for Universally Unique Identifiers or UUIDs, and basic conversion functions.

This Haskell package provides support for computations which consume random values.

This library lets you write interactive programs without callbacks or side-effects. Functional Reactive Programming (FRP) uses composable events and time-varying values to describe interactive systems as pure functions. Just like other pure functional code, functional reactive code is easier to get right on the first try, maintain, and reuse. Reflex is a fully-deterministic, higher-order FRP interface and an engine that efficiently implements that interface.

Hslogger lets each log message have a priority and source be associated with it. The programmer can then define global handlers that route or filter messages based on the priority and source. It also has a syslog handler built in.

ghc-doctest-driver-gen is a Doctest's driver file generator. It lets you automatically generate driver file for Doctest's Cabal integration.

This library provides various semigroups, specialized containers and a general map/reduce framework for Haskell.

This package provides a simple compatibility shim that lets you work with both binary and cereal with one chunk of serialization code.

This package profides a class for encoding and decoding UTF8 strings with instances for several common types. It also includes several functions for working with UTF8. It aims to be lightweight, depending only on Base and including only one module.

This package extends https://hackage.haskell.org/package/process. It allows you to read process input and output as ByteStrings or Text, or write your own ProcessOutput instance. It also provides lazy process input and output, and a ProcessMaker class for more flexibility in the process creation API.

This library provides monad morphism utilities, most commonly used for manipulating monad transformer stacks.

This package defines classes of monads that can perform multiple executions in parallel and combine their results. For any monad that's an instance of the class, the package re-implements a subset of the Control.Monad interface, but with parallel execution.

The Scripting.Lua module is a wrapper of the Lua language interpreter as described in https://www.lua.org/.

This package includes backported versions of types that were added to transformers in transformers 0.3 and 0.4 for users who need strict transformers 0.2 or 0.3 compatibility to run on old versions of the platform, but also need those types.

This package provides Haskell 98 groups. A group is a monoid with invertibility.

This package tries to compat as many time features as possible.

Tabular provides a Haskell representation of two-dimensional data tables, the kind that you might find in a spreadsheet or or a research report. It also comes with some default rendering functions for turning those tables into ASCII art, simple text with an arbitrary delimiter, CSV, HTML or LaTeX.

Below is an example of the kind of output this library produces. The tabular package can group rows and columns, each group having one of three separators (no line, single line, double line) between its members.

    || memtest 1 | memtest 2 ||  time test  | time test 2
====++===========+===========++=============+============
A 1 ||       hog |  terrible ||        slow |      slower
A 2 ||       pig |   not bad ||        fast |     slowest
----++-----------+-----------++-------------+------------
B 1 ||      good |     awful || intolerable |    bearable
B 2 ||    better | no chance ||    crawling |     amazing
B 3 ||       meh |   well... ||  worst ever |          ok

This library provides data structures for describing changes to other data structures. In this library, a patch is something that can be applied, analogous to a function, and which distinguishes returning the argument it was provided from returning something else.

This package provides a plotting library for Haskell, using gnuplot for rendering.

This Haskell package provides the core MonadUnliftIO typeclass, a number of common instances, and a collection of common functions working with it.

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

This package provides tools to measure the memory usage of a Haskell value or function.

This library provides the core data types and functions for parsing Commonmark. The parser is fully Commonmark-compliant and passes the test suite. It is designed to be customizable and easily extensible. To customize the output, create an AST, or support a new output format, one need only define some new typeclass instances. It is also easy to add new syntax elements or modify existing ones.

Accurate information about source positions is available for all block and inline elements. Thus the library can be used to create an accurate syntax highlighter or an editor with live preview. The parser has been designed for robust performance even in pathological cases that tend to cause stack overflows or exponential slowdowns in other parsers, with parsing speed that varies linearly with input length.

This library provides a wrapper to mmap, allowing files or devices to be lazily loaded into memory as strict or lazy ByteStrings, ForeignPtrs or plain Ptrs, using the virtual memory subsystem to do on-demand loading.

This package endows Data.Time, from the time package, with several data types and functions for enhanced processing of timezones. For one way to create timezone series, see the ghc-timezone-olson package.