This Haskell package provides three useful generalizations:

class Functor f => FunctorWithIndex i f | f -> i where
  imap :: (i -> a -> b) -> f a -> f b

class Foldable f => FoldableWithIndex i f | f -> i where
  ifoldMap :: Monoid m => (i -> a -> m) -> f a -> m

class (FunctorWithIndex i t, FoldableWithIndex i t, Traversable t)
       => TraversableWithIndex i t | t -> i where
  itraverse :: Applicative f => (i -> a -> f b) -> t a -> f (t b)

The ghc-keys package provides similar functionality, but uses associated TypeFamilies instead of FunctionalDependencies.

This Haskell package provides an API for constructing vectors. It provides the composable Builder abstraction, which has instances of the Monoid and Semigroup classes.

You would first use the Builder abstraction to specify the structure of the vector; then you can execute the builder to actually produce the vector.

This library provides the POSIX regex backend used by the Haskell library regex-base.

wordexp(3) wrapper library for Haskell to perform word expansion like a posix-shell.

A library for generating concise pretty printers based on precedence rules.

This Haskell package provides extras for the ghc-contravariant package.

This package contains a wrapped name module for TimeLocale.

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 Haskell package includes a thin sqlite3 wrapper based on the direct-sqlite package, as well as the entire C library, so there are no system dependencies.

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.

Concatenative gives Haskell Factor-style combinators and arrows for postfix notation. For more information on stack based languages, see https://concatenative.org.

This Haskell library provides implementations of special mathematical functions and Chebyshev polynomials. These functions are often useful in statistical and numerical computing.

This package provides a simple type class for converting values of different string types into values of other string types.

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.

Uniplate is a library for writing simple and concise generic operations. Uniplate has similar goals to the original Scrap Your Boilerplate work, but is substantially simpler and faster.

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

Backported versions of types that were added to transformers in transformers 0.3 and 0.4 for users who need strict transformers 0.2 or 0.3 compatibility to run on old versions of the platform.

The mockery package provides support functions for automated testing.

The ListLike module provides a common interface to the various Haskell types that are list-like. Predefined interfaces include standard Haskell lists, Arrays, ByteStrings, and lazy ByteStrings. Custom types can easily be made ListLike instances as well.

ListLike also provides for String-like types, such as String and ByteString, for types that support input and output, and for types that can handle infinite lists.

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

This library provides convenient combinators for working with and building parsing combinator libraries. Given a few simple instances, you get access to a large number of canned definitions. Instances exist for the parsers provided by parsec, attoparsec and base's Text.Read.

This library provides Haskell bindings to the Zstandard compression algorithm, a fast lossless compression algorithm targeting real-time compression scenarios at zlib-level and better compression ratios.

This package provides a Haskell type inhabited by finitely many values and indexed by type-level naturals.

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