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*.

Hakyll is a static website compiler library. That is, it provides you with the tools to create a simple or advanced static website using a Haskell EDSL and input formats such as Markdown or RST.

This library provides file handling utilities for Haskell.

With this package you can build a Storable instance of a record type from Storable instances of its elements in an elegant way. It does not do any magic, just a bit arithmetic to compute the right offsets, that would be otherwise done manually or by a preprocessor like C2HS. There is no guarantee that the generated memory layout is compatible with that of a corresponding C struct. However, the module generates the smallest layout that is possible with respect to the alignment of the record elements.

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.

Automatically discover and run Hspec tests . <http://hspec.github.io/hspec-discover.html>

This library can load and store images in PNG, Bitmap, JPEG, Radiance, TIFF and GIF formats.

Lifted-base exports IO operations from the base library lifted to any instance of MonadBase or MonadBaseControl. Note that not all modules from base are converted yet. The package includes a copy of the monad-peel test suite written by Anders Kaseorg.

This Haskell package lets you automatically generate lenses for data types; code was extracted from the lens package, and therefore generated lenses are fully compatible with ones generated by lens (and can be used both from lens and microlens).

This package provides a pure interface for compressing and decompressing LZMA streams of data represented as lazy ByteStrings. A monadic incremental interface is provided as well.

This package provides a low-level networking interface.

This package provides both mutable and immutable Bloom filter data types, along with a family of hash functions and an easy-to-use interface.

This Haskell package includes tools for generating and consuming feeds in both RSS (Really Simple Syndication) and Atom format.

This package provides Haskell bindings for the OpenGL graphics system (GL, version 4.5) and its accompanying utility library (GLU, version 1.3).

Contravariant functors for Haskell.

This package provides a library for parallel programming.

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.

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.

This package provides a generic interface for multiple Vty platforms in one package so you don't have to conditionally depend on them in your cabal file.

Async provides a library to run IO operations asynchronously, and wait for their results. It is a higher-level interface over threads in Haskell, in which Async a is a concurrent thread that will eventually deliver a value of type a.

A reusable library containing hledger's core functionality. This is used by most hledger* packages so that they support the same common file formats, command line options, reports etc.

hledger is a robust, cross-platform set of tools for tracking money, time, or any other commodity, using double-entry accounting and a simple, editable file format, with command-line, terminal and web interfaces. It is a Haskell rewrite of Ledger, and one of the leading implementations of Plain Text Accounting.

This package contains a simple and pure LRU cache. The implementation is based on Data.Map from the containers library. Further, the package also containes a multiple IO wrapper that enables atomic updates of the cache.

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.

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.