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 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 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 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.
package mono-traversable

Type classes for mapping, folding, and traversing monomorphic containers Please see the README at https://www.stackage.org/package/mono-traversable

Page 20 of many | Previous | Next