This package provides a binary serialization library, similar to binary, that introduces an isolate primitive for parser isolation, and labeled blocks for better error messages.

This package provides a data structure representing a bidirectional mapping between two key types. Each value in the bimap is associated with exactly one value of the opposite type.

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

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

This library provides access to system information and functionality to Lua scripts via Haskell's System module. Intended usage for this package is to preload it by adding the loader function to package.preload. Note that the Lua package library must have already been loaded before the loader can be added.

This library provides the Data.Primitive.Addr module that was a part of the primitive library before primitive-0.7.0.0.

This library provides functions for parsing and pretty printing Roman numerals. Because the notation of Roman numerals has varied through the centuries this package allows for some customisation using a configuration that is passed to the conversion functions.

This Haskell package provides Monomorphic variants of the Functor, Foldable, and Traversable typeclasses. If you understand Haskell's basic typeclasses, you understand mono-traversable. In addition to what you are used to, it adds on an IsSequence typeclass and has code for marking data structures as non-empty.

This package provides a simple interface for building .dot graph files, for input into the dot and graphviz tools. It includes a monadic interface for building graphs.

This Haskell package provides an abstract interface to highly-parameterizable queues/deques.

Background: There exists a feature space for queues that extends between:

• Simple, single-ended, non-concurrent, bounded queues

• Double-ended, thread-safe, growable queues with important points in between (such as the queues used for work stealing).

This package includes an interface for Deques that allows the programmer to use a single API for all of the above, while using the type system to select an efficient implementation given the requirements (using type families).

This package also includes a simple reference implementation based on IORef and Data.Sequence.

This library provides functions for use in parsing indentation sensitive contexts. It parses blocks of lines all indented to the same level as well as lines continued at an indented level below.

Network.HostName is a simple package providing a means to determine the hostname.

This library provides a datatype which can be interpreted by apply-refact. It exists as a separate library so that applications can specify refactorings without depending on GHC.

GNU ncurses is a library for creating command-line application with pseudo-graphical interfaces. This package is a nice, modern binding to GNU ncurses.

Pandoc is a Haskell library for converting from one markup format to another, and a command-line tool that uses this library. It can read and write Markdown and (subsets of) other formats, such as HTML, reStructuredText, LaTeX, DocBook, and many more.

Pandoc extends standard Markdown syntax with footnotes, embedded LaTeX, definition lists, tables, and other features. A compatibility mode is provided for those who need a drop-in replacement for Markdown.pl.

Runtime exceptions - as exposed in base by the Control.Exception module - have long been an intimidating part of the Haskell ecosystem. This package is intended to overcome this. It provides a safe and simple API on top of the existing exception handling machinery. The API is equivalent to the underlying implementation in terms of power but encourages best practices to minimize the chances of getting the exception handling wrong.

This library provides some useful extensions for ghc-commonmark to parser core commonmark syntax: smart quotes, definition lists, tables, footnotes, math, and more.

This library provides Numeric.Interval.Interval, which represents a closed, convex set of floating point values.

The ListLike module provides a common interface to the various Haskell types that are list-like. Predefined interfaces include standard Haskell lists, Arrays, ByteStrings, and lazy ByteStrings. Custom types can easily be made ListLike instances as well.

ListLike also provides for String-like types, such as String and ByteString, for types that support input and output, and for types that can handle infinite lists.

Efficient hashing-based container types. The containers have been optimized for performance critical use, both in terms of large data quantities and high speed.

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

ghc-citeproc parses Citation Style Language style files and uses them to generate a list of formatted citations and bibliography entries. For more information about CSL, see https://citationstyles.org/.

This package defines a class, Hashable, for types that can be converted to a hash value. This class exists for the benefit of hashing-based data structures. The package provides instances for basic types and a way to combine hash values.

This package provides Haskell bindings to SDL2_mixer.