Shelly provides convenient systems programming in Haskell, similar in spirit to POSIX shells. Shelly is originally forked from the Shellish package.

HAProxy protocol version 1.5 support (see http://haproxy.1wt.eu/download/1.5/doc/proxy-protocol.txt) for applications using io-streams. The proxy protocol allows information about a networked peer (like remote address and port) to be propagated through a forwarding proxy that is configured to speak this protocol.

This library provides a fast parser combinator library, aimed particularly at dealing efficiently with network protocols and complicated text/binary file formats.

ghc-blaze-textual is a fast Haskell library for rendering common Haskell datatypes in text form using the ghc-blaze-builder library.

SecureMem is similar to ByteString, except that it provides a memory chunk that will be auto-scrubbed after it run out of scope.

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

This package exposes combinators that can wrap arbitrary monadic actions. They run the action and potentially retry running it with some configurable delay for a configurable number of times. The purpose is to make it easier to work with IO and especially network IO actions that often experience temporary failure and warrant retrying of the original action. For example, a database query may time out for a while, in which case we should hang back for a bit and retry the query instead of simply raising an exception.

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 includes 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, but also need those types.

This package contains the generics system described in the /Scrap Your Boilerplate/ papers (see the website). It defines the Data class of types permitting folding and unfolding of constructor applications, instances of this class for primitive types, and a variety of traversals.

RFC 4648-compliant Base64 with an eye towards performance and modernity (additional support for RFC 7049 standards)

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.

This package provides instances to push and receive any datatype encodable as JSON to and from the Lua stack.

This package provides the following modules: Math.NumberTheory.Logarithms and Math.NumberTheory.Powers.Integer from the arithmoi package, GHC.Integer.Logarithms.Compat and Math.NumberTheory.Power.Natural, as well as some additional functions in migrated modules.

Protolude gives you sensible defaults for writing custom Preludes to replace the standard one provided by GHC.

Haskell library for opening the web browser.

This package contains a MonadRef type class that abstracts over the details of manipulating references, allowing one to write code that can operate in either the ST monad or the IO monad.

This package is an enhancement of the Text.Regex library, providing the PCRE backend to accompany regex-base, with bundled code from https://www.pcre.org.

The YAML 1.2 format provides a much richer data-model and feature-set than the JavaScript Object Notation format. However, sometimes it's desirable to ignore the extra capabilities and treat YAML as if it was merely a more convenient markup format for humans to write JSON data. To this end this module provides a compatibility layer atop ghc-hsyaml ,which allows decoding YAML documents in the more limited JSON data-model while also providing convenience by reusing ghc-aeson's FromJSON instances for decoding the YAML data into native Haskell data types.

This package provides modules containing facilities for manipulating Haskell source code using Template Haskell. See http://www.haskell.org/haskellwiki/Template_Haskell for more information.

This library encourages an error-handling style that directly uses the type system, rather than out-of-band exceptions.

This Haskell package provides a lens library, just like ghc-lens, but smaller. It provides essential lenses and traversals (like _1 and _Just), as well as ones which are simply nice to have (like each, at, and ix), and some combinators (like failing and singular), but everything else is stripped. As the result, this package has no dependencies.

This library defines a data structure for representing Jupyter notebooks, along with ToJSON and FromJSON instances for conversion to and from JSON .ipynb files.

This package provides various primitive memory-related operations.