Generic.Random.Internal.Generic

Core implementation.

Warning

This is an internal module: it is not subject to any versioning policy, breaking changes can happen at any time.

If something here seems useful, please report it or create a pull request to export it from an external module.

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 SizedOptsDef 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

N.B.: This replaces the generator for fields of type [t] with listOf' arbitrary instead of listOf arbitrary (i.e., arbitrary for lists).

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

genericArbitrary with explicit generators.

Example

genericArbitraryG customGens (17 % 19 % ())

where, the generators for String and Int fields are overridden as follows, for example:

customGens :: Gen String :+ Gen Int
customGens =
  (filter (/= 'NUL') <$> arbitrary) :+
  (getNonNegative <$> arbitrary)

Note on multiple matches

Multiple generators may match a given field: the first will be chosen.

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

genericArbitraryU with explicit generators. See also genericArbitraryG.

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

genericArbitrarySingle with explicit generators. See also genericArbitraryG.

genericArbitraryRecG

Arguments

:: GArbitrary (SetGens genList SizedOpts) a

=> genList

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

Defined in Generic.Random.Internal.Generic

Methods

uniformWeight :: (a :| b, Int)

WeightBuilder a => WeightBuilder (a :| b)

Defined in Generic.Random.Internal.Generic

Associated Types

type Prec (a :| b) r

Methods

(%.) :: forall (c :: Symbol) r. c ~ First (a :| b) => W c -> Prec (a :| b) r -> (a :| b, Int, r)

type Prec (a :| b) r

Defined in Generic.Random.Internal.Generic

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

data L (c :: Symbol)

Constructors

L

Instances

UniformWeight (L c)

Defined in Generic.Random.Internal.Generic

Methods

uniformWeight :: (L c, Int)

WeightBuilder (L c)

Defined in Generic.Random.Internal.Generic

Associated Types

type Prec (L c) r

Methods

(%.) :: forall (c0 :: Symbol) r. c0 ~ First (L c) => W c0 -> Prec (L c) r -> (L c, Int, r)

type Prec (L c) r

Defined in Generic.Random.Internal.Generic

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)

Defined in Generic.Random.Internal.Generic

Methods

(%) :: forall (c :: Symbol). c ~ First' (Weights a) => W c -> 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)

Defined in Generic.Random.Internal.Generic

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

Methods

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

A binary constructor for building up trees of weights.

Instances

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

Defined in Generic.Random.Internal.Generic

Methods

(%) :: forall (c :: Symbol). c ~ First' (Weights a) => W c -> Prec' (Weights a) -> Weights a

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

Defined in Generic.Random.Internal.Generic

Methods

(%) :: forall (c :: Symbol). c ~ First' (a, Int, r) => W c -> Prec' (a, Int, r) -> (a, Int, r)

class WeightBuilder a where

Associated Types

type Prec a r

Methods

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

Instances

WeightBuilder ()

Defined in Generic.Random.Internal.Generic

Associated Types

type Prec () r

Methods

(%.) :: forall (c :: Symbol) r. c ~ First () => W c -> Prec () r -> ((), Int, r)

WeightBuilder (L c)

Defined in Generic.Random.Internal.Generic

Associated Types

type Prec (L c) r

Methods

(%.) :: forall (c0 :: Symbol) r. c0 ~ First (L c) => W c0 -> Prec (L c) r -> (L c, Int, r)

WeightBuilder a => WeightBuilder (a :| b)

Defined in Generic.Random.Internal.Generic

Associated Types

type Prec (a :| b) r

Methods

(%.) :: forall (c :: Symbol) r. c ~ First (a :| b) => W c -> Prec (a :| b) r -> (a :| b, Int, r)

class UniformWeight a where

Methods

uniformWeight :: (a, Int)

Instances

UniformWeight ()

Defined in Generic.Random.Internal.Generic

Methods

uniformWeight :: ((), Int)

UniformWeight (L c)

Defined in Generic.Random.Internal.Generic

Methods

uniformWeight :: (L c, Int)

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

Defined in Generic.Random.Internal.Generic

Methods

uniformWeight :: (a :| b, Int)

class UniformWeight (Weights_ f) => UniformWeight_ f

Instances

UniformWeight (Weights_ f) => UniformWeight_ f

