Hoogle Search

Within LTS Haskell 24.49 (ghc-9.10.3)

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

  1. package persistent-sqlite

    Backend for the persistent library using sqlite3. This package includes a thin sqlite3 wrapper based on the direct-sqlite package, as well as the entire C library, so there are no system dependencies.

  2. package prettyprinter-ansi-terminal

    ANSI terminal backend for the »prettyprinter« package. See README.md

  3. package rio

    A standard library for Haskell See README and Haddocks at https://www.stackage.org/package/rio

  4. package shakespeare

    A toolkit for making compile-time interpolated templates Shakespeare is a family of type-safe, efficient template languages. Shakespeare templates are expanded at compile-time, ensuring that all interpolated variables are in scope. Variables are interpolated according to their type through a typeclass. Shakespeare templates can be used inline with a quasi-quoter or in an external file. Note there is no dependency on haskell-src-extras. Instead Shakespeare believes logic should stay out of templates and has its own minimal Haskell parser. Packages that use this: xml-hamlet Please see the documentation at http://www.yesodweb.com/book/shakespearean-templates for more details.

  5. package vault

    a persistent store for values of arbitrary types A vault is a persistent store for values of arbitrary types. It's like having first-class access to the storage space behind IORefs. . The data structure is analogous to a bank vault, where you can access different bank boxes with different keys; hence the name. . Also provided is a locker type, representing a store for a single element.

  6. package HTTP

    A library for client-side HTTP The HTTP package supports client-side web programming in Haskell. It lets you set up HTTP connections, transmitting requests and processing the responses coming back, all from within the comforts of Haskell. It's dependent on the network package to operate, but other than that, the implementation is all written in Haskell. A basic API for issuing single HTTP requests + receiving responses is provided. On top of that, a session-level abstraction is also on offer (the BrowserAction monad); it taking care of handling the management of persistent connections, proxies, state (cookies) and authentication credentials required to handle multi-step interactions with a web server. The representation of the bytes flowing across is extensible via the use of a type class, letting you pick the representation of requests and responses that best fits your use. Some pre-packaged, common instances are provided for you (ByteString, String). Here's an example use: 

    do
rsp <- Network.HTTP.simpleHTTP (getRequest "http://www.haskell.org/")
-- fetch document and return it (as a 'String'.)
fmap (take 100) (getResponseBody rsp)

do
(_, rsp)
<- Network.Browser.browse $ do
setAllowRedirects True -- handle HTTP redirects
request $ getRequest "http://www.haskell.org/"
return (take 100 (rspBody rsp))
    Note: This package does not support HTTPS connections. If you need HTTPS, take a look at the following packages:

  7. package atomic-primops

    A safe approach to CAS and other atomic ops in Haskell. After GHC 7.4 a new `casMutVar#` primop became available, but it's difficult to use safely, because pointer equality is a highly unstable property in Haskell. This library provides a safer method based on the concept of Tickets. . Also, this library uses the "foreign primop" capability of GHC to add access to other variants that may be of interest, specifically, compare and swap inside an array. . Note that as of GHC 7.8, the relevant primops have been included in GHC itself. This library is engineered to work pre- and post-GHC-7.8, while exposing the same interface.

  8. package byteable

    Type class for sequence of bytes Abstract class to manipulate sequence of bytes The use case of this class is abstracting manipulation of types that are just wrapping a bytestring with stronger and more meaniful name. Usual definition of those types are of the form: newtype MyType = MyType ByteString

  9. package errors

    Simplified error-handling The one-stop shop for all your error-handling needs! Just import Control.Error. This library encourages an error-handling style that directly uses the type system, rather than out-of-band exceptions.

  10. package generics-sop

    Generic Programming using True Sums of Products A library to support the definition of generic functions. Datatypes are viewed in a uniform, structured way: the choice between constructors is represented using an n-ary sum, and the arguments of each constructor are represented using an n-ary product. The module Generics.SOP is the main module of this library and contains more detailed documentation. Since version 0.4.0.0, this package is now based on sop-core. The core package contains all the functionality of n-ary sums and products, whereas this package provides the datatype-generic programming support on top. Examples of using this library are provided by the following packages:

    A detailed description of the ideas behind this library is provided by the paper:

Page 23 of many | Previous | Next