Efficient hashing-based container types. The containers have been optimized for performance critical use, both in terms of large data quantities and high speed.

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

Provides Arbitrary instances for fgl graphs to avoid adding a QuickCheck dependency for fgl whilst still making the instances available to others. Also available are non-fgl-specific functions for generating graph-like data structures.

This package allows simple reflection of expressions containing variables. Reflection here means that a Haskell expression is turned into a string. The primary aim of this package is teaching and understanding; there are no options for manipulating the reflected expressions beyond showing them.

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.

Boxes is a pretty-printing library for laying out text in two dimensions, using a simple box model.

This package provides bindings and types to bridge Haskell and <https://www.lua.org/ Lua>. . The full Lua interpreter version 5.4.4 is included. Alternatively, a system-wide Lua installation can be linked instead.

This package provides a family of combinators for defining webservices APIs and serving them . You can learn about the basics in the <http://docs.servant.dev/en/stable/tutorial/index.html tutorial>. . <https://github.com/haskell-servant/servant/blob/master/servant/CHANGELOG.md CHANGELOG>

PCG is a family of simple fast space-efficient statistically good algorithms for random number generation. Unlike many general-purpose RNGs, they are also hard to predict. . This library implements bindings to the standard C implementation. This includes the standard, unique, fast and single variants in the pcg family. There is a pure implementation that can be used as a generator with the random package as well as a faster primitive api that includes functions for generating common types. . The generators in this module are suitable for use in parallel but make sure threads don't share the same generator or things will go horribly wrong.

This library provides wrappers around Prelude and Data.List functions, such as head and !!, that can throw exceptions.

This Haskell package was originally present in classy-prelude.

IWlib is a thin Haskell binding to the iw C library. It provides information about the current wireless network connections, and adapters on supported systems.

This library defines a propositional equality data type, shims Data.Type.Equality as well as possible for older GHC versions (< 7.8).

data a :~: b where
  Refl :: a :~: a

The module Data.Type.Equality.Hetero shims @code:~~: equality, and for compilers with PolyKinds.

This library provides a half-precision floating-point computation library for Haskell.

This package provides a means of generating tag files for Emacs and Vim.

This package allows you to have a README.md that at the same time is a literate Haskell program.

This module allows tokens produced by skylighting-core to be rendered as ConTeXt commands.

This package provides a dependent sum is a generalization of a particular way of thinking about the Either type. Either a b can be thought of as a 2-tuple (tag, value), where the value of the tag determines the type of the value. In particular, either tag = Left and value :: a or tag = Right and value :: b. This package allows you to define your own dependent sum types by using your own "tag" types.

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.

The premise of basic-prelude is that there are a lot of very commonly desired features missing from the standard Prelude, such as commonly used operators (<$> and >=>, for instance) and imports for common datatypes (e.g., ByteString and Vector). At the same time, there are lots of other components which are more debatable, such as providing polymorphic versions of common functions.

So basic-prelude is intended to give a common foundation for a number of alternate preludes. The package provides two modules: CorePrelude provides the common ground for other preludes to build on top of, while BasicPrelude exports CorePrelude together with commonly used list functions to provide a drop-in replacement for the standard Prelude.

Users wishing to have an improved Prelude can use BasicPrelude. Developers wishing to create a new prelude should use CorePrelude.

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 a simple network library for all your connection needs. It provides a very simple API to create sockets to a destination with the choice of SSL/TLS, and SOCKS.

This package provides a UTF-8 aware subset of Lua's string module for Haskell. The functions provided by this module are upper, lower, len, reverse, and sub.

This Haskell library generates pretty hex dumps of ByteStrings in the style of other common *nix hex dump tools.