Defined in Generic.Random.Internal.Generic

class UniformWeight_ (Rep a) => GUniformWeight a

Derived uniform distribution of constructors for a.

Instances

UniformWeight_ (Rep a) => GUniformWeight a

Defined in Generic.Random.Internal.Generic

newtype Options (c :: Coherence) (s :: Sizing) (genList :: Type)

Type-level options for GArbitrary.

Note: it is recommended to avoid referring to the Options type explicitly in code, as the set of options may change in the future. Instead, use the provided synonyms (UnsizedOpts, SizedOpts, SizedOptsDef) and the setter SetOptions (abbreviated as (<+)).

Constructors

Options

Fields

• _generators :: genList

Instances

HasGenerators (Options c s g)

Defined in Generic.Random.Internal.Generic

Methods

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

type SetOptions (g :: Type) (Options c s _g)

Defined in Generic.Random.Internal.Generic

type SetOptions (g :: Type) (Options c s _g) = Options c s g

type SetOptions (c :: Coherence) (Options _c s g)

Defined in Generic.Random.Internal.Generic

type SetOptions (c :: Coherence) (Options _c s g) = Options c s g

type SetOptions (s :: Sizing) (Options c _s g)

Defined in Generic.Random.Internal.Generic

type SetOptions (s :: Sizing) (Options c _s g) = Options c s g

type SetGens g (Options c s _g)

Defined in Generic.Random.Internal.Generic

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

type GeneratorsOf (Options _c _s g)

Defined in Generic.Random.Internal.Generic

type GeneratorsOf (Options _c _s g) = g

type CoherenceOf (Options c _s _g)

Defined in Generic.Random.Internal.Generic

type CoherenceOf (Options c _s _g) = c

type SetUnsized (Options c s g)

Defined in Generic.Random.Internal.Generic

type SetUnsized (Options c s g) = Options c 'Unsized g

type SetSized (Options c s g)

Defined in Generic.Random.Internal.Generic

type SetSized (Options c s g) = Options c 'Sized g

type SizingOf (Options _c s _g)

Defined in Generic.Random.Internal.Generic

type SizingOf (Options _c s _g) = s

type family SetOptions (x :: k) (o :: Type) :: Type

Setter for Options.

This subsumes the other setters: SetSized, SetUnsized, SetGens.

Since: 1.4.0.0

Instances

type SetOptions (g :: Type) (Options c s _g)

Defined in Generic.Random.Internal.Generic

type SetOptions (g :: Type) (Options c s _g) = Options c s g

type SetOptions (c :: Coherence) (Options _c s g)

Defined in Generic.Random.Internal.Generic

type SetOptions (c :: Coherence) (Options _c s g) = Options c s g

type SetOptions (s :: Sizing) (Options c _s g)

Defined in Generic.Random.Internal.Generic

type SetOptions (s :: Sizing) (Options c _s g) = Options c s g

type (<+) o x = SetOptions x o infixl 1

Infix flipped synonym for Options.

Since: 1.4.0.0

type UnsizedOpts = Options 'INCOHERENT 'Unsized ()

type SizedOpts = Options 'INCOHERENT 'Sized ()

type SizedOptsDef = Options 'INCOHERENT 'Sized (Gen1 [] :+ ())

type CohUnsizedOpts = Options 'COHERENT 'Unsized ()

Like UnsizedOpts, but using coherent instances by default.

Since: 1.4.0.0

type CohSizedOpts = Options 'COHERENT 'Sized ()

Like SizedOpts, but using coherent instances by default.

Since: 1.4.0.0

setOpts :: forall x o. Coercible o (SetOptions x o) => o -> SetOptions x o

Coerce an Options value between types with the same representation.

Since: 1.4.0.0

unsizedOpts :: UnsizedOpts

Default options for unsized generators.

sizedOpts :: SizedOpts

Default options for sized generators.

sizedOptsDef :: SizedOptsDef

Default options overriding the list generator using listOf'.

cohUnsizedOpts :: CohUnsizedOpts

Like unsizedOpts, but using coherent instances by default.

cohSizedOpts :: CohSizedOpts

Like sizedOpts but using coherent instances by default.

data Sizing

Whether to decrease the size parameter before generating fields.

