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

Methods

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

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

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

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

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

ssplit :: R (Fun StdGen (Tuple2 StdGen 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

Methods

readsPrec :: Int -> ReadS StdGen

readList :: ReadS [StdGen]

readPrec :: ReadPrec StdGen

readListPrec :: ReadPrec [StdGen]

Show StdGen

Methods

showsPrec :: Int -> StdGen -> ShowS

show :: StdGen -> String

showList :: [StdGen] -> ShowS

RandomGen StdGen

Methods

next :: StdGen -> (Int, StdGen)

genRange :: StdGen -> (Int, Int)

split :: StdGen -> (StdGen, StdGen)

RandomGen StdGen

Methods

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

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

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

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

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

ssplit :: R (Fun StdGen (Tuple2 StdGen 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

Methods

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

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

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

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

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

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

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

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

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

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

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

srandomIO :: R (IO Bool)

Random Char

Methods

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

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

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

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

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

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

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

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

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

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

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

srandomIO :: R (IO Char)

Random Double

Methods

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

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

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

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

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

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

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

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

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

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

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

srandomIO :: R (IO Double)

Random Float

Methods

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

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

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

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

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

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

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

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

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

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

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

srandomIO :: R (IO Float)

Random Int

Methods

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

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

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

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

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

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

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

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

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

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

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

srandomIO :: R (IO Int)

Random Integer

Methods

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

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

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

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

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

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

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

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

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

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

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

srandomIO :: R (IO 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)

Orphan instances

Show StdGen

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun StdGen ShowS))

sshowsPrec :: R (Fun Int (Fun StdGen ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun StdGen String)

sshow :: R (Fun StdGen String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List StdGen) ShowS)

sshowList :: R (Fun (List StdGen) ShowS)

Read StdGen

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS StdGen))

sreadsPrec :: R (Fun Int (ReadS StdGen))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List StdGen))

sreadList :: R (ReadS (List StdGen))