This is a small wrapper around the directory, unix, and Win32 packages, for use with system-filepath. It provides a consistent API to the various versions of these packages distributed with different versions of GHC. In particular, this library supports working with POSIX files that have paths which can't be decoded in the current locale encoding.

This library provides wrappers around Prelude and Data.List functions, such as head and !!, that can throw exceptions.

This package makes it possible to define schemas for use when loading configuration files using the config-value format. These schemas can be used to process a configuration file into a Haskell value or to automatically generate documentation for the file format.

Utilities to package up Haskell functions and values into a Lua module. . This package is part of HsLua, a Haskell framework built around the embeddable scripting language <https://lua.org Lua>.

Haskellers are usually familiar with monoids and semigroups. A monoid has an appending operation <> (or mappend), and an identity element, mempty. A semigroup has an appending <> operation, but does not require a mempty element. A Semiring has two appending operations, plus and times, and two respective identity elements, zero and one. More formally, a Semiring R is a set equipped with two binary relations + and *, such that: (R,+) is a commutative monoid with identity element 0, (R,*) is a monoid with identity element 1, (*) left and right distributes over addition, and . multiplication by 0 annihilates R.

Skylighting is a syntax highlighting library with support for over one hundred languages. It derives its tokenizers from XML syntax definitions used by KDE's KSyntaxHighlighting framework, so any syntax supported by that framework can be added. An optional command-line program is provided. Skylighting is intended to be the successor to highlighting-kate. This package provides generated syntax modules based on the KDE XML definitions provided by the skylighting-core package.

This Haskell package provides additional data structures, and other added capabilities layered on top of the Par monad.

This Haskell package provides a replacement for Data.Conduit.List, as well as a convenient Conduit module.

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.

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 provides a quasi-quoter for raw SQL for ghc-persistent.

This package provides tools to parse Haskell sources to the template-haskell abstract syntax.

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 various primitive memory-related operations.

This package implements an API for accessing the Domain Name Service (DNS) resolver service via the standard libresolv system library (whose API is often available directly via the standard libc C library) on Unix systems.

Lua module wrapping Text.DocLayout.

This package provides implementation of the Wagner-Fischer dynamic programming algorithm to find the optimal edit script and cost between two sequences. The implementation in this package is specialised to sequences represented with Data.Vector but is otherwise agnostic to:

• The type of values in the vectors;

• The type representing edit operations; and

• The type representing the cost of operations.

This package contains bindings to the SDL 2 library, in both high- and low-level forms. The SDL namespace contains high-level bindings, where enumerations are split into sum types, and we perform automatic error-checking. The SDL.Raw namespace contains an almost 1-1 translation of the C API into Haskell FFI calls. As such, this does not contain sum types nor error checking. Thus this namespace is suitable for building your own abstraction over SDL, but is not recommended for day-to-day programming.

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 works as a prelude replacement for Haskell, providing more functionality and types out of the box than the standard prelude (such as common data types like ByteString and Text), as well as removing common ``gotchas'', like partial functions and lazy I/O. The guiding principle here is:

• If something is safe to use in general and has no expected naming conflicts, expose it.

• If something should not always be used, or has naming conflicts, expose it from another module in the hierarchy.

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.

Difference lists are a list-like type supporting O(1) append. This is particularly useful for efficient logging and pretty printing (e.g. with the Writer monad), where list append quickly becomes too expensive.

This package provides semigroups for Haskell. In mathematics, a semigroup is an algebraic structure consisting of a set together with an associative binary operation. A semigroup generalizes a monoid in that there might not exist an identity element. It also (originally) generalized a group (a monoid with all inverses) to a type where every element did not have to have an inverse, thus the name semigroup.

This is a small library for working with changes to JSON documents. It includes a library and two command-line executables in the style of the diff and patch commands available on many systems.