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 purescript-bridge

Generate PureScript data types from Haskell data types Generate PureScript data types from Haskell data types
package pusher-http-haskell

Haskell client library for the Pusher Channels HTTP API Functions that correspond to endpoints of the Pusher Channels HTTP API. Messages can be triggered, and information about the channel can be queried. Additionally there are functions for authenticating users of private and presence channels.
package pwstore-fast

Secure password storage. To store passwords securely, they should be salted, then hashed with a slow hash function. This library uses PBKDF1-SHA256, and handles all the details. It uses the cryptohash package for speed; if you need a pure Haskell library, pwstore-purehaskell has the exact same API, but uses only pure Haskell. It is about 25 times slower than this package, but still quite usable.
package qchas

A library for implementing Quantum Algorithms A library useful for implementing Quantum Algorithms. It contains definitions of Quantum Gates, Qubits.
package quadratic-irrational

An implementation of quadratic irrationals A library for exact computation with quadratic irrationals with support for exact conversion from and to (potentially periodic) simple continued fractions. A quadratic irrational is a number that can be expressed in the form
```
(a + b √c) / d
```
where a, b and d are integers and c is a square-free natural number. Some examples of such numbers are
- 7/2,
- √2,
- (1 + √5)/2 (the golden ratio),
- solutions to quadratic equations with rational constants – the quadratic formula has a familiar shape.
A simple continued fraction is a number expressed in the form
```
a + 1/(b + 1/(c + 1/(d + 1/(e + …))))
```
or alternatively written as
```
[a; b, c, d, e, …]
```
where a is an integer and b, c, d, e, … are positive integers. Every finite SCF represents a rational number and every infinite, periodic SCF represents a quadratic irrational.
```
3.5      = [3; 2]
(1+√5)/2 = [1; 1, 1, 1, …]
√2       = [1; 2, 2, 2, …]
```
package queue-sheet

queue sheet utility This package provides a utility for creating queue sheets. Please see the README on GitHub at https://github.com/ExtremaIS/queue-sheet-haskell#readme.
package queues

Queue data structures. Queue data structures, as described in
- Okasaki, Chris. "Simple and efficient purely functional queues and deques." Journal of functional programming 5.4 (1995): 583-592.
- Okasaki, Chris. Purely Functional Data Structures. Diss. Princeton University, 1996.
A queue has a "back" where new elements are enqueued, and a "front" where elements are dequeued in the order that they were enqueued (first in, first out). The queues provided in this library also support an "enqueue at front" operation, because the underlying representations happen to support it, so you might technically refer to these data structures as output-restricted deques. In this library, it is helpful to think of the "front" being on the left, because (though the direction is arbitrary) we are consistent throughout, where it matters:
- List conversion functions associate the head of a list with the front of a queue.
- The append operator xs <> ys creates a queue with xs in front of ys.
- The Show instances draw the front of the queue on the left.
Under "ephemeral" (or "single-threaded", or "linear") usage, wherein one does not need to refer to an old version of a data structure after mutating it:
- EphemeralQueue is 2.5x faster than and allocates 0.50x as much memory as Queue.
- Queue is 2.6x faster than and allocates 0.40x as much memory as Seq (from containers).
(These numbers vary from benchmark to benchmark and machine to machine. Always perform your own experiments!) While it is certainly common to use a queue ephemerally, it is unusual for a Haskell data structure to require ephemeral usage to achieve its stated bounds. A refactoring or change in requirements might cause surprising changes in performance. That is why EphemeralQueue has a longer name and module name. When in doubt, use Queue.
package quickbench

quick & easy benchmarking of command-line programs quickbench produces very simple output (elapsed seconds), as quickly as possible (running commands just once by default), and tabulates results from multiple executables. I find it very useful for quick and dirty, exploratory, and comparative measurements that you can understand at a glance. Please see the readme for more.
package quickcheck-dynamic

A library for stateful property-based testing Please see the README on GitHub at https://github.com/input-output-hk/quickcheck-dynamic#readme
package quickcheck-state-machine

Test monadic programs using state machine based models See README at https://github.com/stevana/quickcheck-state-machine#readme

Page 232 of many | Previous | Next