This library provides a YAML 1.2 parser implementation for Haskell. Its features include:

• Pure Haskell implementation with small dependency footprint and emphasis on strict compliance with the YAML 1.2 specification.

• Direct decoding to native Haskell types via (aeson-inspired) typeclass-based API (see Data.YAML).

• Support for constructing custom YAML node graph representation (including support for cyclic YAML data structures).

• Support for the standard (untyped) Failsafe, (strict) JSON, and (flexible) Core ``schemas'' providing implicit typing rules as defined in the YAML 1.2 specification (including support for user-defined custom schemas).

• Event-based API resembling LibYAML's Event-based API (see Data.YAML.Event).

• Low-level API access to lexical token-based scanner (see Data.YAML.Token).

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.

A data-type like Either but with differing properties and type-class instances.

Library support is provided for this different representation, including lens-related functions for converting between each and abstracting over their similarities.

The Validation data type is isomorphic to Either, but has an instance of Applicative that accumulates on the error side. That is to say, if two (or more) errors are encountered, they are appended using a Semigroup operation.

As a consequence of this Applicative instance, there is no corresponding Bind or Monad instance. Validation is an example of, "An applicative functor that is not a monad."

This package includes Hakell modules providing various helper functions for Lists, Maybes, Tuples, Functions.

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 library provides mechanisms to efficiently run periodic, on-demand actions in Haskell.

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 ordered containers of intervals, with efficient search for all keys containing a point or overlapping an interval. See the example code on the home page for a quick introduction.

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.

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

Experimental Hspec support for testing WAI applications

This Haskell library provides pointed and copointed data types.

OpenGLRaw is a raw Haskell binding for the OpenGL 4.5 graphics system and lots of OpenGL extensions. It is basically a 1:1 mapping of OpenGL's C API, intended as a basis for a nicer interface. OpenGLRaw offers access to all necessary functions, tokens and types plus a general facility for loading extension entries. The module hierarchy closely mirrors the naming structure of the OpenGL extensions, making it easy to find the right module to import. All API entries are loaded dynamically, so no special C header files are needed for building this package. If an API entry is not found at runtime, a userError is thrown.

This is the IRC core library for glirc. The client is available in its own glirc package.

A thread safe API to write a line of textual data to a Handle, such as sending some messages to the terminal - that has the following properties:

• Properly handle character encoding settings on the Handle

• For reasonably sized messages, ensure that the entire message is written in one chunk to avoid interleaving data with other threads

• Avoid unnecessary memory allocations and copies

• Minimize locking.

This Haskell package aims to reexport all the non-conflicting and most general definitions from the "base" package.

This includes APIs for applicatives, arrows, monoids, foldables, traversables, exceptions, generics, ST, MVars and STM.

This package will never have any dependencies other than "base".

Versioning policy:

The versioning policy of this package deviates from PVP in the sense that its exports in part are transitively determined by the version of "base". Therefore it's recommended for the users of ghc-base-prelude to specify the bounds of "base" as well.

This Haskell library provides a Lua module to work with file paths in a platform independent way.

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 one module layer over regex-posix to replace Text.Regex.

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 implements the bijection between JSON and CBOR defined in the CBOR specification, RFC 7049.

This library provides exception safe semaphores that can be used in place of QSem, QSemN, and SampleVar, all of which are not exception safe and can be broken by killThread.

This library provides the ability to launch and interact with external processes. It wraps around the process library, and intends to improve upon it.

This Haskell package contains Template Haskell functions for generating functions similar to those in Data.List for tuples of statically known size.