Hoogle Search

Within LTS Haskell 8.12 (ghc-8.0.2)

  1. package base

    Basic libraries This package contains the Prelude and its support libraries, and a large collection of useful libraries ranging from data structures to parsing combinators and debugging utilities.

  2. package bytestring

    Fast, compact, strict and lazy byte strings with a list interface An efficient compact, immutable byte string type (both strict and lazy) suitable for binary or 8-bit character data. The ByteString type represents sequences of bytes or 8-bit characters. It is suitable for high performance use, both in terms of large data quantities, or high speed requirements. The ByteString functions follow the same style as Haskell's ordinary lists, so it is easy to convert code from using String to ByteString. Two ByteString variants are provided:

    • Strict ByteStrings keep the string as a single large array. This makes them convenient for passing data between C and Haskell.
    • Lazy ByteStrings use a lazy list of strict chunks which makes it suitable for I/O streaming tasks.
    The Char8 modules provide a character-based view of the same underlying ByteString types. This makes it convenient to handle mixed binary and 8-bit character content (which is common in many file formats and network protocols). The Builder module provides an efficient way to build up ByteStrings in an ad-hoc way by repeated concatenation. This is ideal for fast serialisation or pretty printing. There is also a ShortByteString type which has a lower memory overhead and can can be converted to or from a ByteString, but supports very few other operations. It is suitable for keeping many short strings in memory. ByteStrings are not designed for Unicode. For Unicode strings you should use the Text type from the text package. These modules are intended to be imported qualified, to avoid name clashes with Prelude functions, e.g.
    import qualified Data.ByteString as BS

  3. package text

    An efficient packed Unicode text type. An efficient packed, immutable Unicode text type (both strict and lazy), with a powerful loop fusion optimization framework. The Text type represents Unicode character strings, in a time and space-efficient manner. This package provides text processing capabilities that are optimized for performance critical use, both in terms of large data quantities and high speed. The Text type provides character-encoding, type-safe case conversion via whole-string case conversion functions. It also provides a range of functions for converting Text values to and from ByteStrings, using several standard encodings. Efficient locale-sensitive support for text IO is also supported. These modules are intended to be imported qualified, to avoid name clashes with Prelude functions, e.g.

    import qualified Data.Text as T
    To use an extended and very rich family of functions for working with Unicode text (including normalization, regular expressions, non-standard encodings, text breaking, and locales), see the text-icu package: http://hackage.haskell.org/package/text-icu

  4. package containers

    Assorted concrete container types This package contains efficient general-purpose implementations of various basic immutable container types. The declared cost of each operation is either worst-case or amortized, but remains valid even if structures are shared.

  5. package transformers

    Concrete functor and monad transformers A portable library of functor and monad transformers, inspired by the paper "Functional Programming with Overloading and Higher-Order Polymorphism", by Mark P Jones, in Advanced School of Functional Programming, 1995 (http://web.cecs.pdx.edu/~mpj/pubs/springschool.html). This package contains:

    • the monad transformer class (in Control.Monad.Trans.Class) and IO monad class (in Control.Monad.IO.Class)
    • concrete functor and monad transformers, each with associated operations and functions to lift operations associated with other transformers.
    The package can be used on its own in portable Haskell code, in which case operations need to be manually lifted through transformer stacks (see Control.Monad.Trans.Class for some examples). Alternatively, it can be used with the non-portable monad classes in the mtl or monads-tf packages, which automatically lift operations introduced by monad transformers through other transformers.

  6. package mtl

    Monad classes, using functional dependencies Monad classes using functional dependencies, with instances for various monad transformers, inspired by the paper Functional Programming with Overloading and Higher-Order Polymorphism, by Mark P Jones, in Advanced School of Functional Programming, 1995 (http://web.cecs.pdx.edu/~mpj/pubs/springschool.html).

  7. package QuickCheck

    Automatic testing of Haskell programs QuickCheck is a library for random testing of program properties. The programmer provides a specification of the program, in the form of properties which functions should satisfy, and QuickCheck then tests that the properties hold in a large number of randomly generated cases. Specifications are expressed in Haskell, using combinators defined in the QuickCheck library. QuickCheck provides combinators to define properties, observe the distribution of test data, and define test data generators. You can find a (slightly out-of-date but useful) manual at http://www.cse.chalmers.se/~rjmh/QuickCheck/manual.html.

  8. package time

    A time library A time library

  9. package hspec

    A Testing Framework for Haskell Hspec is a testing framework for Haskell. It is inspired by the Ruby library RSpec. Some of Hspec's distinctive features are:

    • a friendly DSL for defining tests
    • integration with QuickCheck, SmallCheck, and HUnit
    • parallel test execution
    • automatic discovery of test files
    The Hspec Manual is at http://hspec.github.io/.

  10. package directory

    Platform-agnostic library for filesystem operations This library provides a basic set of operations for manipulating files and directories in a portable way.

Page 1 of many | Next