Hoogle Search

Within LTS Haskell 24.49 (ghc-9.10.3)

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

package valor

Simple and powerful data validation Simple and powerful data validation library with Applicative and Monad interface. Great for constructing structured errors.
package vary

Vary: Friendly and fast polymorphic variants (open unions/coproducts/extensible sums) Vary: Friendly and fast Variant types for Haskell Just like tuples are a version of a user-defined product type (only without the field names), a Variant is a version of a user-defined sum type (but without the field names). Variant types are the generalization of Either. Especially in the situation where you want to handle multiple errors, Variant types are a great abstraction to use. Variant types are sometimes called '_polymorphic_ variants' for disambiguation. They are also commonly known as (open) unions, coproducts or extensible sums. Vary is lightweight on dependencies. With all library flags turned off, it only depends on base and deepseq. Please see the full README below or on GitHub at https://github.com/qqwy/haskell-vary#readme
package varying

FRP through value streams and monadic splines. Varying is a FRP library aimed at providing a simple way to describe values that change over a domain. It allows monadic, applicative and arrow notation and has convenience functions for tweening. Great for animation.
package vcr

Record and replay HTTP interactions Record and replay HTTP interactions
package vcs-ignore

Library for handling files ignored by VCS systems. vcs-ignore is small Haskell library used to find, check and process files ignored by selected VCS.
package vec

Vec: length-indexed (sized) list This package provides length-indexed (sized) lists, also known as vectors.
```
data Vec n a where
VNil  :: Vec 'Nat.Z a
(:::) :: a -> Vec n a -> Vec ('Nat.S n) a
```
The functions are implemented in four flavours:
- naive: with explicit recursion. It's simple, constraint-less, yet slow.
- pull: using Fin n -> a representation, which fuses well, but makes some programs hard to write. And
- data-family: which allows lazy pattern matching
- inline: which exploits how GHC dictionary inlining works, unrolling recursion if the size of Vec is known statically.
As best approach depends on the application, vec doesn't do any magic transformation. Benchmark your code. This package uses fin, i.e. not GHC.TypeLits, for indexes. For lens or optics support see vec-lens and vec-optics packages respectively. See Hasochism: the pleasure and pain of dependently typed haskell programming by Sam Lindley and Conor McBride for answers to how and why. Read APLicative Programming with Naperian Functors by Jeremy Gibbons for (not so) different ones.
Similar packages
- linear has V type, which uses Vector from vector package as backing store. Vec is a real GADT, but tries to provide as many useful instances (upto lens).
- vector-sized Great package using GHC.TypeLits. Current version (0.6.1.0) uses finite-typelits and Int indexes.
- sized-vector depends on singletons package. vec isn't light on dependencies either, but try to provide wide GHC support.
- fixed-vector
- sized also depends on a singletons package. The Sized f n a type is generalisation of linear's V for any ListLike.
- clash-prelude is a kitchen sink package, which has CLaSH.Sized.Vector module. Also depends on singletons.
package vector-bytes-instances

Serial (from the bytes package) for Vector (from the vector package) Serial (from the bytes package) for Vector (from the vector package) Based on the original BSD3-licensed work by Don Stewart in the vector-binary-instances library.
package vector-fftw

A binding to the fftw library for one-dimensional vectors. This package provides bindings to the fftw library for one-dimensional vectors. It provides both high-level functions and more low-level manipulation of fftw plans. We provide three different modules which wrap fftw's operations:
- Numeric.FFT.Vector.Unnormalized contains the raw transforms;
- Numeric.FFT.Vector.Invertible scales the backwards transforms to be true inverses;
- Numeric.FFT.Vector.Unitary additionally scales all transforms to preserve the L2 (sum-of-squares) norm of the input.
In addition, we provide .Multi modules for each of these providing multi-dimensional transforms.
package vector-mmap

Memory map immutable and mutable vectors Memory map immutable and mutable vectors.
package vector-quicksort

Fast and flexible quicksort implementation for mutable vectors Quicksort implementation developed with performance in mind. Has good default single-threaded sort and provides parallelised versions that are actually faster than the single-threaded version. Users can define new parallelisation methods. Good starting point:
```
import Data.Vector.Algorithms.Quicksort qualified as Quick
```
Then call as
```
Quick.sort xs
```

Page 264 of many | Previous | Next

Hoogle Search

Similar packages