Hoogle Search

Within LTS Haskell 24.34 (ghc-9.10.3)

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

package download

High-level file download based on URLs High-level file download based on URLs
package download-curl

High-level file download based on URLs High-level file download based on URLs Download web content as strict or lazy bytestringrs, strings, HTML tags, XML, RSS or Atom feeds or JSON, using the curl network library. Importing the library:
```
import Network.Curl.Download
```
Loading a webpage as a ByteString:
```
doc  <- openURI "http://haskell.org"
```
Loading from a file:
```
doc  <- openURI "file:///tmp/A.hs"
```
Loading a HTML page as a list of tags:
```
tags <- openAsTags "http://haskell.org"
```
Loading a HTML page as XML:
```
tags <- openAsXML "http://haskell.org"
```
Loading an RSS or Atom feed:
```
feed <- openAsFeed "http://haskell.org"
```
These data types can the be processed further with the XML, Feed and TagSoup libraries.
package drifter-postgresql

PostgreSQL support for the drifter schema migration tool Support for postgresql-simple Query migrations as well as arbitrary Haskell IO functions. Be sure to check the examples dir for a usage example.
package drifter-sqlite

SQLite support for the drifter schema migraiton tool Please see the README on GitHub at https://github.com/MichaelXavier/drifter-sqlite#readme
package dsp

Haskell Digital Signal Processing Digital Signal Processing, Fourier Transform, Linear Algebra, Interpolation
package dublincore-xml-conduit

XML streaming parser/renderer for the Dublin Core standard elements. Cf README file.
package dunai

Generalised reactive framework supporting classic, arrowized and monadic FRP. Dunai is a DSL for strongly-typed CPS-based composable transformations. Dunai is based on a concept of Monadic Stream Functions (MSFs). MSFs are transformations defined by a function unMSF :: MSF m a b -> a -> m (b, MSF m a b) that executes one step of a simulation, and produces an output in a monadic context, and a continuation to be used for future steps. MSFs are a generalisation of the implementation mechanism used by Yampa, Wormholes and other FRP and reactive implementations. When combined with different monads, they produce interesting effects. For example, when combined with the Maybe monad, they become transformations that may stop producing outputs (and continuations). The Either monad gives rise to MSFs that end with a result (akin to Tasks in Yampa, and Monadic FRP). Flattening, that is, going from some structure MSF (t m) a b to MSF m a b for a specific transformer t often gives rise to known FRP constructs. For instance, flattening with EitherT gives rise to switching, and flattening with ListT gives rise to parallelism with broadcasting. MSFs can be used to implement many FRP variants, including Arrowized FRP, Classic FRP, and plain reactive programming. Arrowized and applicative syntax are both supported. For a very detailed introduction to MSFs, see: http://dl.acm.org/citation.cfm?id=2976010 (mirror: http://ivanperez.io/#FRPRefactored).
package duration

A tiny compile-time time utility library inspired by zeit/ms A tiny compile-time time utility library inspired by zeit/ms
package dynamic-state

Optionally serializable dynamic state keyed by type Optionally serializable dynamic state keyed by type
package dyre

Dynamic reconfiguration in Haskell Dyre implements dynamic reconfiguration facilities after the style of Xmonad. Dyre aims to be as simple as possible without sacrificing features, and places an emphasis on simplicity of integration with an application. A full introduction with a complete example project can be found in the documentation for Config.Dyre

Page 180 of many | Previous | Next