Hoogle Search

Within LTS Haskell 24.4 (ghc-9.10.2)

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

package numhask

A numeric class hierarchy. This package provides alternative numeric classes over Prelude. The numeric class constellation looks somewhat like:
Usage
```
>>> {-# LANGUAGE GHC2024 #-}

>>> {-# LANGUAGE RebindableSyntax #-}

>>> import NumHask.Prelude
```
See NumHask for a detailed overview.
package parameterized-utils

Classes and data structures for working with data-kind indexed types This package contains collection classes and type representations used for working with values that have a single parameter. It's intended for things like expression libraries where one wishes to leverage the Haskell type-checker to improve type-safety by encoding the object language type system into data kinds.
package pipes-parse

Parsing infrastructure for the pipes ecosystem pipes-parse builds upon the pipes library to provide shared parsing idioms and utilities:
- Leftovers: Save unused input for later consumption
- Leftover propagation: Leftovers are propagated backwards perfectly
- Connect and Resume: Use StateT to save unused input for later
- Termination Safety: Detect and recover from end of input
Pipes.Parse contains the full documentation for this library. Read Pipes.Parse.Tutorial for an extensive tutorial.
package pointed

Pointed and copointed data Pointed and copointed data.
package pointedlist

A zipper-like comonad which works as a list, tracking a position. A PointedList tracks the position in a non-empty list which works similarly to a zipper. A current item is always required, and therefore the list may never be empty. A circular PointedList wraps around to the other end when progressing past the actual edge.
package port-utils

Utilities for creating and waiting on ports Utilities for creating and waiting on ports. . openFreePort will create a socket bound to a random port (like warp's openFreePort). . wait will attempt to connect to given host and port repeatedly until successful. .
package primes

Efficient, purely functional generation of prime numbers This Haskell library provides an efficient lazy wheel sieve for prime generation inspired by Lazy wheel sieves and spirals of primes by Colin Runciman and The Genuine Sieve of Eratosthenes by Melissa O'Neil.
package psqueues

Pure priority search queues The psqueues package provides Priority Search Queues in three different flavors.
- OrdPSQ k p v, which uses the Ord k instance to provide fast insertion, deletion and lookup. This implementation is based on Ralf Hinze's A Simple Implementation Technique for Priority Search Queues. Hence, it is similar to the PSQueue library, although it is considerably faster and provides a slightly different API.
- IntPSQ p v is a far more efficient implementation. It fixes the key type to Int and uses a radix tree (like IntMap) with an additional min-heap property.
- HashPSQ k p v is a fairly straightforward extension of IntPSQ: it simply uses the keys' hashes as indices in the IntPSQ. If there are any hash collisions, it uses an OrdPSQ to resolve those. The performance of this implementation is comparable to that of IntPSQ, but it is more widely applicable since the keys are not restricted to Int, but rather to any Hashable datatype.
Each of the three implementations provides the same API, so they can be used interchangeably. The benchmarks show how they perform relative to one another, and also compared to the other Priority Search Queue implementations on Hackage: PSQueue and fingertree-psqueue. Typical applications of Priority Search Queues include:
- Caches, and more specifically LRU Caches;
- Schedulers;
- Pathfinding algorithms, such as Dijkstra's and A*.
package refined

Refinement types with static and runtime checking For an extensive introduction to the library please follow to this blog-post.
package reflex

Higher-order Functional Reactive Programming Interactive programs without callbacks or side-effects. Functional Reactive Programming (FRP) uses composable events and time-varying values to describe interactive systems as pure functions. Just like other pure functional code, functional reactive code is easier to get right on the first try, maintain, and reuse. Reflex is a fully-deterministic, higher-order Functional Reactive Programming interface and an engine that efficiently implements that interface. https://reflex-frp.org

Page 48 of many | Previous | Next

Hoogle Search

Usage