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 hashable

A class for types that can be converted to a hash value This package defines a class, Hashable, for types that can be converted to a hash value. This class exists for the benefit of hashing-based data structures. The package provides instances for basic types and a way to combine hash values. Hashable is intended exclusively for use in in-memory data structures. Hashable does not have a fixed standard. This allows it to improve over time. Because it does not have a fixed standard, different computers or computers on different versions of the code will observe different hash values. As such, hashable is not recommended for use other than in-memory datastructures. Specifically, hashable is not intended for network use or in applications which persist hashed values. For stable hashing use named hashes: sha256, crc32, xxhash etc.
package random

Pseudo-random number generation This package provides basic pseudo-random number generation, including the ability to split random number generators.
System.Random: pure pseudo-random number interface
In pure code, use System.Random.uniform and System.Random.uniformR from System.Random to generate pseudo-random numbers with a pure pseudo-random number generator like System.Random.StdGen. As an example, here is how you can simulate rolls of a six-sided die using System.Random.uniformR:
```
>>> let roll = uniformR (1, 6)        :: RandomGen g => g -> (Word, g)

>>> let rolls = unfoldr (Just . roll) :: RandomGen g => g -> [Word]

>>> let pureGen = mkStdGen 42

>>> take 10 (rolls pureGen)           :: [Word]
[1,1,3,2,4,5,3,4,6,2]
```
See System.Random for more details.
System.Random.Stateful: monadic pseudo-random number interface
In monadic code, use System.Random.Stateful.uniformM and System.Random.Stateful.uniformRM from System.Random.Stateful to generate pseudo-random numbers with a monadic pseudo-random number generator, or using a monadic adapter. As an example, here is how you can simulate rolls of a six-sided die using System.Random.Stateful.uniformRM:
```
>>> let rollM = uniformRM (1, 6)                 :: StatefulGen g m => g -> m Word

>>> let pureGen = mkStdGen 42

>>> runStateGen_ pureGen (replicateM 10 . rollM) :: [Word]
[1,1,3,2,4,5,3,4,6,2]
```
The monadic adapter System.Random.Stateful.runStateGen_ is used here to lift the pure pseudo-random number generator pureGen into the System.Random.Stateful.StatefulGen context. The monadic interface can also be used with existing monadic pseudo-random number generators. In this example, we use the one provided in the mwc-random package:
```
>>> import System.Random.MWC as MWC

>>> let rollM = uniformRM (1, 6)       :: StatefulGen g m => g -> m Word

>>> monadicGen <- MWC.create

>>> replicateM 10 (rollM monadicGen) :: IO [Word]
[2,3,6,6,4,4,3,1,5,4]
```
See System.Random.Stateful for more details.
package exceptions

Extensible optionally-pure exceptions Extensible optionally-pure exceptions.
package criterion

Robust, reliable performance measurement and analysis This library provides a powerful but simple way to measure software performance. It provides both a framework for executing and analysing benchmarks and a set of driver functions that makes it easy to build and run benchmarks, and to analyse their results. The fastest way to get started is to read the online tutorial, followed by the documentation and examples in the Criterion.Main module. For examples of the kinds of reports that criterion generates, see the home page.
package semigroups

Anything that associates In mathematics, a semigroup is an algebraic structure consisting of a set together with an associative binary operation. A semigroup generalizes a monoid in that there might not exist an identity element. It also (originally) generalized a group (a monoid with all inverses) to a type where every element did not have to have an inverse, thus the name semigroup.
package array

Mutable and immutable arrays In addition to providing the Data.Array module as specified in the Haskell 2010 Language Report, this package also defines the classes IArray of immutable arrays and MArray of arrays mutable within appropriate monads, as well as some instances of these classes.
package binary

Binary serialisation for Haskell values using lazy ByteStrings Efficient, pure binary serialisation using lazy ByteStrings. Haskell values may be encoded to and from binary formats, written to disk as binary, or sent over the network. The format used can be automatically generated, or you can choose to implement a custom format if needed. Serialisation speeds of over 1 G/sec have been observed, so this library should be suitable for high performance scenarios.
package stm

Software Transactional Memory Software Transactional Memory, or STM, is an abstraction for concurrent communication. The main benefits of STM are composability and modularity. That is, using STM you can write concurrent abstractions that can be easily composed with any other abstraction built using STM, without exposing the details of how your abstraction ensures safety. This is typically not the case with other forms of concurrent communication, such as locks or MVars.
package process

Process libraries This package contains libraries for dealing with system processes. The typed-process package is a more recent take on a process API, which uses this package internally. It features better binary support, easier concurrency, and a more composable API. You can read more about it at https://github.com/fpco/typed-process/#readme.
package attoparsec

Fast combinator parsing for bytestrings and text A fast parser combinator library, aimed particularly at dealing efficiently with network protocols and complicated text/binary file formats.

Page 3 of many | Previous | Next

Hoogle Search

System.Random: pure pseudo-random number interface

System.Random.Stateful: monadic pseudo-random number interface