The Sized option makes the size parameter decrease in the following way: - Constructors with one field decrease the size parameter by 1 to generate that field. - Constructors with more than one field split the size parameter among all fields; the size parameter is rounded down to then be divided equally.

Constructors

Sized

Decrease the size parameter when running generators for fields

Unsized

Don't touch the size parameter

Instances

type SetOptions (s :: Sizing) (Options c _s g)

Defined in Generic.Random.Internal.Generic

type SetOptions (s :: Sizing) (Options c _s g) = Options c s g

type family SizingOf opts :: Sizing

Instances

type SizingOf (Options _c s _g)

Defined in Generic.Random.Internal.Generic

type SizingOf (Options _c s _g) = s

type family SetSized (o :: Type) :: Type

Instances

type SetSized (Options c s g)

Defined in Generic.Random.Internal.Generic

type SetSized (Options c s g) = Options c 'Sized g

type family SetUnsized (o :: Type) :: Type

Instances

type SetUnsized (Options c s g)

Defined in Generic.Random.Internal.Generic

type SetUnsized (Options c s g) = Options c 'Unsized g

setSized :: Options c s g -> Options c 'Sized g

setUnsized :: Options c s g -> Options c 'Unsized g

data Coherence

For custom generators to work with parameterized types, incoherent instances must be used internally. In practice, the resulting behavior is what users want 100% of the time, so you should forget this option even exists.

Details

The default configuration of generic-random does a decent job if we trust GHC implements precisely the instance resolution algorithm as described in the GHC manual:

• https://downloads.haskell.org/ghc/latest/docs/html/users_guide/glasgow_exts.html#overlapping-instances

While that assumption holds in practice, it is overly context-dependent (to know the context leading to a particular choice, we must replay the whole resolution algorithm). In particular, this algorithm may find one solution, but it is not guaranteed to be unique: the behavior of the program is dependent on implementation details.

An notable property to consider of an implicit type system (such as type classes) is coherence: the behavior of the program is stable under specialization.

This sounds nice on paper, but actually leads to surprising behavior for generic implementations with parameterized types, such as generic-random.

To address that, the coherence property can be relaxd by users, by explicitly allowing some custom generators to be chosen incoherently. With appropriate precautions, it is possible to ensure a weaker property which nevertheless helps keep type inference predictable: when a solution is found, it is unique. (This is assuredly weaker, i.e., is not stable under specialization.)

Since: 1.4.0.0

Constructors

INCOHERENT

Match custom generators incoherently.

COHERENT

Match custom generators coherently by default (can be manually bypassed with Incoherent).

Instances

type SetOptions (c :: Coherence) (Options _c s g)

Defined in Generic.Random.Internal.Generic

type SetOptions (c :: Coherence) (Options _c s g) = Options c s g

type family CoherenceOf (o :: Type) :: Coherence

Instances

type CoherenceOf (Options c _s _g)

Defined in Generic.Random.Internal.Generic

type CoherenceOf (Options c _s _g) = c

newtype Incoherent g

Match this generator incoherently when the COHERENT option is set.

Constructors

Incoherent g

Instances

FindGen ('Match 'INCOHERENT) s g gs a => FindGen 'Shift s (Incoherent g) gs a

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy 'Shift, Proxy s, FullGenListOf s) -> Incoherent g -> gs -> Gen a

data a :+ b infixr 1

Heterogeneous list of generators.

Constructors

a :+ b infixr 1

Instances

FindGen 'Shift s b g a => FindGen 'Shift s () (b :+ g) a

Examine the next candidate

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy 'Shift, Proxy s, FullGenListOf s) -> () -> (b :+ g) -> Gen a

FindGen 'Shift s g (h :+ gs) a => FindGen 'Shift s (g :+ h) gs a

This can happen if the generators form a tree rather than a list, for whatever reason.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy 'Shift, Proxy s, FullGenListOf s) -> (g :+ h) -> gs -> Gen a

(TypeLevelGenList a, TypeLevelGenList b) => TypeLevelGenList (a :+ b :: Type)

Defined in Generic.Random.DerivingVia

Associated Types

type TypeLevelGenList' (a :+ b)

Methods

toGenList :: Proxy (a :+ b) -> TypeLevelGenList' (a :+ b)

