Hoogle Search

Within LTS Haskell 24.3 (ghc-9.10.2)

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

package some

Existential type: Some This library defines an existential type Some.
```
data Some f where
Some :: f a -> Some f
```
in few variants, and utilities to work with it. If you are unsure which variant to use, use the one in Data.Some module.
package sop-core

True Sums of Products Implementation of n-ary sums and n-ary products. The module Data.SOP is the main module of this library and contains more detailed documentation. The main use case of this package is to serve as the core of generics-sop. A detailed description of the ideas behind this library is provided by the paper:
- Edsko de Vries and Andres Löh. True Sums of Products. Workshop on Generic Programming (WGP) 2014.
package time-locale-compat

Compatibile module for time-format locale This package contains wrapped name module for time-format locale between old-locale and time-1.5.
package constraints-extras

Utility package for constraints Convenience functions and TH for working with constraints. See README.md for example usage.
package cryptohash

collection of crypto hashes, fast, pure and practical DEPRECATED: this library is still fully functional, but please use cryptonite for new projects and convert old one to use cryptonite. This is where things are at nowadays. A collection of crypto hashes, with a practical incremental and one-pass, pure APIs, with performance close to the fastest implementations available in other languages. The implementations are made in C with a haskell FFI wrapper that hide the C implementation. Simple examples using the unified API:
```
import Crypto.Hash

sha1 :: ByteString -> Digest SHA1
sha1 = hash

hexSha3_512 :: ByteString -> String
hexSha3_512 bs = show (hash bs :: Digest SHA3_512)
```
Simple examples using the module API:
```
import qualified Crypto.Hash.SHA1 as SHA1

main = putStrLn $ show $ SHA1.hash (Data.ByteString.pack [0..255])
```
```
import qualified Crypto.Hash.SHA3 as SHA3

main = putStrLn $ show $ digest
where digest = SHA3.finalize ctx
ctx    = foldl' SHA3.update iCtx (map Data.ByteString.pack [ [1,2,3], [4,5,6] ]
iCtx   = SHA3.init 224
```
package dependent-map

Dependent finite maps (partial dependent products) Provides a type called DMap which generalizes Data.Map.Map, allowing keys to specify the type of value that can be associated with them.
package fingertree

Generic finger-tree structure, with example instances A general sequence representation with arbitrary annotations, for use as a base for implementations of various collection types, with examples, as described in section 4 of
- Ralf Hinze and Ross Paterson, "Finger trees: a simple general-purpose data structure", Journal of Functional Programming 16:2 (2006) pp 197-217. https://staff.city.ac.uk/~ross/papers/FingerTree.html
For a tuned sequence type, see Data.Sequence in the containers package, which is a specialization of this structure.
package generics-sop

Generic Programming using True Sums of Products A library to support the definition of generic functions. Datatypes are viewed in a uniform, structured way: the choice between constructors is represented using an n-ary sum, and the arguments of each constructor are represented using an n-ary product. The module Generics.SOP is the main module of this library and contains more detailed documentation. Since version 0.4.0.0, this package is now based on sop-core. The core package contains all the functionality of n-ary sums and products, whereas this package provides the datatype-generic programming support on top. Examples of using this library are provided by the following packages:
- basic-sop basic examples,
- pretty-sop generic pretty printing,
- lens-sop generically computed lenses,
- json-sop generic JSON conversions.
A detailed description of the ideas behind this library is provided by the paper:
- Edsko de Vries and Andres Löh. True Sums of Products. Workshop on Generic Programming (WGP) 2014.
package gi-gio

Gio bindings Bindings for Gio, autogenerated by haskell-gi.
package hedis

Client library for the Redis datastore: supports full command set, pipelining. Redis is an open source, advanced key-value store. It is often referred to as a data structure server since keys can contain strings, hashes, lists, sets and sorted sets. This library is a Haskell client for the Redis datastore. Compared to other Haskell client libraries it has some advantages:
- Compatibility with Latest Stable Redis: Hedis is intended to be used with the latest stable version of Redis (currently 5.0). Most redis commands (http://redis.io/commands) are available as haskell functions, although MONITOR and SYNC are intentionally omitted. Additionally, a low-level API is exposed that makes it easy for the library user to implement further commands, such as new commands from an experimental Redis version.
- Automatic Optimal Pipelining: Commands are pipelined (http://redis.io/topics/pipelining) as much as possible without any work by the user. See http://informatikr.com/2012/redis-pipelining.html for a technical explanation of automatic optimal pipelining.
- Enforced Pub/Sub semantics: When subscribed to the Redis Pub/Sub server (http://redis.io/topics/pubsub), clients are not allowed to issue commands other than subscribing to or unsubscribing from channels. This library uses the type system to enforce the correct behavior.
- Connect via TCP or Unix Domain Socket: TCP sockets are the default way to connect to a Redis server. For connections to a server on the same machine, Unix domain sockets offer higher performance than the standard TCP connection.
For detailed documentation, see the Database.Redis module.

Page 28 of many | Previous | Next