Containers with merging via monoidal accumulation. The Monoid instances provided by the containers and unordered-containers packages merge structures in a left-biased manner instead of using the underlying monoidal structure of the value. This package wraps the types provided by these packages, but provides Monoid instances implemented in terms of the value type's mappend'.

This library provides tools to create command line interfaces with ease.

Hpack is a format for Haskell packages. It is an alternative to the Cabal package format and follows different design principles. Hpack packages are described in a file named package.yaml. Both cabal2nix and stack support package.yaml natively. For other build tools the hpack executable can be used to generate a .cabal file from package.yaml.

This package defines a class, Hashable, for types that can be converted to a hash value. This class exists for the benefit of hashing-based data structures. The package provides instances for basic types and a way to combine hash values.

This package provides functions to fork threads and wait for their result, whether it's an exception or a normal value. Besides waiting for the termination of a single thread this package also provides functions to wait for a group of threads to terminate. This package is similar to the threadmanager, async and spawn packages. The advantages of this package are:

• Simpler API.

• More efficient in both space and time.

• No space-leak when forking a large number of threads.

• Correct handling of asynchronous exceptions.

• GHC specific functionality like forkOn and forkIOWithUnmask.

This library provides a class for non-negative numbers, a wrapper which can turn any ordered numeric type into a member of that class, and a lazy number type for non-negative numbers (a generalization of Peano numbers).

This package provides a Pure Haskell implementation of the SplitMix pseudorandom number generator. SplitMix is a "splittable" pseudorandom number generator that is quite fast: 9 64-bit arithmetic/logical operations per 64 bits generated. SplitMix is tested with two standard statistical test suites (DieHarder and TestU01, this implementation only using the former) and it appears to be adequate for "everyday" use, such as Monte Carlo algorithms and randomized data structures where speed is important. In particular, it should not be used for cryptographic or security applications, because generated sequences of pseudorandom values are too predictable (the mixing functions are easily inverted, and two successive outputs suffice to reconstruct the internal state).

When you've caught all the exceptions that can be handled safely, this is what you're left with.

A package for convenient access to high-resolution clock and timer functions of different operating systems via a unified API.

Monad classes using type families, with instances for various monad transformers, inspired by the paper 'Functional Programming with Overloading and Higher-Order Polymorphism', by Mark P Jones. This package is almost a compatible replacement for the mtl-tf package.

This package provides a Cairo vector graphics rendering backend for the Charts library.

This package works as a prelude replacement for Haskell, providing more functionality and types out of the box than the standard prelude (such as common data types like ByteString and Text), as well as removing common ``gotchas'', like partial functions and lazy I/O. The guiding principle here is:

• If something is safe to use in general and has no expected naming conflicts, expose it.

• If something should not always be used, or has naming conflicts, expose it from another module in the hierarchy.

This package provides first class functional references. In addition to the usual operations of getting, setting and composition, plus integration with the state monad, lens families provide some unique features:

• Polymorphic updating

• Traversals

• Cast projection functions to read-only lenses

• Cast toList functions to read-only traversals

• Cast semantic editor combinators to modify-only traversals

For optimal first-class support use the lens-family package with rank 2/rank N polymorphism. Lens.Family.Clone allows for first-class support of lenses and traversals for those who require Haskell 98.

This package provides a Haskell library for working with base16-encoded data quickly and efficiently, using the ByteString type.

This package provides the ShortText type which is suitable for keeping many short strings in memory. This is similar to how ShortByteString relates to ByteString.

The main difference between Text and ShortText is that ShortText uses UTF-8 instead of UTF-16 internally and also doesn't support zero-copy slicing (thereby saving 2 words). Consequently, the memory footprint of a (boxed) ShortText value is 4 words (2 words when unboxed) plus the length of the UTF-8 encoded payload.

This package contains basic primitives for the Foundation set of packages.

This package is a compatibility package for a singleton data type . > data Solo a = Solo a . Note: it's not a @newtype@ . @Solo@ is available in @base-4.16@ (GHC-9.2).

This library contains simple and easy-to-use primitives for I/O using streams.

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.

Haskeline provides a user interface for line input in command-line programs. This library is similar in purpose to readline, but since it is written in Haskell it is (hopefully) more easily used in other Haskell programs.

Haskeline runs both on POSIX-compatible systems and on Windows.

This package provides a Haskell library for globbing: matching patterns against file paths.

This package provides an interface to the directory package for users of path. It also implements some missing stuff like recursive scanning and copying of directories, working with temporary files/directories, and more.

This package provides the core modules underlying diagrams, an embedded domain-specific language for compositional, declarative drawing.

Zstandard compression packaged as a conduit. This is a very thin wrapper around the official hs-zstd interface.