th-reify-many provides functions for recursively reifying top level declarations. The main intended use case is for enumerating the names of datatypes reachable from an initial datatype, and passing these names to some function which generates instances.

This package provides a Cairo vector graphics rendering backend for the Charts library.

doclayout is a pretty-printing library for laying out text documents, with several features not present in pretty-printing libraries designed for code. It was designed for use in Pandoc.

This library provides Haskell bindings for checking currently mounted filesystems.

This package (formerly binary-serialise-cbor) provides pure, efficient serialization of Haskell values directly into ByteStrings for storage or transmission purposes. By providing a set of type class instances, you can also serialise any custom data type you have as well.

The underlying binary format used is the 'Concise Binary Object Representation', or CBOR, specified in RFC 7049. As a result, serialised Haskell values have implicit structure outside of the Haskell program itself, meaning they can be inspected or analyzed without custom tools.

An implementation of the standard bijection between CBOR and JSON is provided by the https://hackage.haskell.org/package/cborg-json package. Also see https://hackage.haskell.org/package/cbor-tool for a convenient command-line utility for working with CBOR data.

This package is an enhancement of the Text.Regex library, providing the PCRE backend to accompany regex-base, with bundled code from https://www.pcre.org.

Alex is a tool for generating lexical analysers in Haskell. It takes a description of tokens based on regular expressions and generates a Haskell module containing code for scanning text efficiently. It is similar to the tool lex or flex for C/C++.

This package provides automatic formatting for Haskell files. Both a library and an executable.

This package provides functions to fork threads and wait for their result, whether it's an exception or a normal value. Besides waiting for the termination of a single thread this package also provides functions to wait for a group of threads to terminate. This package is similar to the threadmanager, async and spawn packages. The advantages of this package are:

• Simpler API.

• More efficient in both space and time.

• No space-leak when forking a large number of threads.

• Correct handling of asynchronous exceptions.

• GHC specific functionality like forkOn and forkIOWithUnmask.

This package defines orphan instances that mimic instances available in later versions of base to a wider (older) range of compilers.

This package provides a simple text templating system used by pandoc.

This library defines a data structure for representing Jupyter notebooks, along with ToJSON and FromJSON instances for conversion to and from JSON .ipynb files.

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.

This package provides a simple network library for all your connection needs. It provides a very simple API to create sockets to a destination with the choice of SSL/TLS, and SOCKS.

This package is for working with the native byte-ordering of the system.

This Haskell package was originally present in classy-prelude.

This package implements a language similar to YAML or JSON but with fewer special cases and fewer dependencies. It emphasizes layout structure for sections and lists, and requires quotes around strings.

This package provides a small cross-platform library for reading and modifying the system clipboard. It uses xclip or xsel at runtime.

This library provides tools to create command line interfaces with ease.

This package provides functions to prevent or capture writing to stdout and other handles.

Get terminal window height and width without ncurses dependency.

cassava is a library for parsing and encoding RFC 4180 compliant comma-separated values (CSV) data, which is a textual line-oriented format commonly used for exchanging tabular data.

cassava's API includes support for:

• Index-based record-conversion

• Name-based record-conversion

• Typeclass directed conversion of fields and records

• Built-in field-conversion instances for standard types

• Customizable record-conversion instance derivation via GHC generics

• Low-level bytestring builders (see Data.Csv.Builder)

• Incremental decoding and encoding API (see Data.Csv.Incremental)

• Streaming API for constant-space decoding (see Data.Csv.Streaming)

Moreover, this library is designed to be easy to use; for instance, here's a very simple example of encoding CSV data:

>>> Data.Csv.encode [("John",27),("Jane",28)]
"John,27
Jane,28
"

This is a simple time library providing a simple but powerful and performant API. The backbone of the library are the Timeable and Time type classes. Each Timeable instances can be converted to a type that has a Time instances, and thus are different representations of current time.

This package provides memory abstractions, such as chunk of memory, polymorphic byte array management and manipulation functions. It contains a polymorphic byte array abstraction and functions similar to strict ByteString, different type of byte array abstraction, raw memory IO operations (memory set, memory copy, ..) and more