This package provides state variables, which are references in the IO monad, like IORefs or parts of the OpenGL state.

This library provides support for parsing and generating BitTorrent files.

Highlighting-kate is a syntax highlighting library with support for nearly one hundred languages. The syntax parsers are automatically generated from Kate syntax descriptions, so any syntax supported by Kate can be added. An (optional) command-line program is provided, along with a utility for generating new parsers from Kate XML syntax descriptions.

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.

Rose (n-ary) trees with both upwards- (i.e. cached) and downwards-traveling (i.e. accumulating) monoidal annotations. This is used as the core data structure underlying the diagrams framework, but potentially has other applications as well.

To store passwords securely, they should be salted, then hashed with a slow hash function. This library uses PBKDF1-SHA256, and handles all the details. It uses the cryptohash package for speed; if you need a pure Haskell library, pwstore-purehaskell has the exact same API, but uses only pure Haskell. It is about 25 times slower than this package, but still quite usable.

This package provides a Haskell module for creating 2D and 3D plots using gnuplot.

This package addresses the 'configuration problem' which is propagating configurations that are available at run-time, allowing multiple configurations to coexist without resorting to mutable global variables or System.IO.Unsafe.unsafePerformIO.

Generate routines for integer division, employing arithmetic and bitwise operations only, which are __2.5x-3.5x faster__ than quot'. Divisors must be known in compile-time and be positive.

Utilities to parse, print, diff, and analyse data in CoNLL-U, a format used in linguistics to represent the syntactic annotation of sentences. See https://universaldependencies.org/format.html

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

The module Data.CaseInsensitive provides the CI type constructor which can be parameterised by a string-like type like: String, ByteString, Text, etc. Comparisons of values of the resulting type will be insensitive to cases.

A clone of wl-pprint for use with the text library.

This package provides a library to parse and render YAML documents.

For examples and an introduction to the library please take a look at the <https://github.com/CRogers/should-not-typecheck#should-not-typecheck- README> on github.

This library implements a technique to catch all exceptions raised within an enclosed computation, while remaining responsive to (external) asynchronous exceptions.

This package profides a class for encoding and decoding UTF8 strings with instances for several common types. It also includes several functions for working with UTF8. It aims to be lightweight, depending only on Base and including only one module.

A PointedList tracks the position in a non-empty list which works similarly to a zipper. A current item is always required, and therefore the list may never be empty. A circular PointedList wraps around to the other end when progressing past the actual edge.

Using the API Annotations available from GHC 7.10.2, this library provides a means to round-trip any code that can be compiled by GHC, currently excluding .lhs files.

libyaml C source code for yaml bindings.

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

This package (formerly binary-serialise-cbor) provides pure, efficient serialization of Haskell values directly into ByteStrings for storage or transmission purposes. By providing a set of type class instances, you can also serialise any custom data type you have as well.

The underlying binary format used is the 'Concise Binary Object Representation', or CBOR, specified in RFC 7049. As a result, serialised Haskell values have implicit structure outside of the Haskell program itself, meaning they can be inspected or analyzed without custom tools.

An implementation of the standard bijection between CBOR and JSON is provided by the https://hackage.haskell.org/package/cborg-json package. Also see https://hackage.haskell.org/package/cbor-tool for a convenient command-line utility for working with CBOR data.

This package turn Data.Serialize Gets and Puts into Sources, Sinks, and Conduits.

This package provides Haskell bindings to the SDL2_gfx graphics library.