Safe Haskell	None
Language	Haskell2010

Generic.Random.Internal.BaseCase

Synopsis

Documentation

genericArbitrary' #

Arguments

:: (GArbitrary SizedOpts a, BaseCase a)
=> Weights a	List of weights for every constructor
-> Gen a

Decrease size to ensure termination for recursive types, looking for base cases once the size reaches 0.

genericArbitrary' (17 % 19 % 23 % ()) :: Gen a

genericArbitraryU' :: (GArbitrary SizedOpts a, BaseCase a, GUniformWeight a) => Gen a #

Equivalent to genericArbitrary' uniform.

genericArbitraryU :: Gen a

withBaseCase :: Gen a -> Gen a -> Gen a #

Run the first generator if the size is positive. Run the second if the size is zero.

defaultGen `withBaseCase` baseCaseGen

class BaseCaseSearch (a :: *) (z :: Nat) (y :: Maybe Nat) (e :: *) where #

Find a base case of type a with maximum depth z, recursively using BaseCaseSearch instances to search deeper levels.

y is the depth of a base case, if found.

e is the original type the search started with, that a appears in. It is used for error reporting.

Minimal complete definition

baseCaseSearch

Methods

baseCaseSearch :: prox y -> proxy '(z, e) -> IfM y Gen Proxy a #

Instances