type TypeLevelGenList' (a :+ b :: Type)

Defined in Generic.Random.DerivingVia

type TypeLevelGenList' (a :+ b :: Type) = TypeLevelGenList' a :+ TypeLevelGenList' b

type family GeneratorsOf opts :: Type

Instances

type GeneratorsOf (Options _c _s g)

Defined in Generic.Random.Internal.Generic

type GeneratorsOf (Options _c _s g) = g

class HasGenerators opts where

Methods

generators :: opts -> GeneratorsOf opts

Instances

HasGenerators (Options c s g)

Defined in Generic.Random.Internal.Generic

Methods

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

setGenerators :: genList -> Options c s g0 -> Options c s genList

Define the set of custom generators.

Note: for recursive types which can recursively appear inside lists or other containers, you may want to include a custom generator to decrease the size when generating such containers.

See also the Note about lists in Generic.Random.Tutorial.

type family SetGens (g :: Type) opts

Instances

type SetGens g (Options c s _g)

Defined in Generic.Random.Internal.Generic

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

newtype FieldGen (s :: Symbol) a

Custom generator for record fields named s.

If there is a field named s with a different type, this will result in a type error.

Constructors

FieldGen

Fields

• unFieldGen :: Gen a

Instances

a ~ a' => FindGen ('MatchCoh 'True) s (FieldGen sn a) gs a'

Matching custom generator for field s.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('MatchCoh 'True), Proxy s, FullGenListOf s) -> FieldGen sn a -> gs -> Gen a'

a ~ a' => FindGen ('Match 'INCOHERENT) ('S _fg _coh '(con, i, 'Just s)) (FieldGen s a) gs a'

Matching custom generator for field s.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('Match 'INCOHERENT), Proxy ('S _fg _coh '(con, i, 'Just s)), FullGenListOf ('S _fg _coh '(con, i, 'Just s))) -> FieldGen s a -> gs -> Gen a'

fieldGen :: proxy s -> Gen a -> FieldGen s a

FieldGen constructor with the field name given via a proxy.

newtype ConstrGen (c :: Symbol) (i :: Nat) a

Custom generator for the i-th field of the constructor named c. Fields are 0-indexed.

Constructors

ConstrGen

Fields

• unConstrGen :: Gen a

Instances

a ~ a' => FindGen ('MatchCoh 'True) s (ConstrGen c i a) gs a'

Matching custom generator for i-th field of constructor c.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('MatchCoh 'True), Proxy s, FullGenListOf s) -> ConstrGen c i a -> gs -> Gen a'

a ~ a' => FindGen ('Match 'INCOHERENT) ('S _fg _coh '('Just c, i, s)) (ConstrGen c i a) gs a'

Matching custom generator for i-th field of constructor c.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('Match 'INCOHERENT), Proxy ('S _fg _coh '('Just c, i, s)), FullGenListOf ('S _fg _coh '('Just c, i, s))) -> ConstrGen c i a -> gs -> Gen a'

constrGen :: proxy '(c, i) -> Gen a -> ConstrGen c i a

ConstrGen constructor with the constructor name given via a proxy.

newtype Gen1 f

Custom generators for "containers" of kind Type -> Type, parameterized by the generator for "contained elements".

A custom generator Gen1 f will be used for any field whose type has the form f x, requiring a generator of x. The generator for x will be constructed using the list of custom generators if possible, otherwise an instance Arbitrary x will be required.

Constructors

Gen1

Fields

• unGen1 :: forall a. Gen a -> Gen (f a)

Instances

(f x ~ a', FindGen 'Shift ('S fg coh (DummySel :: (Maybe Symbol, Nat, Maybe Symbol))) () fg x) => FindGen ('MatchCoh 'True) ('S fg coh _sel) (Gen1 f) gs a'

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('MatchCoh 'True), Proxy ('S fg coh _sel), FullGenListOf ('S fg coh _sel)) -> Gen1 f -> gs -> Gen a'

FindGen 'Shift ('S fg coh (DummySel :: (Maybe Symbol, Nat, Maybe Symbol))) () fg a => FindGen ('Match 'INCOHERENT) ('S fg coh _sel) (Gen1 f) gs (f a)

Matching custom generator for container f. Start the search for containee a, discarding field information.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('Match 'INCOHERENT), Proxy ('S fg coh _sel), FullGenListOf ('S fg coh _sel)) -> Gen1 f -> gs -> Gen (f a)

