Hat.Random

Documentation

class RandomGen g where

Minimal complete definition

sgenRange, gnext, gsplit

Methods

ggenRange :: RefSrcPos -> RefExp -> R (Fun g (Tuple2 Int Int))

sgenRange :: R (Fun g (Tuple2 Int Int))

gnext :: RefSrcPos -> RefExp -> R (Fun g (Tuple2 Int g))

snext :: R (Fun g (Tuple2 Int g))

gsplit :: RefSrcPos -> RefExp -> R (Fun g (Tuple2 g g))

ssplit :: R (Fun g (Tuple2 g g))

Instances

RandomGen StdGen

data StdGen :: *

The StdGen instance of RandomGen has a genRange of at least 30 bits.

The result of repeatedly using next should be at least as statistically robust as the Minimal Standard Random Number Generator described by [System.Random, System.Random]. Until more is known about implementations of split, all we require is that split deliver generators that are (a) not identical and (b) independently robust in the sense just given.

The Show and Read instances of StdGen provide a primitive way to save the state of a random number generator. It is required that read (show g) == g.

In addition, reads may be used to map an arbitrary string (not necessarily one produced by show) onto a value of type StdGen. In general, the Read instance of StdGen has the following properties:

• It guarantees to succeed on any string.
• It guarantees to consume only a finite portion of the string.
• Different argument strings are likely to result in different results.

Instances

Read StdGen

Show StdGen

RandomGen StdGen

Show StdGen

Read StdGen

RandomGen StdGen

gmkStdGen :: RefSrcPos -> RefExp -> R (Fun Int StdGen)

amkStdGen :: RefAtom

hmkStdGen :: R Int -> RefExp -> R StdGen

class Random a where

Minimal complete definition

grandomR, grandom, srandomRs, srandoms, srandomRIO

Methods

grandomR :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 a a) (Fun g (Tuple2 a g)))

srandomR :: RandomGen g => R (Fun (Tuple2 a a) (Fun g (Tuple2 a g)))

grandom :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (Tuple2 a g))

srandom :: RandomGen g => R (Fun g (Tuple2 a g))

grandomRs :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 a a) (Fun g (List a)))

srandomRs :: RandomGen g => R (Fun (Tuple2 a a) (Fun g (List a)))

grandoms :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (List a))

srandoms :: RandomGen g => R (Fun g (List a))

grandomRIO :: RefSrcPos -> RefExp -> R (Fun (Tuple2 a a) (IO a))

srandomRIO :: R (Fun (Tuple2 a a) (IO a))

grandomIO :: RefSrcPos -> RefExp -> R (IO a)

srandomIO :: R (IO a)

Instances

Random Bool

Random Char

Random Double

Random Float

Random Int

Random Integer

ggetStdRandom :: RefSrcPos -> RefExp -> R (Fun (Fun StdGen (Tuple2 a StdGen)) (IO a))

agetStdRandom :: RefAtom

hgetStdRandom :: R (Fun StdGen (Tuple2 b StdGen)) -> RefExp -> R (IO b)

ggetStdGen :: RefSrcPos -> RefExp -> R (IO StdGen)

gsetStdGen :: RefSrcPos -> RefExp -> R (Fun StdGen (IO Tuple0))

asetStdGen :: RefAtom

hsetStdGen :: R StdGen -> RefExp -> R (IO Tuple0)

gnewStdGen :: RefSrcPos -> RefExp -> R (IO StdGen)