Hoogle Search

Within LTS Haskell 24.41 (ghc-9.10.3)

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

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 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 markdown-unlit

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

Strict data types and String IO. This package provides strict versions of some standard Haskell data types (pairs, Maybe and Either). It also contains strict IO operations. It is common knowledge that lazy datastructures can lead to space-leaks. This problem is particularly prominent, when using lazy datastructures to store the state of a long-running application in memory. One common solution to this problem is to use seq and its variants in every piece of code that updates your state. However a much easier solution is to use fully strict types to store such state values. By "fully strict types" we mean types for whose values it holds that, if they are in weak-head normal form, then they are also in normal form. Intuitively, this means that values of fully strict types cannot contain unevaluated thunks. To define a fully strict datatype, one typically uses the following recipe.
1. Make all fields of every constructor strict; i.e., add a bang to all fields.
2. Use only strict types for the fields of the constructors.
The second requirement is problematic as it rules out the use of the standard Haskell Maybe, Either, and pair types. This library solves this problem by providing strict variants of these types and their corresponding standard support functions and type-class instances. Note that this library does currently not provide fully strict lists. They can be added if they are really required. However, in many cases one probably wants to use unboxed or strict boxed vectors from the vector library (http://hackage.haskell.org/package/vector) instead of strict lists. Moreover, instead of Strings one probably wants to use strict Text values from the text library (http://hackage.haskell.org/package/text). This library comes with batteries included; i.e., mirror functions and instances of the lazy versions in base. It also includes instances for type-classes from the deepseq, binary, and hashable packages.
package vector-algorithms

Efficient algorithms for vector arrays Efficient algorithms for sorting vector arrays. At some stage other vector algorithms may be added.
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 doctest-exitcode-stdio

Run doctest's in a Cabal.Test.exitcode-stdio environment Run doctest's in a Cabal.Test.exitcode-stdio environment. For use with the doctest-extract utility. Normally, you should not need to import a module from this package, only generated code will do this.
package doctest-lib

Parts of doctest exposed as library Parts of doctest exposed as library. For use with the doctest-extract utility.

Page 20 of many | Previous | Next