Generic.Random.Internal.Generic

Random generators

genericArbitrary

Arguments

:: GArbitrary UnsizedOpts a

=> Weights a

List of weights for every constructor

-> Gen a

Pick a constructor with a given distribution, and fill its fields with recursive calls to arbitrary.

Example

genericArbitrary (2 % 3 % 5 % ()) :: Gen a

Picks the first constructor with probability 2/10, the second with probability 3/10, the third with probability 5/10.

genericArbitraryU :: (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a

Pick every constructor with equal probability. Equivalent to genericArbitrary uniform.

genericArbitraryU :: Gen a

genericArbitrarySingle :: (GArbitrary UnsizedOpts a, Weights_ (Rep a) ~ L c0) => Gen a

arbitrary for types with one constructor. Equivalent to genericArbitraryU, with a stricter type.

genericArbitrarySingle :: Gen a

genericArbitraryRec

Arguments

:: GArbitrary SizedOpts a

=> Weights a

List of weights for every constructor

-> Gen a

Decrease size at every recursive call, but don't do anything different at size 0.

genericArbitraryRec (7 % 11 % 13 % ()) :: Gen a

genericArbitraryG :: GArbitrary (SetGens g UnsizedOpts) a => GenList g -> Weights a -> Gen a

genericArbitrary with explicit generators.

Example

genericArbitraryG customGens (17 % 19 % ())

where, for example to override generators for String and Int fields,

customGens :: GenList '[String, Int]
customGens =
  (filter (/= '\NUL') <$> arbitrary) :@
  (getNonNegative <$> arbitrary) :@
  Nil

Note on multiple matches

If the list contains multiple matching types for a field x of type a (i.e., either a or Field "x" a), the generator for the first match will be picked.

genericArbitraryUG :: (GArbitrary (SetGens g UnsizedOpts) a, GUniformWeight a) => GenList g -> Gen a

genericArbitraryU with explicit generators. See also genericArbitraryG.

genericArbitrarySingleG :: (GArbitrary (SetGens g UnsizedOpts) a, Weights_ (Rep a) ~ L c0) => GenList g -> Gen a

genericArbitrarySingle with explicit generators. See also genericArbitraryG.

genericArbitraryRecG

Arguments

:: GArbitrary (SetGens g SizedOpts) a

=> GenList g

-> Weights a

List of weights for every constructor

-> Gen a

genericArbitraryRec with explicit generators. See also genericArbitraryG.

genericArbitraryWith :: GArbitrary opts a => opts -> Weights a -> Gen a

General generic generator with custom options.

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 :: Symbol)

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.

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

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

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

Constructors

Weights (Weights_ (Rep a)) Int

Instances

WeightBuilder (Weights_ (Rep a)) => WeightBuilder' (Weights a)

Methods

