Hoogle Search

Within LTS Haskell 24.6 (ghc-9.10.2)

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

package iproute

IP Routing Table IP Routing Table is a tree of IP ranges to search one of them on the longest match base. It is a kind of TRIE with one way branching removed. Both IPv4 and IPv6 are supported.
package optics-core

Optics as an abstract interface: core definitions This package makes it possible to define and use Lenses, Traversals, Prisms and other optics, using an abstract interface. This variant provides core definitions with a minimal dependency footprint. See the optics package (and its dependencies) for documentation and the "batteries-included" variant.
package parallel

Parallel programming library This package provides a library for parallel programming. For documentation, start from the Control.Parallel.Strategies module below. For more tutorial documentation, see the book Parallel and Concurrent Programming in Haskell. To understand the principles behind the library, see Seq no more: Better Strategies for Parallel Haskell.
package streaming-commons

Common lower-level functions needed by various streaming data libraries Provides low-dependency functionality commonly needed by various streaming data libraries, such as conduit and pipes.
package uuid-types

Type definitions for Universally Unique Identifiers This library contains type definitions for Universally Unique Identifiers (UUID) (as specified in RFC 4122) and basic conversion functions. See also the 'uuid' package providing a high-level API for managing the different UUID versions.
package websockets

A sensible and clean way to write WebSocket-capable servers in Haskell. This library allows you to write WebSocket-capable servers. An example server: https://github.com/jaspervdj/websockets/blob/master/example/server.lhs An example client: https://github.com/jaspervdj/websockets/blob/master/example/client.hs This package only supports insecure (ws://...) WebSockets. If you need secure (wss://...) websockets, consider using Wuss: https://hackage.haskell.org/package/wuss See also:
- The specification of the WebSocket protocol: http://www.whatwg.org/specs/web-socket-protocol/
- The JavaScript API for dealing with WebSockets: http://www.w3.org/TR/websockets/
package adjunctions

Adjunctions and representable functors Adjunctions and representable functors.
package attoparsec-aeson

Parsing of aeson's Value with attoparsec Parsing of aeson's Value with attoparsec, originally from aeson.
package cassava

A CSV parsing and encoding library cassava is a library for parsing and encoding RFC 4180 compliant comma-separated values (CSV) data, which is a textual line-oriented format commonly used for exchanging tabular data. cassava's API includes support for
- Index-based record-conversion
- Name-based record-conversion
- Typeclass directed conversion of fields and records
- Built-in field-conversion instances for standard types
- Customizable record-conversion instance derivation via GHC generics
- Low-level bytestring builders (see Data.Csv.Builder)
- Incremental decoding and encoding API (see Data.Csv.Incremental)
- Streaming API for constant-space decoding (see Data.Csv.Streaming)
Moreover, this library is designed to be easy to use; for instance, here's a very simple example of encoding CSV data:
```
>>> Data.Csv.encode [("John",27),("Jane",28)]
"John,27\r\nJane,28\r\n"
```
Please refer to the documentation in Data.Csv and the included README for more usage examples.
package data-accessor

Utilities for accessing and manipulating fields of records In Haskell 98 the name of a record field is automatically also the name of a function which gets the value of the according field. E.g. if we have data Pair a b = Pair {first :: a, second :: b} then
```
first  :: Pair a b -> a
second :: Pair a b -> b
```
However for setting or modifying a field value we need to use some syntactic sugar, which is often clumsy.
```
modifyFirst :: (a -> a) -> (Pair a b -> Pair a b)
modifyFirst f r@(Pair{first=a}) = r{first = f a}
```
With this package you can define record field accessors which allow setting, getting and modifying values easily. The package clearly demonstrates the power of the functional approach: You can combine accessors of a record and sub-records, to make the access look like the fields of the sub-record belong to the main record. Example:
```
*Data.Accessor.Example> (first^:second^=10) (('b',7),"hallo")
(('b',10),"hallo")
```
You can easily manipulate record fields in a Control.Monad.State.State monad, you can easily code Show instances that use the Accessor syntax and you can parse binary streams into records. See Data.Accessor.Example for demonstration of all features. It would be great if in revised Haskell versions the names of record fields are automatically Data.Accessor.Accessors rather than plain get functions. For now, the package data-accessor-template provides Template Haskell functions for automated generation of Data.Acesssor.Accessors. See also the other data-accessor packages that provide an Accessor interface to other data types. The package enumset provides accessors to bit-packed records. For similar packages see lenses and fclabel. A related concept are editors http://conal.net/blog/posts/semantic-editor-combinators/. Editors only consist of a modify method (and modify applied to a const function is a set function). This way, they can modify all function values of a function at once, whereas an accessor can only change a single function value, say, it can change f 0 = 1 to f 0 = 2. This way, editors can even change the type of a record or a function. An Arrow instance can be defined for editors, but for accessors only a Category instance is possible ((.) method). The reason is the arr method of the Arrow class, that conflicts with the two-way nature (set and get) of accessors.

Page 17 of many | Previous | Next