Hoogle Search

Within LTS Haskell 22.17 (ghc-9.6.4)

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

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.
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 be converted to or from a ByteString. 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
```
package text

An efficient packed Unicode text type. An efficient packed, immutable Unicode text type (both strict and lazy). 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.
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.
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.
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)
- 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.
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 official QuickCheck manual. It's a bit out-of-date in some details and doesn't cover newer QuickCheck features, but is still full of good advice.
- https://begriffs.com/posts/2017-01-14-design-use-quickcheck.html, a detailed tutorial written by a user of QuickCheck.
The quickcheck-instances companion package provides instances for types in Haskell Platform packages at the cost of additional dependencies.
package time

A time library Time, clocks and calendars
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 https://hspec.github.io/.
package tasty-hunit

HUnit support for the Tasty test framework. HUnit support for the Tasty test framework. Note that this package does not depend on HUnit but implements the relevant subset of its API. The name is a legacy of the early versions of tasty-hunit and of test-framework-hunit, which did depend on HUnit.

Page 1 of many | Next

Hoogle Search

ICU Support