This package provides an API to Haddock, the documentation-generation tool for Haskell libraries.

This package provides the Network.Multicast Haskell module for sending UDP datagrams over multicast (class D) addresses.

This package provides access to platform dependent file locking APIs. There are alternative file locking packages:

• GHC.IO.Handle.Lock in base >= 4.10 is good enough for most use cases. However, uses only Handles so these locks cannot be used for intra-process locking.

• ghc-filelock doesn't support OFD locking.

An embeddable Lua REPL built with Isocline and HsLua.

This library uses GHC.Generics to derive efficient optics (traversals, lenses and prisms) for algebraic data types in a type-directed way, with a focus on good type inference and error messages when possible. This package is the shared internal logic of the generic-lens and generic-optics libraries.

This package provides a modular backend for rendering diagrams created with the diagrams embedded domain-specific language (EDSL) to Scalable Vector Graphics (SVG) files.

Manipulate identifiers and structurally non-complex pieces of text by delimiting word boundaries via a combination of whitespace, control-characters, and case-sensitivity.

Has support for common idioms like casing of programmatic variable names, taking, dropping, and splitting by word, and modifying the first character of a piece of text.

Caution: this library makes heavy use of the text library's internal loop optimisation framework. Since internal modules are not guaranteed to have a stable API there is potential for build breakage when the text dependency is upgraded. Consider yourself warned!

LeanCheck is a simple enumerative property-based testing library. Properties are defined as Haskell functions returning a boolean value which should be true for all possible choices of argument values. LeanCheck applies enumerated argument values to these properties in search for a counterexample. Properties can be viewed as parameterized unit tests. LeanCheck works by producing tiers of test values: a possibly infinite list of finite sublists of same-and-increasingly-sized values.

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.

This package provides a Haskell library for working with files and directories. It includes code for pattern matching, finding files, modifying file contents, and more.

This module provides set and multiset operations on ordered lists.

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 a mid-Level PostgreSQL client library, forked from ghc-mysql-simple.

This package provides a simple wrapper to show the used CPU time of monadic computation with an IO base.

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 defines the type class MonadBaseControl, a subset of MonadBase into which generic control operations such as catch can be lifted from IO or any other base monad.

This Haskell package is intended for those who are tired of keeping long lists of dependencies to the same essential libraries in each package as well as the endless imports of the same APIs all over again.

It also supports the modern tendencies in the language.

To solve those problems this package does the following:

• Reexport the original APIs under the Rebase namespace.

• Export all the possible non-conflicting symbols from the Rebase.Prelude module.

• Give priority to the modern practices in the conflicting cases.

The policy behind the package is only to reexport the non-ambiguous and non-controversial APIs, which the community has obviously settled on. The package is intended to rapidly evolve with the contribution from the community, with the missing features being added with pull-requests.

The Par monad offers an API for parallel programming. The library works for parallelising both pure and IO computations, although only the pure version is deterministic. The default implementation provides a work-stealing scheduler and supports forking tasks that are much lighter weight than IO-threads.

This library provides the functions to find unique and duplicate elements in a list.

This package is a compatibility package for a singleton data type . > data Solo a = Solo a . Note: it's not a @newtype@ . @Solo@ is available in @base-4.16@ (GHC-9.2).

This package provides a writer monad for multi-line string literals.

This library provides functions available in later versions of base to a wider range of compilers, without requiring the use of CPP pragmas in your code.

Long lived application data typically should not contain any thunks. This library can be used to examine values for unexpected thunks, which can then be used in assertions. This can be invaluable in avoiding memory leaks, or tracking down existing ones.

The threadDelay and timeout functions from the Haskell base library use the bounded Int type for specifying the delay or timeout period. This package provides alternative functions which use the unbounded Integer type.