newtype Gen1_ f

Custom generators for unary type constructors that are not "containers", i.e., which don't require a generator of a to generate an f a.

A custom generator Gen1_ f will be used for any field whose type has the form f x.

Constructors

Gen1_

Fields

• unGen1_ :: forall a. Gen (f a)

Instances

f x ~ a' => FindGen ('MatchCoh 'True) s (Gen1_ f) gs a'

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('MatchCoh 'True), Proxy s, FullGenListOf s) -> Gen1_ f -> gs -> Gen a'

FindGen ('Match 'INCOHERENT) s (Gen1_ f) gs (f a)

Matching custom generator for non-container f.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('Match 'INCOHERENT), Proxy s, FullGenListOf s) -> Gen1_ f -> gs -> Gen (f a)

vectorOf' :: Int -> Gen a -> Gen [a]

An alternative to vectorOf that divides the size parameter by the length of the list.

listOf' :: Gen a -> Gen [a]

An alternative to listOf that divides the size parameter by the length of the list. The length follows a geometric distribution of parameter 1/(sqrt size + 1).

listOf1' :: Gen a -> Gen [a]

An alternative to listOf1 (nonempty lists) that divides the size parameter by the length of the list. The length (minus one) follows a geometric distribution of parameter 1/(sqrt size + 1).

geom :: Int -> Gen Int

Geometric distribution of parameter 1/(sqrt n + 1) (n >= 0).

class GA opts f where

Generic Arbitrary

Methods

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

Instances

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

Defined in Generic.Random.Internal.Generic

Methods

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

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

Defined in Generic.Random.Internal.Generic

Methods

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

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

Defined in Generic.Random.Internal.Generic

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

Defined in Generic.Random.Internal.Generic

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

class GASum opts f where

Methods

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

Instances

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

Defined in Generic.Random.Internal.Generic

Methods

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

GAProduct (SizingOf opts) (Name c) opts f => GASum opts (M1 C c f)

Defined in Generic.Random.Internal.Generic

Methods

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

class GAProduct (s :: Sizing) (c :: Maybe Symbol) opts f where

Methods

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

Instances

GAProduct' c 0 opts f => GAProduct 'Unsized c opts (f :: k -> Type)

Defined in Generic.Random.Internal.Generic

Methods

gaProduct :: forall proxys (p :: k0). proxys '('Unsized, c) -> opts -> Gen (f p)

(GAProduct' c 0 opts f, KnownNat (Arity f)) => GAProduct 'Sized c opts (f :: k -> Type)

Defined in Generic.Random.Internal.Generic

Methods

gaProduct :: forall proxys (p :: k0). proxys '('Sized, c) -> opts -> Gen (f p)

GAProduct 'Sized c opts (U1 :: k -> Type)

Defined in Generic.Random.Internal.Generic

Methods

gaProduct :: forall proxys (p :: k0). proxys '('Sized, c) -> opts -> Gen (U1 p)

GAProduct' c 0 opts (S1 d f) => GAProduct 'Sized c opts (S1 d f :: k -> Type)

Defined in Generic.Random.Internal.Generic

Methods

gaProduct :: forall proxys (p :: k0). proxys '('Sized, c) -> opts -> Gen (S1 d f p)

class GAProduct' (c :: Maybe Symbol) (i :: Nat) opts f where

Methods

gaProduct' :: proxy '(c, i) -> opts -> Gen (f p)

Instances

GAProduct' c i opts (U1 :: k -> Type)

Defined in Generic.Random.Internal.Generic

Methods

gaProduct' :: forall proxy (p :: k0). proxy '(c, i) -> opts -> Gen (U1 p)

(GAProduct' c i opts f, GAProduct' c (i + Arity f) opts g) => GAProduct' c i opts (f :*: g :: k -> Type)

Defined in Generic.Random.Internal.Generic

Methods

gaProduct' :: forall proxy (p :: k0). proxy '(c, i) -> opts -> Gen ((f :*: g) p)

