This package provides a type-safe tool for generating XML code via quasi-quoting built on top of ghc-shakespeare.

This library provides backend-agnostic generation of client functions. For more information, see the README.

This library provides tools to calculate various string metrics efficiently.

The doctest program checks examples in source code comments. It is modeled after doctest for Python, see the Doctest website.

This package provides the number parsers without the need to use a large (and unportable) token parser.

Provides a FilePath datatype and utility functions for operating on it. Unlike the filepath package, this package does not simply reuse String, increasing type safety.

This package provides combinators for building fast hashing functions. It includes hashing functions for all basic Haskell98 types.

A clean and powerful stream processing library that lets you build and connect reusable streaming components. Advantages over traditional streaming libraries:

• Concise API: Use simple commands like for, (>->), await, and yield

• Blazing fast: Implementation tuned for speed, including shortcut fusion

• Lightweight Dependency: pipes is small and compiles very rapidly, including dependencies

• Elegant semantics: Use practical category theory

• ListT: Correct implementation of ListT that interconverts with pipes

• Bidirectionality: Implement duplex channels

This package provides functions for signed 15.16 precision fixed point arithmetic.

This package defines orphan instances that mimic instances available in later versions of base to a wider (older) range of compilers.

This package provides a Readable type class for reading data types from ByteString and Text. It also includes efficient implementations for common data types.

This package provides functions to prevent or capture writing to stdout and other handles.

Knowledge of GHC's installation directories.

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 Haskell modules to allow use of Accessor to access state in transformers State monad.

Contravariant functors for Haskell.

Cross platform library for file creation, modification, and deletion notification. This library builds upon existing libraries for platform specific Windows, Mac, and Linux file system event notification.

This library provides higher order versions of Prelude classes to ease programming with polymorphic recursion and reduce UndecidableInstances.

Diagrams is a flexible, extensible embedded domain-specific language (EDSL) for creating graphics of many types. Graphics can be created in arbitrary vector spaces and rendered with multiple backends. This package provides a standard library of primitives and operations for creating diagrams.

Cairo is a library to render high quality vector graphics. There exist various backends that allows rendering to Gtk windows, PDF, PS, PNG and SVG documents, amongst others.

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

This Haskell package provides the core MonadUnliftIO typeclass, instances for base and transformers, and basic utility functions.

Automatically discover and run Hspec tests . <http://hspec.github.io/hspec-discover.html>

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.