Safe Haskell | None |
---|---|
Language | Haskell2010 |
- genericArbitrary' :: (GArbitrary SizedOpts a, BaseCase a) => Weights a -> Gen a
- genericArbitraryU' :: (GArbitrary SizedOpts a, BaseCase a, GUniformWeight a) => Gen a
- withBaseCase :: Gen a -> Gen a -> Gen a
- class BaseCaseSearch (a :: *) (z :: Nat) (y :: Maybe Nat) (e :: *) where
- class BaseCaseSearching_ a z y where
- class BaseCaseSearching a z where
- class BaseCase a where
- type family IfM (b :: Maybe t) (c :: k) (d :: k) :: k
- type (==) m n = IsEQ (CmpNat m n)
- type family IsEQ (e :: Ordering) :: Bool
- type family (b :: Maybe Nat) ||? (c :: Maybe Nat) :: Maybe Nat
- type family (b :: Maybe Nat) &&? (c :: Maybe Nat) :: Maybe Nat
- type Max m n = MaxOf (CmpNat m n) m n
- type family MaxOf (e :: Ordering) (m :: k) (n :: k) :: k
- type Min m n = MinOf (CmpNat m n) m n
- type family MinOf (e :: Ordering) (m :: k) (n :: k) :: k
- class Alternative (IfM y Weighted Proxy) => GBCS (f :: k -> *) (z :: Nat) (y :: Maybe Nat) (e :: *) where
- class Alternative (IfM (yf ||? yg) Weighted Proxy) => GBCSSum f g z e yf yg where
- class GBCSSumCompare f g z e o where
- class Alternative (IfM (yf &&? yg) Weighted Proxy) => GBCSProduct f g z e yf yg where
- class IsMaybe b where
- class GBaseCaseSearch a z y e where
Documentation
:: (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 Source #
Equivalent to
.genericArbitrary'
uniform
genericArbitraryU :: Gen a
withBaseCase :: Gen a -> Gen a -> Gen a Source #
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 Source #
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.
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch Bool z y e Source # | |
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch Char z y e Source # | |
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch Double z y e Source # | |
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch Float z y e Source # | |
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch Int z y e Source # | |
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch Integer z y e Source # | |
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch Ordering z y e Source # | |
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch Word z y e Source # | |
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch () z y e Source # | |
GBaseCaseSearch Nat Nat * a z y e => BaseCaseSearch a z y e Source # | |
(~) (Maybe Nat) y (Just Nat 0) => BaseCaseSearch [a] z y e Source # | |
class BaseCaseSearching_ a z y where Source #
BaseCaseSearching Nat a ((+) z 1) => BaseCaseSearching_ Nat t a z (Nothing t) Source # | |
BaseCaseSearching_ k t a z (Just t m) Source # | |
class BaseCaseSearching a z where Source #
Progressively increase the depth bound for BaseCaseSearch
.
baseCaseSearching :: proxy '(z, a) -> Gen a Source #
(BaseCaseSearch a z y a, BaseCaseSearching_ Nat Nat a z y) => BaseCaseSearching Nat a z Source # | |
class BaseCase a where Source #
Custom instances can override the default behavior.
BaseCaseSearching Nat a 0 => BaseCase a Source # | Overlappable |
class Alternative (IfM y Weighted Proxy) => GBCS (f :: k -> *) (z :: Nat) (y :: Maybe Nat) (e :: *) where Source #
(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 Source # | |
(~) (Maybe Nat) y (Just Nat 0) => GBCS k (U1 k) z y e Source # | |
(~) (Maybe Nat) y (Nothing Nat) => GBCS k (K1 k i c) 0 y e Source # | |
(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 Source # | |
(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 Source # | |
(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 Source # | |
GBCS k f z y e => GBCS k (M1 k i c f) z y e Source # | |
class Alternative (IfM (yf ||? yg) Weighted Proxy) => GBCSSum f g z e yf yg where Source #
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) Source #
GBCSSum k3 k2 k1 f g z e (Nothing Nat) (Nothing Nat) Source # | |
GBCSSum k3 k2 k1 f g z e (Nothing Nat) (Just Nat n) Source # | |
GBCSSum k3 k2 k1 f g z e (Just Nat m) (Nothing Nat) Source # | |
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) Source # | |
class GBCSSumCompare f g z e o where Source #
gbcsSumCompare :: proxy0 o -> proxy '(z, e) -> Weighted (f p) -> Weighted (g p) -> Weighted ((f :+: g) p) Source #
GBCSSumCompare k3 k2 k1 Ordering f g z e GT Source # | |
GBCSSumCompare k3 k2 k1 Ordering f g z e LT Source # | |
GBCSSumCompare k3 k2 k1 Ordering f g z e EQ Source # | |
class Alternative (IfM (yf &&? yg) Weighted Proxy) => GBCSProduct f g z e yf yg where Source #