(HasGenerators opts, FindGen 'Shift ('S gs coh '(c, i, Name d)) () gs a, gs ~ GeneratorsOf opts, coh ~ CoherenceOf opts) => GAProduct' c i opts (S1 d (K1 _k a :: k -> Type) :: k -> Type)

Defined in Generic.Random.Internal.Generic

Methods

gaProduct' :: forall proxy (p :: k0). proxy '(c, i) -> opts -> Gen (S1 d (K1 _k a) p)

type family Arity f :: Nat where ...

Equations

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

Arity (M1 _i _c _f) = 1

class FindGen (i :: AInstr) (s :: AStore) (g :: Type) (gs :: Type) (a :: Type) where

Given a list of custom generators g :+ gs, find one that applies, or use Arbitrary a by default.

g and gs follow this little state machine:

          g,      gs | result
---------------------+-----------------------------
         (),      () | END
         (), g :+ gs | g, gs
         (),      g  | g, () when g is not (_ :+ _)
     g :+ h,      gs | g, h :+ gs
      Gen a,      gs | END if g matches, else ((), gs)
 FieldGen a,      gs | idem
ConstrGen a,      gs | idem
     Gen1 a,      gs | idem
    Gen1_ a,      gs | idem

Methods

findGen :: (Proxy i, Proxy s, FullGenListOf s) -> g -> gs -> Gen a

Instances

FindGen ('Match (ACoherenceOf s)) s g gs a => FindGen 'Shift s g gs a

If none of the above matches, then g should be a simple generator, and we test whether it matches the type a.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy 'Shift, Proxy s, FullGenListOf s) -> g -> gs -> Gen a

FindGen 'Shift s g () a => FindGen 'Shift s () g a

Examine the last candidate (g is not of the form _ :+ _)

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy 'Shift, Proxy s, FullGenListOf s) -> () -> g -> Gen a

Arbitrary a => FindGen 'Shift s () () a

All candidates have been exhausted

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy 'Shift, Proxy s, FullGenListOf s) -> () -> () -> Gen a

FindGen 'Shift s b g a => FindGen 'Shift s () (b :+ g) a

Examine the next candidate

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy 'Shift, Proxy s, FullGenListOf s) -> () -> (b :+ g) -> Gen a

FindGen ('Match 'INCOHERENT) s g gs a => FindGen 'Shift s (Incoherent g) gs a

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy 'Shift, Proxy s, FullGenListOf s) -> Incoherent g -> gs -> Gen a

FindGen 'Shift s g (h :+ gs) a => FindGen 'Shift s (g :+ h) gs a

This can happen if the generators form a tree rather than a list, for whatever reason.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy 'Shift, Proxy s, FullGenListOf s) -> (g :+ h) -> gs -> Gen a

FindGen 'Shift s () gs a => FindGen ('Match 'INCOHERENT) s _g gs a

None of the INCOHERENT instances match, discard the candidate g and look at the rest of the list gs.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('Match 'INCOHERENT), Proxy s, FullGenListOf s) -> _g -> gs -> Gen a

FindGen ('MatchCoh (Matches (ASelOf s) g a)) s g gs a => FindGen ('Match 'COHERENT) s g gs a

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('Match 'COHERENT), Proxy s, FullGenListOf s) -> g -> gs -> Gen a

FindGen 'Shift s () gs a => FindGen ('MatchCoh 'False) s _g gs a

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('MatchCoh 'False), Proxy s, FullGenListOf s) -> _g -> gs -> Gen a

FindGen ('Match 'INCOHERENT) s (Gen a) gs a

Matching custom generator for a.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('Match 'INCOHERENT), Proxy s, FullGenListOf s) -> Gen a -> gs -> Gen a

a ~ a' => FindGen ('MatchCoh 'True) s (Gen a) gs a'

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('MatchCoh 'True), Proxy s, FullGenListOf s) -> Gen a -> gs -> Gen a'

a ~ a' => FindGen ('MatchCoh 'True) s (FieldGen sn a) gs a'

Matching custom generator for field s.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('MatchCoh 'True), Proxy s, FullGenListOf s) -> FieldGen sn a -> gs -> Gen a'

f x ~ a' => FindGen ('MatchCoh 'True) s (Gen1_ f) gs a'

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('MatchCoh 'True), Proxy s, FullGenListOf s) -> Gen1_ f -> gs -> Gen a'

