Generic.Random.Internal.Generic

Random generators

genericArbitrary

Arguments

:: (Generic a, GA Unsized (Rep a))

=> Weights a

List of weights for every constructor

-> Gen a

Pick a constructor with a given distribution, and fill its fields recursively.

genericArbitraryU :: forall a. (Generic a, GA Unsized (Rep a), UniformWeight (Weights_ (Rep a))) => Gen a

Shorthand for genericArbitrary uniform.

genericArbitrary'

Arguments

:: (Generic a, GA (Sized n) (Rep a))

=> n

-> Weights a

List of weights for every constructor

-> Gen a

Like genericArbitrary', with decreasing size to ensure termination for recursive types, looking for base cases once the size reaches 0.

genericArbitraryU0 :: forall n a. (Generic a, GA (Sized Z) (Rep a), UniformWeight (Weights_ (Rep a))) => Gen a

Shorthand for genericArbitrary' Z uniform, using nullary constructors as the base cases.

genericArbitraryU1 :: forall n a. (Generic a, GA (Sized (S Z)) (Rep a), UniformWeight (Weights_ (Rep a))) => Gen a

Shorthand for genericArbitrary' (S Z) uniform, using nullary constructors and constructors whose fields are all nullary as base cases.

Internal

type family Weights_ (f :: * -> *) :: * where ...

Equations

Weights_ (f :+: g) = Weights_ f :| Weights_ g

Weights_ (M1 D _c f) = Weights_ f

Weights_ (M1 C (MetaCons c _i _j) _f) = L c

data a :| b

Constructors

N a Int b

Instances

(UniformWeight a, UniformWeight b) => UniformWeight ((:|) a b)

Methods

uniformWeight :: (a :| b, Int)

WeightBuilder a => WeightBuilder ((:|) a b)

Associated Types

type Prec ((:|) a b) r :: *

Methods

(%) :: W (First (a :| b)) -> Prec (a :| b) r -> (a :| b, Int, r)

type Prec ((:|) a b) r

type Prec ((:|) a b) r = Prec a (b, Int, r)

data L c

Constructors

L

Instances

UniformWeight (L c)

Methods

uniformWeight :: (L c, Int)

WeightBuilder (L c)

Associated Types

type Prec (L c) r :: *

Methods

(%) :: W (First (L c)) -> Prec (L c) r -> (L c, Int, r)

type Prec (L c) r

type Prec (L c) r = r

data Weights a

Trees of weights assigned to constructors of type a, rescaled to obtain a probability distribution.

Two ways of constructing them.

weights (x1 % x2 % ... % xn % ()) :: Weights a
uniform :: Weights a

Using weights, there must be exactly as many weights as there are constructors.

uniform is equivalent to weights (1 % ... % 1 % ()) (automatically fills out the right number of 1s).

Constructors

Weights (Weights_ (Rep a)) Int

newtype W c

Type of a single weight, tagged with the name of the associated constructor for additional compile-time checking.

weights ((9 :: W "Leaf") % (8 :: W "Node") % ())

Constructors

W Int

Instances

Num (W c)

Methods

(+) :: W c -> W c -> W c

(-) :: W c -> W c -> W c

(*) :: W c -> W c -> W c

negate :: W c -> W c

abs :: W c -> W c

signum :: W c -> W c

fromInteger :: Integer -> W c

weights :: (Weights_ (Rep a), Int, ()) -> Weights a

A smart constructor to specify a custom distribution.

uniform :: UniformWeight (Weights_ (Rep a)) => Weights a

Uniform distribution.

type family First a :: Symbol where ...

Equations

First (a :| _b) = First a

First (L c) = c

class WeightBuilder a where

Minimal complete definition

(%)

Associated Types

type Prec a r

Methods

(%) :: W (First a) -> Prec a r -> (a, Int, r) infixr 1

A binary constructor for building up trees of weights.

Instances

WeightBuilder ()

Associated Types

type Prec () r :: *

Methods

(%) :: W (First ()) -> Prec () r -> ((), Int, r)

WeightBuilder (L c)

Associated Types

type Prec (L c) r :: *

Methods

(%) :: W (First (L c)) -> Prec (L c) r -> (L c, Int, r)

WeightBuilder a => WeightBuilder ((:|) a b)