(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch Bool z y e #
Methods baseCaseSearch :: prox y -> proxy ((Nat, ) z e) -> IfM Nat ( -> ) y Gen (Proxy ) Bool #
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch Char z y e #
Methods baseCaseSearch :: prox y -> proxy ((Nat, ) z e) -> IfM Nat ( -> ) y Gen (Proxy ) Char #
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch Double z y e #
Methods baseCaseSearch :: prox y -> proxy ((Nat, ) z e) -> IfM Nat ( -> ) y Gen (Proxy ) Double #
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch Float z y e #
Methods baseCaseSearch :: prox y -> proxy ((Nat, ) z e) -> IfM Nat ( -> ) y Gen (Proxy ) Float #
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch Int z y e #
Methods baseCaseSearch :: prox y -> proxy ((Nat, ) z e) -> IfM Nat ( -> ) y Gen (Proxy ) Int #
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch Integer z y e #
Methods baseCaseSearch :: prox y -> proxy ((Nat, ) z e) -> IfM Nat ( -> ) y Gen (Proxy ) Integer #
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch Ordering z y e #
Methods baseCaseSearch :: prox y -> proxy ((Nat, ) z e) -> IfM Nat ( -> ) y Gen (Proxy ) Ordering #
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch Word z y e #
Methods baseCaseSearch :: prox y -> proxy ((Nat, ) z e) -> IfM Nat ( -> ) y Gen (Proxy ) Word #
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch () z y e #
Methods baseCaseSearch :: prox y -> proxy ((Nat, ) z e) -> IfM Nat ( -> ) y Gen (Proxy ) () #
GBaseCaseSearch Nat Nat * a z y e => BaseCaseSearch a z y e #
Methods baseCaseSearch :: prox y -> proxy ((Nat, ) z e) -> IfM Nat ( -> ) y Gen (Proxy ) a #
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch [a] z y e #
Methods baseCaseSearch :: prox y -> proxy ((Nat, ) z e) -> IfM Nat ( -> ) y Gen (Proxy ) [a] #

class BaseCaseSearching_ a z y where #

Minimal complete definition

baseCaseSearching_

Methods

baseCaseSearching_ :: proxy y -> proxy2 '(z, a) -> IfM y Gen Proxy a -> Gen a #

Instances

BaseCaseSearching Nat a ((+) z 1) => BaseCaseSearching_ Nat t a z (Nothing t) #
Methods baseCaseSearching_ :: proxy y -> proxy2 ((a, ) z (Nothing t)) -> IfM z ( -> ) y Gen (Proxy ) (Nothing t) -> Gen (Nothing t) #
BaseCaseSearching_ k t a z (Just t m) #
Methods baseCaseSearching_ :: proxy y -> proxy2 ((a, ) z (Just t m)) -> IfM z ( -> ) y Gen (Proxy ) (Just t m) -> Gen (Just t m) #

class BaseCaseSearching a z where #

Progressively increase the depth bound for BaseCaseSearch.

Minimal complete definition

baseCaseSearching

Methods

baseCaseSearching :: proxy '(z, a) -> Gen a #

Instances

(BaseCaseSearch a z y a, BaseCaseSearching_ Nat Nat a z y) => BaseCaseSearching Nat a z #
Methods baseCaseSearching :: proxy ((a, *) z z) -> Gen z #

class BaseCase a where #

Custom instances can override the default behavior.

Minimal complete definition

baseCase

Methods

baseCase :: Gen a #

Generator of base cases.

Instances

BaseCaseSearching Nat a 0 => BaseCase a #	Overlappable
Methods baseCase :: Gen a #

type family IfM (b :: Maybe t) (c :: k) (d :: k) :: k #

Instances

type IfM t k (Nothing t) c d #
type IfM t k (Nothing t) c d = d
type IfM t1 k (Just t1 t2) c d #
type IfM t1 k (Just t1 t2) c d = c

type (==) m n = IsEQ (CmpNat m n) #

type family IsEQ (e :: Ordering) :: Bool #

Instances

type IsEQ LT #
type IsEQ LT = False
type IsEQ EQ #
type IsEQ EQ = True
type IsEQ GT #
type IsEQ GT = False

type family (b :: Maybe Nat) ||? (c :: Maybe Nat) :: Maybe Nat #

Instances

type m \|\|? (Nothing Nat) #
type m \|\|? (Nothing Nat) = m
type (Nothing Nat) \|\|? n #
type (Nothing Nat) \|\|? n = n
type (Just Nat m) \|\|? (Just Nat n) #
type (Just Nat m) \|\|? (Just Nat n) = Just Nat (Min m n)

type family (b :: Maybe Nat) &&? (c :: Maybe Nat) :: Maybe Nat #

Instances

type m &&? (Nothing Nat) #
type m &&? (Nothing Nat) = Nothing Nat
type (Nothing Nat) &&? n #
type (Nothing Nat) &&? n = Nothing Nat
type (Just Nat m) &&? (Just Nat n) #
type (Just Nat m) &&? (Just Nat n) = Just Nat (Max m n)

type Max m n = MaxOf (CmpNat m n) m n #

type family MaxOf (e :: Ordering) (m :: k) (n :: k) :: k #

Instances

type MaxOf k LT m n #
type MaxOf k LT m n = n
type MaxOf k EQ m n #
type MaxOf k EQ m n = m
type MaxOf k GT m n #
type MaxOf k GT m n = m

type Min m n = MinOf (CmpNat m n) m n #

type family MinOf (e :: Ordering) (m :: k) (n :: k) :: k #

Instances

type MinOf k LT m n #
type MinOf k LT m n = m
type MinOf k EQ m n #
type MinOf k EQ m n = n
type MinOf k GT m n #
type MinOf k GT m n = n

class Alternative (IfM y Weighted Proxy) => GBCS (f :: k -> *) (z :: Nat) (y :: Maybe Nat) (e :: *) where #

Minimal complete definition

gbcs

Methods

gbcs :: prox y -> proxy '(z, e) -> IfM y Weighted Proxy (f p) #

Instances

(TypeError Constraint ((:$$:) ((:$$:) ((:$$:) ((:<>:) (Text "Unrecognized Rep: ") (ShowType (k -> ) f)) (Text "Possible causes:")) ((:<>:) ((:<>:) (Text " Missing (") (ShowType Constraint (BaseCase e))) (Text ") constraint"))) (Text " Missing Generic instance")), Alternative (IfM Nat ( -> ) y Weighted (Proxy ))) => GBCS k f z y e #
Methods gbcs :: prox e -> proxy ((Nat, ) y e) -> IfM Nat ( -> ) e Weighted (Proxy ) (z p) #
(~) (Maybe Nat) y (Just Nat 0) => GBCS k (U1 k) z y e #
Methods gbcs :: prox e -> proxy ((Nat, ) y e) -> IfM Nat ( -> ) e Weighted (Proxy ) (z p) #
(~) (Maybe Nat) y (Nothing Nat) => GBCS k (K1 k i c) 0 y e #
Methods gbcs :: prox e -> proxy ((Nat, ) y e) -> IfM Nat ( -> ) e Weighted (Proxy ) (0 p) #
(GBCSSum k Nat * f g z e yf yg, GBCS k f z yf e, GBCS k g z yg e, (~) (Maybe Nat) y ((\|\|?) yf yg)) => GBCS k ((:+:) k f g) z y e #
Methods gbcs :: prox e -> proxy ((Nat, ) y e) -> IfM Nat ( -> ) e Weighted (Proxy ) (z p) #
(GBCSProduct k Nat * f g z e yf yg, GBCS k f z yf e, GBCS k g z yg e, (~) (Maybe Nat) y ((&&?) yf yg)) => GBCS k ((:*:) k f g) z y e #
Methods gbcs :: prox e -> proxy ((Nat, ) y e) -> IfM Nat ( -> ) e Weighted (Proxy ) (z p) #
(BaseCaseSearch c ((-) z 1) y e, (~) Bool ((==) z 0) False, Alternative (IfM Nat (* -> ) y Weighted (Proxy )), IsMaybe Nat y) => GBCS k (K1 k i c) z y e #
Methods gbcs :: prox e -> proxy ((Nat, ) y e) -> IfM Nat ( -> ) e Weighted (Proxy ) (z p) #
GBCS k f z y e => GBCS k (M1 k i c f) z y e #
Methods gbcs :: prox e -> proxy ((Nat, ) y e) -> IfM Nat ( -> ) e Weighted (Proxy ) (z p) #

class Alternative (IfM (yf ||? yg) Weighted Proxy) => GBCSSum f g z e yf yg where #

Minimal complete definition

gbcsSum

Methods

gbcsSum :: prox '(yf, yg) -> proxy '(z, e) -> IfM yf Weighted Proxy (f p) -> IfM yg Weighted Proxy (g p) -> IfM (yf ||? yg) Weighted Proxy ((f :+: g) p) #

Instances

GBCSSum k3 k2 k1 f g z e (Nothing Nat) (Nothing Nat) #
Methods gbcsSum :: prox ((Maybe Nat, Maybe Nat) yf yg) -> proxy ((g, z) (Nothing Nat) e) -> IfM Nat (* -> ) yf Weighted (Proxy ) (e p) -> IfM Nat (* -> ) yg Weighted (Proxy ) (Nothing Nat p) -> IfM Nat (* -> ) (yf \|\|? yg) Weighted (Proxy ) ((f :+: e) (Nothing Nat) p) #
GBCSSum k3 k2 k1 f g z e (Nothing Nat) (Just Nat n) #
Methods gbcsSum :: prox ((Maybe Nat, Maybe Nat) yf yg) -> proxy ((g, z) (Just Nat n) e) -> IfM Nat (* -> ) yf Weighted (Proxy ) (e p) -> IfM Nat (* -> ) yg Weighted (Proxy ) (Nothing Nat p) -> IfM Nat (* -> ) (yf \|\|? yg) Weighted (Proxy ) ((f :+: e) (Nothing Nat) p) #
GBCSSum k3 k2 k1 f g z e (Just Nat m) (Nothing Nat) #
Methods gbcsSum :: prox ((Maybe Nat, Maybe Nat) yf yg) -> proxy ((g, z) (Nothing Nat) e) -> IfM Nat (* -> ) yf Weighted (Proxy ) (e p) -> IfM Nat (* -> ) yg Weighted (Proxy ) (Just Nat m p) -> IfM Nat (* -> ) (yf \|\|? yg) Weighted (Proxy ) ((f :+: e) (Just Nat m) p) #
GBCSSumCompare k3 k2 k1 Ordering f g z e (CmpNat m n) => GBCSSum k3 k2 k1 f g z e (Just Nat m) (Just Nat n) #
Methods gbcsSum :: prox ((Maybe Nat, Maybe Nat) yf yg) -> proxy ((g, z) (Just Nat n) e) -> IfM Nat (* -> ) yf Weighted (Proxy ) (e p) -> IfM Nat (* -> ) yg Weighted (Proxy ) (Just Nat m p) -> IfM Nat (* -> ) (yf \|\|? yg) Weighted (Proxy ) ((f :+: e) (Just Nat m) p) #

class GBCSSumCompare f g z e o where #

Minimal complete definition

gbcsSumCompare

Methods

gbcsSumCompare :: proxy0 o -> proxy '(z, e) -> Weighted (f p) -> Weighted (g p) -> Weighted ((f :+: g) p) #

Instances

GBCSSumCompare k3 k2 k1 Ordering f g z e GT #
Methods gbcsSumCompare :: proxy0 o -> proxy ((g, z) z e) -> Weighted (GT p) -> Weighted (g p) -> Weighted ((f :+: GT) g p) #
GBCSSumCompare k3 k2 k1 Ordering f g z e LT #
Methods gbcsSumCompare :: proxy0 o -> proxy ((g, z) z e) -> Weighted (LT p) -> Weighted (g p) -> Weighted ((f :+: LT) g p) #
GBCSSumCompare k3 k2 k1 Ordering f g z e EQ #
Methods gbcsSumCompare :: proxy0 o -> proxy ((g, z) z e) -> Weighted (EQ p) -> Weighted (g p) -> Weighted ((f :+: EQ) g p) #

class Alternative (IfM (yf &&? yg) Weighted Proxy) => GBCSProduct f g z e yf yg where #

Minimal complete definition

gbcsProduct

Methods

gbcsProduct :: prox '(yf, yg) -> proxy '(z, e) -> IfM yf Weighted Proxy (f p) -> IfM yg Weighted Proxy (g p) -> IfM (yf &&? yg) Weighted Proxy ((f :*: g) p) #

Instances

(~) (Maybe Nat) ((&&?) yf yg) (Nothing Nat) => GBCSProduct k3 k2 k1 f g z e yf yg #
Methods gbcsProduct :: prox ((Maybe Nat, Maybe Nat) yf yg) -> proxy ((g, z) yg e) -> IfM Nat (* -> ) yf Weighted (Proxy ) (e p) -> IfM Nat (* -> ) yg Weighted (Proxy ) (yf p) -> IfM Nat (* -> ) (yf &&? yg) Weighted (Proxy ) ((f :*: e) yf p) #
GBCSProduct k3 k2 k1 f g z e (Just Nat m) (Just Nat n) #
Methods gbcsProduct :: prox ((Maybe Nat, Maybe Nat) yf yg) -> proxy ((g, z) (Just Nat n) e) -> IfM Nat (* -> ) yf Weighted (Proxy ) (e p) -> IfM Nat (* -> ) yg Weighted (Proxy ) (Just Nat m p) -> IfM Nat (* -> ) (yf &&? yg) Weighted (Proxy ) ((f :*: e) (Just Nat m) p) #

class IsMaybe b where #

Minimal complete definition

ifMmap, ifM

Methods

ifMmap :: proxy b -> (c a -> c' a') -> (d a -> d' a') -> IfM b c d a -> IfM b c' d' a' #

ifM :: proxy b -> c a -> d a -> IfM b c d a #

Instances

IsMaybe t (Nothing t) #
Methods ifMmap :: proxy b -> (c a -> c' a') -> (d a -> d' a') -> IfM (Nothing t) (k -> ) b c d a -> IfM (Nothing t) (k -> ) b c' d' a' # ifM :: proxy b -> c a -> d a -> IfM (Nothing t) (k -> *) b c d a #
IsMaybe t1 (Just t1 t2) #
Methods ifMmap :: proxy b -> (c a -> c' a') -> (d a -> d' a') -> IfM (Just t1 t2) (k -> ) b c d a -> IfM (Just t1 t2) (k -> ) b c' d' a' # ifM :: proxy b -> c a -> d a -> IfM (Just t1 t2) (k -> *) b c d a #

class GBaseCaseSearch a z y e where #

Minimal complete definition

gBaseCaseSearch

Methods

gBaseCaseSearch :: prox y -> proxy '(z, e) -> IfM y Gen Proxy a #

Instances

(Generic a, GBCS * (Rep a) z y e, IsMaybe Nat y) => GBaseCaseSearch Nat Nat * a z y e #
Methods gBaseCaseSearch :: prox y -> proxy ((a, y) z e) -> IfM z (* -> ) y Gen (Proxy ) e #

type m \|\|? (Nothing Nat) #
type m \|\|? (Nothing Nat) = m
type (Nothing Nat) \|\|? n #
type (Nothing Nat) \|\|? n = n
type (Just Nat m) \|\|? (Just Nat n) #
type (Just Nat m) \|\|? (Just Nat n) = Just Nat (Min m n)

(TypeError Constraint ((:$$:) ((:$$:) ((:$$:) ((:<>:) (Text "Unrecognized Rep: ") (ShowType (k -> ) f)) (Text "Possible causes:")) ((:<>:) ((:<>:) (Text " Missing (") (ShowType Constraint (BaseCase e))) (Text ") constraint"))) (Text " Missing Generic instance")), Alternative (IfM Nat ( -> ) y Weighted (Proxy ))) => GBCS k f z y e #
Methods gbcs :: prox e -> proxy ((Nat, ) y e) -> IfM Nat ( -> ) e Weighted (Proxy ) (z p) #
(~) (Maybe Nat) y (Just Nat 0) => GBCS k (U1 k) z y e #
Methods gbcs :: prox e -> proxy ((Nat, ) y e) -> IfM Nat ( -> ) e Weighted (Proxy ) (z p) #
(~) (Maybe Nat) y (Nothing Nat) => GBCS k (K1 k i c) 0 y e #
Methods gbcs :: prox e -> proxy ((Nat, ) y e) -> IfM Nat ( -> ) e Weighted (Proxy ) (0 p) #
(GBCSSum k Nat * f g z e yf yg, GBCS k f z yf e, GBCS k g z yg e, (~) (Maybe Nat) y ((\|\|?) yf yg)) => GBCS k ((:+:) k f g) z y e #
Methods gbcs :: prox e -> proxy ((Nat, ) y e) -> IfM Nat ( -> ) e Weighted (Proxy ) (z p) #
(GBCSProduct k Nat * f g z e yf yg, GBCS k f z yf e, GBCS k g z yg e, (~) (Maybe Nat) y ((&&?) yf yg)) => GBCS k ((:*:) k f g) z y e #
Methods gbcs :: prox e -> proxy ((Nat, ) y e) -> IfM Nat ( -> ) e Weighted (Proxy ) (z p) #
(BaseCaseSearch c ((-) z 1) y e, (~) Bool ((==) z 0) False, Alternative (IfM Nat (* -> ) y Weighted (Proxy )), IsMaybe Nat y) => GBCS k (K1 k i c) z y e #
Methods gbcs :: prox e -> proxy ((Nat, ) y e) -> IfM Nat ( -> ) e Weighted (Proxy ) (z p) #
GBCS k f z y e => GBCS k (M1 k i c f) z y e #
Methods gbcs :: prox e -> proxy ((Nat, ) y e) -> IfM Nat ( -> ) e Weighted (Proxy ) (z p) #