The mockery package provides support functions for automated testing.

This library provides one module layer over regex-posix to replace Text.Regex.

This haskell library provides validity and validity-based testing for ghc-hspec.

Values of custom types usually have invariants imposed upon them. This package provides the Validity type class, which makes these invariants explicit by providing a function to check whether the invariants hold.

A binding to libffi, allowing C functions of types only known at runtime to be called from Haskell.

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.

A PointedList tracks the position in a non-empty list which works similarly to a zipper. A current item is always required, and therefore the list may never be empty. A circular PointedList wraps around to the other end when progressing past the actual edge.

This library provides various semigroups, specialized containers and a general map/reduce framework for Haskell.

This Haskell package offers a collection of channel types, similar to Control.Concurrent.STM.{TChan,TQueue} but with additional features.

A prettyprinter/text rendering engine. Easy to use, well-documented, ANSI terminal backend exists, HTML backend is trivial to implement, no name clashes, Text-based, extensible.

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.

The psqueues package provides Priority Search Queues in three different flavors:

• OrdPSQ k p v, which uses the Ord k instance to provide fast insertion, deletion and lookup. This implementation is based on Ralf Hinze's A Simple Implementation Technique for Priority Search Queues.

  Hence, it is similar to the PSQueue library, although it is considerably faster and provides a slightly different API.

• IntPSQ p v is a far more efficient implementation. It fixes the key type to Int and uses a https://en.wikipedia.org/wiki/Radix_tree, radix tree (like IntMap) with an additional min-heap property.

• HashPSQ k p v is a fairly straightforward extension of IntPSQ: it simply uses the keys' hashes as indices in the IntPSQ. If there are any hash collisions, it uses an OrdPSQ to resolve those. The performance of this implementation is comparable to that of IntPSQ, but it is more widely applicable since the keys are not restricted to Int, but rather to any Hashable datatype.

Each of the three implementations provides the same API, so they can be used interchangeably.

Typical applications of Priority Search Queues include:

• Caches, and more specifically LRU Caches;

• Schedulers;

• Pathfinding algorithms, such as Dijkstra's and A*.

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 package extends https://hackage.haskell.org/package/process. It allows you to read process input and output as ByteStrings or Text, or write your own ProcessOutput instance. It also provides lazy process input and output, and a ProcessMaker class for more flexibility in the process creation API.

Bindings to the Xft, X Free Type interface library, and some Xrender parts.

Network recv based on buffer pools

ByteString-backed Handles

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

Trifecta is a modern parser combinator library for Haskell, with slicing and Clang-style colored diagnostics.

Provides an efficient Haskell implementation of Peano numbers

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

This package provides Haskell bindings for libcmark, the reference parser for CommonMark, a fully specified variant of Markdown. It includes bundled libcmark sources, and does not require prior installation of the C library.

This package provides a Haskell library including a couple of different implementations of mutable hash tables in the ST monad, as well as a typeclass abstracting their common operations, and a set of wrappers to use the hash tables in the IO monad.

This package converts between bytestrings and their hexadecimal string representation.