Hoogle Search

Within LTS Haskell 24.4 (ghc-9.10.2)

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

package ghc-bignum

GHC BigNum library This package provides the low-level implementation of the standard BigNat, Natural and Integer types.
package hmatrix

Numeric Linear Algebra Linear systems, matrix decompositions, and other numerical computations based on BLAS and LAPACK. Standard interface: Numeric.LinearAlgebra. Safer interface with statically checked dimensions: Numeric.LinearAlgebra.Static. Code examples: http://dis.um.es/~alberto/hmatrix/hmatrix.html
package hslua-core

Bindings to Lua, an embeddable scripting language Wrappers and helpers to bridge Haskell and Lua. It builds upon the lua package, which allows to bundle a Lua interpreter with a Haskell program.
package markdown-unlit

Literate Haskell support for Markdown Documentation is here: https://github.com/sol/markdown-unlit#readme
package tagsoup

Parsing and extracting information from (possibly malformed) HTML/XML documents TagSoup is a library for parsing HTML/XML. It supports the HTML 5 specification, and can be used to parse either well-formed XML, or unstructured and malformed HTML from the web. The library also provides useful functions to extract information from an HTML document, making it ideal for screen-scraping. Users should start from the Text.HTML.TagSoup module.
package weigh

Measure allocations of a Haskell functions/values Please see README.md
package call-stack

Use GHC call-stacks in a backward compatible way Use GHC call-stacks in a backward compatible way
package haskell-src-exts

Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printer Haskell-Source with Extensions (HSE, haskell-src-exts) is a standalone parser for Haskell. In addition to standard Haskell, all extensions implemented in GHC are supported. Apart from these standard extensions, it also handles regular patterns as per the HaRP extension as well as HSX-style embedded XML syntax.
package io-streams

Simple, composable, and easy-to-use stream I/O Overview The io-streams library contains simple and easy-to-use primitives for I/O using streams. Most users will want to import the top-level convenience module System.IO.Streams, which re-exports most of the library:
```
import           System.IO.Streams (InputStream, OutputStream)
import qualified System.IO.Streams as Streams
```
For first-time users, io-streams comes with an included tutorial, which can be found in the System.IO.Streams.Tutorial module. Features The io-streams user API has two basic types: InputStream a and OutputStream a, and three fundamental I/O primitives:
```
-- read an item from an input stream
Streams.read :: InputStream a -> IO (Maybe a)

-- push an item back to an input stream
Streams.unRead :: a -> InputStream a -> IO ()

-- write to an output stream
Streams.write :: Maybe a -> OutputStream a -> IO ()
```
Streams can be transformed by composition and hooked together with provided combinators:
```
ghci> Streams.fromList [1,2,3::Int] >>= Streams.map (*10) >>= Streams.toList
[10,20,30]
```
Stream composition leaves the original stream accessible:
```
ghci> input <- Streams.fromByteString "long string"
ghci> wrapped <- Streams.takeBytes 4 input
ghci> Streams.read wrapped
Just "long"
ghci> Streams.read wrapped
Nothing
ghci> Streams.read input
Just " string"
```
Simple types and operations in the IO monad mean straightforward and simple exception handling and resource cleanup using Haskell standard library facilities like Control.Exception.bracket. io-streams comes with:
- functions to use files, handles, concurrent channels, sockets, lists, vectors, and more as streams.
- a variety of combinators for wrapping and transforming streams, including compression and decompression using zlib, controlling precisely how many bytes are read from or written to a stream, buffering output using bytestring builders, folds, maps, filters, zips, etc.
- support for parsing from streams using attoparsec.
- support for spawning processes and communicating with them using streams.
package microlens-platform

microlens + all batteries included (best for apps) This package exports a module which is the recommended starting point for using microlens if you aren't trying to keep your dependencies minimal. By importing Lens.Micro.Platform you get all functions and instances from microlens, microlens-th, microlens-mtl, microlens-ghc, as well as instances for Vector, Text, and HashMap. The minor and major versions of microlens-platform are incremented whenever the minor and major versions of any other microlens package are incremented, so you can depend on the exact version of microlens-platform without specifying the version of microlens (microlens-mtl, etc) you need. This package is a part of the microlens family; see the readme on Github.

Page 20 of many | Previous | Next