FindGen ('Match 'INCOHERENT) s (Gen1_ f) gs (f a)

Matching custom generator for non-container f.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('Match 'INCOHERENT), Proxy s, FullGenListOf s) -> Gen1_ f -> gs -> Gen (f a)

a ~ a' => FindGen ('MatchCoh 'True) s (ConstrGen c i a) gs a'

Matching custom generator for i-th field of constructor c.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('MatchCoh 'True), Proxy s, FullGenListOf s) -> ConstrGen c i a -> gs -> Gen a'

(f x ~ a', FindGen 'Shift ('S fg coh (DummySel :: (Maybe Symbol, Nat, Maybe Symbol))) () fg x) => FindGen ('MatchCoh 'True) ('S fg coh _sel) (Gen1 f) gs a'

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('MatchCoh 'True), Proxy ('S fg coh _sel), FullGenListOf ('S fg coh _sel)) -> Gen1 f -> gs -> Gen a'

FindGen 'Shift ('S fg coh (DummySel :: (Maybe Symbol, Nat, Maybe Symbol))) () fg a => FindGen ('Match 'INCOHERENT) ('S fg coh _sel) (Gen1 f) gs (f a)

Matching custom generator for container f. Start the search for containee a, discarding field information.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('Match 'INCOHERENT), Proxy ('S fg coh _sel), FullGenListOf ('S fg coh _sel)) -> Gen1 f -> gs -> Gen (f a)

a ~ a' => FindGen ('Match 'INCOHERENT) ('S _fg _coh '(con, i, 'Just s)) (FieldGen s a) gs a'

Matching custom generator for field s.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('Match 'INCOHERENT), Proxy ('S _fg _coh '(con, i, 'Just s)), FullGenListOf ('S _fg _coh '(con, i, 'Just s))) -> FieldGen s a -> gs -> Gen a'

a ~ a' => FindGen ('Match 'INCOHERENT) ('S _fg _coh '('Just c, i, s)) (ConstrGen c i a) gs a'

Matching custom generator for i-th field of constructor c.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('Match 'INCOHERENT), Proxy ('S _fg _coh '('Just c, i, s)), FullGenListOf ('S _fg _coh '('Just c, i, s))) -> ConstrGen c i a -> gs -> Gen a'

data AInstr

Constructors

Shift

Match Coherence

MatchCoh Bool

data AStore

Constructors

S Type Coherence ASel

type ASel = (Maybe Symbol, Nat, Maybe Symbol)

iShift :: Proxy 'Shift

type family FullGenListOf (s :: AStore) :: Type where ...

Equations

FullGenListOf ('S fg _coh _sel) = fg

type family ACoherenceOf (s :: AStore) :: Coherence where ...

Equations

ACoherenceOf ('S _fg coh _sel) = coh

type family ASelOf (s :: AStore) :: ASel where ...

Equations

ASelOf ('S _fg _coh sel) = sel

type DummySel = '('Nothing, 0, 'Nothing)

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

Get the name contained in a Meta tag.

Instances

type Name ('MetaCons n _f _s)

Defined in Generic.Random.Internal.Generic

type Name ('MetaCons n _f _s) = 'Just n

type Name ('MetaSel mn su ss ds)

Defined in Generic.Random.Internal.Generic

type Name ('MetaSel mn su ss ds) = mn

type family Matches (s :: ASel) (g :: Type) (a :: Type) :: Bool where ...

Equations

Matches _sel (Gen b) a = b == a

Matches _sel (Gen1_ f) (f a) = 'True

Matches _sel (Gen1_ f) a = 'False

Matches _sel (Gen1 f) (f a) = 'True

Matches _sel (Gen1 f) a = 'False

Matches '(_c, i, s) (FieldGen s1 b) a = (s == 'Just s1) && (b == a)

Matches '(c, i, _s) (ConstrGen c1 j b) a = (c == 'Just c1) && ((i == j) && (b == a))

newtype Weighted a

Constructors

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

Instances

Functor Weighted

Defined in Generic.Random.Internal.Generic

Methods

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

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

Applicative Weighted

Defined in Generic.Random.Internal.Generic

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

Defined in Generic.Random.Internal.Generic

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