Hoogle Search

Within LTS Haskell 24.28 (ghc-9.10.3)

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

package special-values

Typeclass providing special values Special values are provided by a SpecialValues typeclass. Those can be used for example by QuickCheck, see quickcheck-special.
package speedy-slice

Speedy slice sampling. Speedy slice sampling. This implementation of the slice sampling algorithm uses lens as a means to operate over generic indexed traversable functors, so you can expect it to work if your target function takes a list, vector, map, sequence, etc. as its argument. Additionally you can sample over anything that's an instance of both Num and Variate, which is useful in the case of discrete parameters. Exports a mcmc function that prints a trace to stdout, a chain function for collecting results in memory, and a slice transition operator that can be used more generally.
```
import Numeric.MCMC.Slice
import Data.Sequence (Seq, index, fromList)

bnn :: Seq Double -> Double
bnn xs = -0.5 * (x0 ^ 2 * x1 ^ 2 + x0 ^ 2 + x1 ^ 2 - 8 * x0 - 8 * x1) where
x0 = index xs 0
x1 = index xs 1

main :: IO ()
main = withSystemRandom . asGenIO $ mcmc 10000 1 (fromList [0, 0]) bnn
```
package splitmix-distributions

Random samplers for some common distributions, based on splitmix. Random samplers for some common distributions, as well as a convenient interface for composing them, based on splitmix. Please see the README on GitHub at https://github.com/ocramz/splitmix-distributions#readme
package sql-words

SQL keywords data constructors into OverloadedString This package contains SQL keywords constructors defined as OverloadedString literals and helper functions to concate these.
package stache

Mustache templates for Haskell Mustache templates for Haskell.
package static-bytes

A Haskell library providing types representing 8, 16, 32, 64 or 128 bytes of data. Please see the README on GitHub at https://github.com/commercialhaskell/static-bytes#readme
package stm-hamt

STM-specialised Hash Array Mapped Trie A low-level data-structure, which can be used to implement higher-level interfaces like hash-map and hash-set. Such implementations are presented by the stm-containers.
package storable-endian

Storable instances with endianness Storable instances with endianness
package store-core

Fast and lightweight binary serialization Fast and lightweight binary serialization
package streamly-core

Streaming, parsers, arrays, serialization and more For upgrading to streamly-0.9.0+ please read the Streamly-0.9.0 upgrade guide. Streamly is a standard library for Haskell that focuses on C-like performance, modular combinators, and streaming data flow model. Streamly consists of two packages: "streamly-core" and "streamly". streamly-core provides basic features, and depends only on GHC boot libraries (see note below), while streamly provides higher-level features like concurrency, time, lifted exceptions, and networking. For documentation, visit the Streamly website. The streamly-core package provides the following functionality:
- Streams as composable producers of a sequence of values.
- Streams provide all the functionality provided by Haskell lists but in an effectful, streaming fashion with better performance.
- Streams provide ListT and logic programming functionality as well.
- Folds as composable stream consumers that reduce the streams to a single value or reduce segments of streams to transform the stream.
- Parsers as more powerful, composable stream consumers supporting standard parser combinators with backtracking but in a streaming fashion.
- Arrays with streaming interfaces providing high performance, modularity, and concise interface as all streaming operations can be performed on arrays.
- Arrays can be immutable or mutable, unboxed or boxed, pinned or unpinned.
- Arrays generalize the functionality provided by bytestring and text packages.
- Interoperability with bytestring and text is provided via separate packages.
- Arrays and folds provide natural builder functionality so there are no separate builder modules.
- High performance binary serialization with configurable JSON like features.
- Streaming combinators for unicode text processing, providing functionality equivalent to the text package.
- String interpolation for convenient construction of strings.
- Streaming console IO (stdin/stdout) operations.
- Streaming file and directory IO operations.
This package covers some or all of the functionality covered by streaming, pipes, conduit, list-t, logic-t, foldl, attoparsec, array, primitive, vector, vector-algorithms, binary, cereal, store, bytestring, text, stringsearch, interpolate. Streamly provides a consistent, concise, modular and performant interface for all this functionality. Note: The dependencies "heaps" and "monad-control" are included in the package solely for backward compatibility, and will be removed in future versions.

Page 141 of many | Previous | Next