Associated Types

type Prec ((:|) a b) r :: *

Methods

(%) :: W (First (a :| b)) -> Prec (a :| b) r -> (a :| b, Int, r)

class UniformWeight a where

Minimal complete definition

uniformWeight

Methods

uniformWeight :: (a, Int)

Instances

UniformWeight ()

Methods

uniformWeight :: ((), Int)

UniformWeight (L c)

Methods

uniformWeight :: (L c, Int)

(UniformWeight a, UniformWeight b) => UniformWeight ((:|) a b)

Methods

uniformWeight :: (a :| b, Int)

newtype Gen' sized a

Constructors

Gen'

Fields

• unGen' :: Gen a

Instances

Monad (Gen' sized)

Methods

(>>=) :: Gen' sized a -> (a -> Gen' sized b) -> Gen' sized b

(>>) :: Gen' sized a -> Gen' sized b -> Gen' sized b

return :: a -> Gen' sized a

fail :: String -> Gen' sized a

Functor (Gen' sized)

Methods

fmap :: (a -> b) -> Gen' sized a -> Gen' sized b

(<$) :: a -> Gen' sized b -> Gen' sized a

Applicative (Gen' sized)

Methods

pure :: a -> Gen' sized a

(<*>) :: Gen' sized (a -> b) -> Gen' sized a -> Gen' sized b

(*>) :: Gen' sized a -> Gen' sized b -> Gen' sized b

(<*) :: Gen' sized a -> Gen' sized b -> Gen' sized a

data Sized n

Instances

(GASum (Sized n) f, GASum (Sized n) g, BaseCases n f, BaseCases n g) => GA (Sized n) ((:+:) f g)

Methods

ga :: Weights_ (f :+: g) -> Int -> Gen' (Sized n) ((f :+: g) p)

(GAProduct f, KnownNat (Arity f)) => GA (Sized n) (M1 C c f)

Methods

ga :: Weights_ (M1 C c f) -> Int -> Gen' (Sized n) (M1 C c f p)

data Unsized

Instances

(GASum Unsized f, GASum Unsized g) => GA Unsized ((:+:) f g)

Methods

ga :: Weights_ (f :+: g) -> Int -> Gen' Unsized ((f :+: g) p)

GAProduct f => GA Unsized (M1 C c f)

Methods

ga :: Weights_ (M1 C c f) -> Int -> Gen' Unsized (M1 C c f p)

sized' :: (Int -> Gen' sized a) -> Gen' sized a

class GA sized f where

Generic Arbitrary

Minimal complete definition

ga

Methods

ga :: Weights_ f -> Int -> Gen' sized (f p)

Instances

(GASum Unsized f, GASum Unsized g) => GA Unsized ((:+:) f g)

Methods

ga :: Weights_ (f :+: g) -> Int -> Gen' Unsized ((f :+: g) p)

GA sized f => GA sized (M1 D c f)

Methods

ga :: Weights_ (M1 D c f) -> Int -> Gen' sized (M1 D c f p)

GAProduct f => GA Unsized (M1 C c f)

Methods

ga :: Weights_ (M1 C c f) -> Int -> Gen' Unsized (M1 C c f p)

(GASum (Sized n) f, GASum (Sized n) g, BaseCases n f, BaseCases n g) => GA (Sized n) ((:+:) f g)

Methods

ga :: Weights_ (f :+: g) -> Int -> Gen' (Sized n) ((f :+: g) p)

(GAProduct f, KnownNat (Arity f)) => GA (Sized n) (M1 C c f)

Methods

ga :: Weights_ (M1 C c f) -> Int -> Gen' (Sized n) (M1 C c f p)

gArbitrarySingle :: forall sized f p c0. (GA sized f, Weights_ f ~ L c0) => Gen' sized (f p)

gaSum' :: GASum sized f => Weights_ f -> Int -> Gen' sized (f p)

class GASum sized f where

Minimal complete definition

gaSum

Methods

gaSum :: Int -> Weights_ f -> Gen' sized (f p)

Instances

(GASum sized f, GASum sized g) => GASum sized ((:+:) f g)

Methods

gaSum :: Int -> Weights_ (f :+: g) -> Gen' sized ((f :+: g) p)

GAProduct f => GASum sized (M1 i c f)

Methods

gaSum :: Int -> Weights_ (M1 i c f) -> Gen' sized (M1 i c f p)

class GAProduct f where

Minimal complete definition

gaProduct

Methods

gaProduct :: Gen (f p)

Instances

GAProduct U1

Methods

gaProduct :: Gen (U1 p)

Arbitrary c => GAProduct (K1 i c)

Methods

gaProduct :: Gen (K1 i c p)

(GAProduct f, GAProduct g) => GAProduct ((:*:) f g)

Methods

gaProduct :: Gen ((f :*: g) p)

GAProduct f => GAProduct (M1 i c f)

Methods

gaProduct :: Gen (M1 i c f p)

type family Arity f :: Nat where ...

Equations

Arity (f :*: g) = Arity f + Arity g

Arity (M1 _i _c _f) = 1

newtype Tagged a b

Constructors

Tagged

Fields

• unTagged :: b

Instances

Functor (Tagged a)

Methods

fmap :: (a -> b) -> Tagged a a -> Tagged a b

(<$) :: a -> Tagged a b -> Tagged a a

Use the Z and S data types to define the depths of values used by genericArbitrary' to make generators terminate.

data Z

Zero

Constructors

Z

Instances

ListBaseCases Z (K1 i c)

Methods

listBaseCases :: Alternative u => Tagged Z (u (K1 i c p))

data S n

Successor

Constructors

S n

Instances

(Generic c, ListBaseCases n (Rep c)) => ListBaseCases (S n) (K1 i c)

Methods

listBaseCases :: Alternative u => Tagged (S n) (u (K1 i c p))

newtype Weighted a

Constructors

Weighted (Maybe (Int -> Gen a, Int))

Instances

Functor Weighted

Methods

fmap :: (a -> b) -> Weighted a -> Weighted b

(<$) :: a -> Weighted b -> Weighted a

Applicative Weighted

Methods

pure :: a -> Weighted a

(<*>) :: Weighted (a -> b) -> Weighted a -> Weighted b

(*>) :: Weighted a -> Weighted b -> Weighted b

(<*) :: Weighted a -> Weighted b -> Weighted a

Alternative Weighted

Methods

empty :: Weighted a

(<|>) :: Weighted a -> Weighted a -> Weighted a

some :: Weighted a -> Weighted [a]

many :: Weighted a -> Weighted [a]

class BaseCases n f where

Minimal complete definition

baseCases

Methods

baseCases :: Weights_ f -> Int -> Tagged n (Weighted (f p))

Instances

(BaseCases n f, BaseCases n g) => BaseCases n ((:+:) f g)

Methods

baseCases :: Weights_ (f :+: g) -> Int -> Tagged n (Weighted ((f :+: g) p))

ListBaseCases n f => BaseCases n (M1 i c f)

Methods

baseCases :: Weights_ (M1 i c f) -> Int -> Tagged n (Weighted (M1 i c f p))

class ListBaseCases n f where

A ListBaseCases n (Rep a) constraint basically provides the list of values of type a with depth at most n.

Minimal complete definition

listBaseCases

Methods

listBaseCases :: Alternative u => Tagged n (u (f p))

Instances

ListBaseCases n U1

Methods

listBaseCases :: Alternative u => Tagged n (u (U1 p))

(ListBaseCases n f, ListBaseCases n g) => ListBaseCases n ((:*:) f g)

Methods

listBaseCases :: Alternative u => Tagged n (u ((f :*: g) p))

(ListBaseCases n f, ListBaseCases n g) => ListBaseCases n ((:+:) f g)

Methods

listBaseCases :: Alternative u => Tagged n (u ((f :+: g) p))

ListBaseCases Z (K1 i c)

Methods

listBaseCases :: Alternative u => Tagged Z (u (K1 i c p))

ListBaseCases n f => ListBaseCases n (M1 i c f)

Methods

listBaseCases :: Alternative u => Tagged n (u (M1 i c f p))

(Generic c, ListBaseCases n (Rep c)) => ListBaseCases (S n) (K1 i c)

Methods

listBaseCases :: Alternative u => Tagged (S n) (u (K1 i c p))

type BaseCases' n a = (Generic a, ListBaseCases n (Rep a))

For convenience.