Hoogle Search

Within LTS Haskell 17.9 (ghc-8.10.4)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

  1. package base

    Basic libraries This package contains the Standard Haskell 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 (see Data.Text). It also provides a range of functions for converting Text values to and from ByteStrings, using several standard encodings (see Data.Text.Encoding). Efficient locale-sensitive support for text IO is also supported (see Data.Text.IO). These modules are intended to be imported qualified, to avoid name clashes with Prelude functions, e.g.

    import qualified Data.Text as T
    

    ICU Support

    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 based on the well-respected and liberally licensed ICU library.

    Internal Representation: UTF-16 vs. UTF-8

    Currently the text library uses UTF-16 as its internal representation which is neither a fixed-width nor always the most dense representation for Unicode text. We're currently investigating the feasibility of changing Text's internal representation to UTF-8 and if you need such a Text type right now you might be interested in using the spin-off packages text-utf8 and text-short.

  4. package containers

    Assorted concrete container types This package contains efficient general-purpose implementations of various immutable container types including sets, maps, sequences, trees, and graphs. For a walkthrough of what this package provides with examples of common operations see the containers introduction. 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

    This package contains:
    • the monad transformer class (in Control.Monad.Trans.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 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 provided by QuickCheck. QuickCheck provides combinators to define properties, observe the distribution of test data, and define test data generators. Most of QuickCheck's functionality is exported by the main Test.QuickCheck module. The main exception is the monadic property testing library in Test.QuickCheck.Monadic. If you are new to QuickCheck, you can try looking at the following resources:

    The quickcheck-instances companion package provides instances for types in Haskell Platform packages at the cost of additional dependencies.

  7. package hspec

    A Testing Framework for Haskell Hspec is a testing framework for Haskell. 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/.

  8. 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).

  9. package tasty

    Modern and extensible testing framework Tasty is a modern testing framework for Haskell. It lets you combine your unit tests, golden tests, QuickCheck/SmallCheck properties, and any other types of tests into a single test suite.

  10. package time

    A time library Time, clocks and calendars

Page 1 of many | Next