This library provides fast, packed, strict storable arrays with a list interface, a chunky lazy list interface with variable chunk size and an interface for write access via the ST monad. This is much like bytestring and binary but can be used for every Foreign.Storable.Storable type. See also https://hackage.haskell.org/package/vector, a library with a similar intention.

This library does not do advanced fusion optimization, since especially for lazy vectors this would either be incorrect or not applicable. See https://hackage.haskell.org/package/storablevector-streamfusion for a library that provides fusion with lazy lists.

Tabular provides a Haskell representation of two-dimensional data tables, the kind that you might find in a spreadsheet or or a research report. It also comes with some default rendering functions for turning those tables into ASCII art, simple text with an arbitrary delimiter, CSV, HTML or LaTeX.

Below is an example of the kind of output this library produces. The tabular package can group rows and columns, each group having one of three separators (no line, single line, double line) between its members.

    || memtest 1 | memtest 2 ||  time test  | time test 2
====++===========+===========++=============+============
A 1 ||       hog |  terrible ||        slow |      slower
A 2 ||       pig |   not bad ||        fast |     slowest
----++-----------+-----------++-------------+------------
B 1 ||      good |     awful || intolerable |    bearable
B 2 ||    better | no chance ||    crawling |     amazing
B 3 ||       meh |   well... ||  worst ever |          ok

Provides an efficient Haskell implementation of Peano numbers

This Haskell package provides the core MonadUnliftIO typeclass, instances for base and transformers, and basic utility functions.

This package implements selective applicative functors, which allow you to declare your effects statically, and select which to execute dynamically. See the paper on selective functors for more details.

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 module allows tokens produced by skylighting-core to be rendered as LaTeX macros.

This package provides a simple (but internally ugly) memoization function.

A Haskell 98 logically uninhabited data type, used to indicate that a given term should not exist.

This package provides strict versions of some standard Haskell data types, such as pairs, Maybe and Either. It also contains strict IO operations.

This Haskell package contains code for generating high quality random numbers that follow either a uniform or normal distribution. The generated numbers are suitable for use in statistical applications.

The uniform PRNG uses Marsaglia's MWC256 (also known as MWC8222) multiply-with-carry generator, which has a period of 2^8222 and fares well in tests of randomness. It is also extremely fast, between 2 and 3 times faster than the Mersenne Twister.

This library provides Control.Lens. The combinators in Control.Lens provide a highly generic toolbox for composing families of getters, folds, isomorphisms, traversals, setters and lenses and their indexed variants.

This package provides a canonical anonymous 1-tuple type missing from Haskell for attaching typeclass instances.

There is also the OneTuple package which by using a boxed data-type provides a 1-tuple type which has laziness properties which are more faithful to the ones of Haskell's native tuples; whereas the primary purpose of Only is to provide the traditionally so named type-wrapper for attaching typeclass instances.

This library provides opaque unique identifiers in primitive state monads and a GADT-like type using them as witnesses of type equality.

Diagrams is a flexible, extensible embedded domain-specific language (EDSL) for creating graphics of many types. Graphics can be created in arbitrary vector spaces and rendered with multiple backends. This package provides a standard library of primitives and operations for creating diagrams.

This package includes Hakell modules providing various helper functions for Lists, Maybes, Tuples, Functions.

This package provides a stronger variant of `traverse` which can remove elements and generalised mapMaybe, catMaybes, filter

This package defines orphan instances that mimic instances available in later versions of base to a wider (older) range of compilers.

This package implements the bijection between JSON and CBOR defined in the CBOR specification, RFC 7049.

This package defines a class for types with a default value, and provides instances for types from the base, containers, dlist and old-locale packages.

This library provides functions to read, write and manipulate MIDI, WAVE and SoundFont2 multimedia files. It is written entirely in Haskell (without any FFI). It uses efficient parsing and building combinators for binary data stored in ByteStrings (based on the one in binary package).

This package is a Haskell library for the representation, parsing, and pretty-printing of GLSL 1.50 code.

This package provides bifunctors for Haskell.

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.