The PGP Word List consists of two phonetic alphabets, each with one word per possible byte value. A string of bytes is translated with these alphabets, alternating between them at each byte.

The PGP words corresponding to the bytes 5B 1D CA 6E are "erase breakaway spellbind headwaters", for example.

For further information, see http://en.wikipedia.org/wiki/PGP_word_list.

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.

RFC 4648-compliant Base64 with an eye towards performance and modernity (additional support for RFC 7049 standards)

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

This package exposes combinators that can wrap arbitrary monadic actions. They run the action and potentially retry running it with some configurable delay for a configurable number of times. The purpose is to make it easier to work with IO and especially network IO actions that often experience temporary failure and warrant retrying of the original action. For example, a database query may time out for a while, in which case we should hang back for a bit and retry the query instead of simply raising an exception.

Provides a FilePath datatype and utility functions for operating on it. Unlike the filepath package, this package does not simply reuse String, increasing type safety.

This package provides a fully compliant Haskell 98 lexer.

Protolude gives you sensible defaults for writing custom Preludes to replace the standard one provided by GHC.

This package provides the bytestring builder that is debuting in bytestring-0.10.4.0, which should be shipping with GHC 7.8. Compatibility package for older packages.

ResourceT is a monad transformer which creates a region of code where you can safely allocate resources.

This library provides a fast parser combinator library, aimed particularly at dealing efficiently with network protocols and complicated text/binary file formats.

This package provides modules containing facilities for manipulating Haskell source code using Template Haskell. See http://www.haskell.org/haskellwiki/Template_Haskell for more information.

This library provides tools to infer a software license from a given license file.

This package provides Haskell APIs to efficiently access the <https://www.unicode.org/ucd/ Unicode character database> (UCD). Performance is the primary goal in the design of this package. The Haskell data structures are generated programmatically from the UCD files.

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.

This library provides finger trees, a general sequence representation with arbitrary annotations, for use as a base for implementations of various collection types. It includes examples, as described in section 4 of Ralf Hinze and Ross Paterson, "Finger trees: a simple general-purpose data structure".

This package provides instances defined in later versions of ghc-binary package.

Provides Arbitrary instances for fgl graphs to avoid adding a QuickCheck dependency for fgl whilst still making the instances available to others. Also available are non-fgl-specific functions for generating graph-like data structures.

wizards is a package designed for the quick and painless development of interrogative programs, which revolve around a dialogue with the user, who is asked a series of questions in a sequence much like an installation wizard.

Everything from interactive system scripts, to installation wizards, to full-blown shells can be implemented with the support of wizards.

It is developed transparently on top of a free monad, which separates out the semantics of the program from any particular interface. A variety of backends exist, including console-based System.Console.Wizard.Haskeline and System.Console.Wizard.BasicIO, and the pure System.Console.Wizard.Pure. It is also possible to write your own backends, or extend existing back-ends with new features. While both built-in IO backends operate on a console, there is no reason why wizards cannot also be used for making GUI wizard interfaces.

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

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

This is a Haskell module for PortMidi audio library, which supports real-time MIDI input and output.

This module allows tokens produced by skylighting-core to be rendered as HTML.

This package contains the generics system described in the /Scrap Your Boilerplate/ papers (see the website). It defines the Data class of types permitting folding and unfolding of constructor applications, instances of this class for primitive types, and a variety of traversals.