(%) :: W (First' (Weights a)) -> Prec' (Weights a) -> Weights a

newtype W (c :: Symbol)

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

((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. It can be omitted for the % operator is overloaded to insert it.

uniform :: UniformWeight_ (Rep a) => Weights a

Uniform distribution.

type family First a :: Symbol where ...

Equations

First (a :| _b) = First a

First (L c) = c

type family First' w where ...

Equations

First' (Weights a) = First (Weights_ (Rep a))

First' (a, Int, r) = First a

type family Prec' w where ...

Equations

Prec' (Weights a) = Prec (Weights_ (Rep a)) ()

Prec' (a, Int, r) = Prec a r

class WeightBuilder' w where

Minimal complete definition

(%)

Methods

(%) :: W (First' w) -> Prec' w -> w infixr 1

A binary constructor for building up trees of weights.

Instances

WeightBuilder (Weights_ (Rep a)) => WeightBuilder' (Weights a)

Methods

(%) :: W (First' (Weights a)) -> Prec' (Weights a) -> Weights a

WeightBuilder a => WeightBuilder' (a, Int, r)

Methods

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

class WeightBuilder a where

Minimal complete definition

(%.)

Associated Types

type Prec a r

Methods

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

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)

class UniformWeight (Weights_ f) => UniformWeight_ f

Instances

UniformWeight (Weights_ f) => UniformWeight_ f

class UniformWeight_ (Rep a) => GUniformWeight a

Derived uniform distribution of constructors for a.

Instances

UniformWeight_ (Rep a) => GUniformWeight a

data Options (s :: Sizing) (g :: [Type])

Type-level options for GArbitrary.

Constructors

Options

Fields

• _generators :: GenList g

Instances

HasGenerators (Options s g)

Methods

generators :: Options s g -> GenList (GeneratorsOf (Options s g))

type SetGens g (Options s _g)

type SetGens g (Options s _g) = Options s g

type GeneratorsOf (Options _s g)

type GeneratorsOf (Options _s g) = g

type SizingOf (Options s _g)

type SizingOf (Options s _g) = s

unsizedOpts :: UnsizedOpts

sizedOpts :: SizedOpts

data Sizing

Whether to decrease the size parameter before generating fields.

Constructors

Sized

Unsized

type UnsizedOpts = (Options Unsized '[] :: Type)

type SizedOpts = (Options Sized '[] :: Type)

type family SizingOf opts :: Sizing

Instances

type SizingOf (Options s _g)

type SizingOf (Options s _g) = s

proxySizing :: opts -> Proxy (SizingOf opts)

setSized :: Options s g -> Options Sized g

setUnsized :: Options s g -> Options Unsized g

data GenList (g :: [Type]) where

Heterogeneous list of generators.

Constructors

Nil :: GenList '[]

(:@) :: Gen a -> GenList g -> GenList (a ': g) infixr 3

type family GeneratorsOf opts :: [Type]

Instances

type GeneratorsOf (Options _s g)

type GeneratorsOf (Options _s g) = g

class HasGenerators opts where

Minimal complete definition

generators

Methods

generators :: opts -> GenList (GeneratorsOf opts)

Instances

HasGenerators (Options s g)

Methods

generators :: Options s g -> GenList (GeneratorsOf (Options s g))

setGenerators :: GenList g -> Options s g0 -> Options s g

type family SetGens (g :: [Type]) opts

Instances

type SetGens g (Options s _g)

type SetGens g (Options s _g) = Options s g

newtype Field (s :: Symbol) a

A marker for a generator which overrides a specific field named s.

Available only for base >= 4.9.

Constructors

Field

Fields

• unField :: a

Instances

ArbitraryOr ((:) * (Field n a) g) (Just Symbol n) a

Methods

arbitraryOr :: proxy (Just Symbol n) -> GenList ((* ': Field n a) g) -> Gen a

field :: proxy s -> a -> Field s a

Field constructor with the field name given via a proxy.

class GA opts f where

Generic Arbitrary

Minimal complete definition

ga

Methods

ga :: opts -> Weights_ f -> Int -> Gen (f p)

Instances

(GASum opts f, GASum opts g) => GA opts ((:+:) * f g)

Methods

ga :: opts -> Weights_ ((* :+: f) g) -> Int -> Gen ((* :+: f) g p)

GAProduct (SizingOf opts) opts f => GA opts (M1 * C c f)

Methods

ga :: opts -> Weights_ (M1 * C c f) -> Int -> Gen (M1 * C c f p)

GA opts f => GA opts (M1 * D c f)

Methods

ga :: opts -> Weights_ (M1 * D c f) -> Int -> Gen (M1 * D c f p)

class (Generic a, GA opts (Rep a)) => GArbitrary opts a

Generic Arbitrary

Instances

(Generic a, GA opts (Rep a)) => GArbitrary opts a

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

class GASum opts f where

Minimal complete definition

gaSum

Methods

gaSum :: opts -> Int -> Weights_ f -> Gen (f p)

Instances

(GASum opts f, GASum opts g) => GASum opts ((:+:) * f g)

Methods

gaSum :: opts -> Int -> Weights_ ((* :+: f) g) -> Gen ((* :+: f) g p)

GAProduct (SizingOf opts) opts f => GASum opts (M1 * i c f)

Methods

gaSum :: opts -> Int -> Weights_ (M1 * i c f) -> Gen (M1 * i c f p)

class GAProduct (s :: Sizing) opts f where

Minimal complete definition

gaProduct

Methods

gaProduct :: proxys s -> opts -> Gen (f p)

Instances

(GAProduct' opts f, KnownNat (Arity f)) => GAProduct Sized opts f

Methods

gaProduct :: proxys Sized -> opts -> Gen (f p)

GAProduct' opts f => GAProduct Unsized opts f

Methods

gaProduct :: proxys Unsized -> opts -> Gen (f p)

GAProduct Sized opts (U1 *)

Methods

gaProduct :: proxys Sized -> opts -> Gen (U1 * p)

class GAProduct' opts f where

Minimal complete definition

gaProduct'

Methods

gaProduct' :: opts -> Gen (f p)

Instances

GAProduct' opts (U1 *)

Methods

gaProduct' :: opts -> Gen (U1 * p)

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

Methods

gaProduct' :: opts -> Gen ((* :*: f) g p)

(HasGenerators opts, ArbitraryOr (GeneratorsOf opts) (SelectorName d) c) => GAProduct' opts (S1 * d (K1 * i c))

Methods

gaProduct' :: opts -> Gen (S1 * d (K1 * i c) p)

type family Arity f :: Nat where ...

Equations

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

Arity (M1 _i _c _f) = 1

class ArbitraryOr (g :: [Type]) (sel :: Maybe Symbol) a where

Minimal complete definition

arbitraryOr

Methods

arbitraryOr :: proxy sel -> GenList g -> Gen a

Instances

Arbitrary a => ArbitraryOr ([] Type) sel a

Methods

arbitraryOr :: proxy sel -> GenList [Type] -> Gen a

ArbitraryOr g sel a => ArbitraryOr ((:) Type b g) sel a

Methods

arbitraryOr :: proxy sel -> GenList ((Type ': b) g) -> Gen a

ArbitraryOr ((:) Type a g) sel a

Methods

arbitraryOr :: proxy sel -> GenList ((Type ': a) g) -> Gen a

ArbitraryOr ((:) * (Field n a) g) (Just Symbol n) a

Methods

arbitraryOr :: proxy (Just Symbol n) -> GenList ((* ': Field n a) g) -> Gen a

type family SelectorName (d :: Meta) :: Maybe Symbol

Instances

type SelectorName (MetaSel mn su ss ds)

type SelectorName (MetaSel mn su ss ds) = mn

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

liftA2 :: (a -> b -> c) -> Weighted a -> Weighted b -> Weighted c

(*>) :: 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]

liftGen :: Gen a -> Weighted a