-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Generic random generators
--   
--   Please see the README below.
@package generic-random
@version 0.1.0.0


-- | Solve systems of equations
module Data.Random.Generics.Internal.Solver
data SolveArgs
SolveArgs :: Double -> Int -> SolveArgs
[accuracy] :: SolveArgs -> Double
[numIterations] :: SolveArgs -> Int
defSolveArgs :: SolveArgs
findZero :: SolveArgs -> (forall s. Vector (AD s (Forward R)) -> Vector (AD s (Forward R))) -> Vector R -> Maybe (Vector R)
fixedPoint :: SolveArgs -> (forall a. (Mode a, Scalar a ~ R) => Vector a -> Vector a) -> Vector R -> Maybe (Vector R)

-- | Assuming <tt>p . f</tt> is satisfied only for positive values in some
--   interval <tt>(0, r]</tt>, find <tt>f r</tt>.
search :: (Double -> a) -> (a -> Bool) -> a
instance GHC.Show.Show Data.Random.Generics.Internal.Solver.SolveArgs
instance GHC.Classes.Ord Data.Random.Generics.Internal.Solver.SolveArgs
instance GHC.Classes.Eq Data.Random.Generics.Internal.Solver.SolveArgs

module Data.Random.Generics.Internal.Types
data SomeData m
SomeData :: m a -> SomeData m
type SomeData' = SomeData Proxy

-- | Dummy instance for debugging.
data Alias m
Alias :: !(m a -> m b) -> Alias m
type AliasR m = Alias (RejectT m)

-- | Dummy instance for debugging.

-- | Main constructor for <a>Alias</a>.
alias :: (Monad m, Data a, Data b) => (a -> m b) -> Alias m

-- | Main constructor for <a>AliasR</a>.
aliasR :: (Monad m, Data a, Data b) => (a -> m b) -> AliasR m

-- | <pre>
--   coerceAlias :: Alias m -&gt; Alias (AMonadRandom m)
--   </pre>
coerceAlias :: Coercible m n => Alias m -> Alias n

-- | <pre>
--   coerceAliases :: [Alias m] -&gt; [Alias (AMonadRandom m)]
--   </pre>
coerceAliases :: Coercible m n => [Alias m] -> [Alias n]

-- | <pre>
--   composeCast f g = f . g
--   </pre>
composeCastM :: (?loc :: CallStack, Typeable b, Typeable c) => (m c -> d) -> (a -> m b) -> (a -> d)
castM :: (?loc :: CallStack, Typeable a, Typeable b) => m a -> m b
unSomeData :: (?loc :: CallStack, Typeable a) => SomeData m -> m a
applyCast :: (Typeable a, Data b) => (m a -> m b) -> SomeData m -> SomeData m
castError :: (?loc :: CallStack, Typeable a, Typeable b) => proxy a -> proxy' b -> c
withProxy :: (?loc :: CallStack) => (a -> b) -> proxy a -> b
reproxy :: proxy a -> Proxy a
proxyType :: m a -> proxy a -> m a
someData' :: Data a => proxy a -> SomeData'

-- | Size as the number of constructors.
type Size = Int

-- | Internal transformer for rejection sampling.
--   
--   <pre>
--   ReaderT Size (StateT Size (MaybeT m)) a
--   </pre>
newtype RejectT m a
RejectT :: (forall r. Size -> Size -> m r -> (Size -> a -> m r) -> m r) -> RejectT m a
[unRejectT] :: RejectT m a -> forall r. Size -> Size -> m r -> (Size -> a -> m r) -> m r

-- | Set lower bound
runRejectT :: Monad m => (Size, Size) -> RejectT m a -> m a
newtype AMonadRandom m a
AMonadRandom :: m a -> AMonadRandom m a
[asMonadRandom] :: AMonadRandom m a -> m a

-- | <tt><a>MonadRandomLike</a> m</tt> defines basic components to build
--   generators, allowing the implementation to remain abstract over both
--   the <a>Gen</a> type and <a>MonadRandom</a> instances.
--   
--   For the latter, the wrapper <a>AMonadRandom</a> is provided to avoid
--   overlapping instances.
class Monad m => MonadRandomLike m where incr = return ()

-- | Called for every constructor. Counter for ceiled rejection sampling.
incr :: MonadRandomLike m => m ()

-- | <tt>doubleR upperBound</tt>: generates values in <tt>[0,
--   upperBound]</tt>.
doubleR :: MonadRandomLike m => Double -> m Double

-- | <tt>integerR upperBound</tt>: generates values in <tt>[0,
--   upperBound-1]</tt>.
integerR :: MonadRandomLike m => Integer -> m Integer

-- | Default <tt>Int</tt> generator.
int :: MonadRandomLike m => m Int

-- | Default <tt>Double</tt> generator.
double :: MonadRandomLike m => m Double

-- | Default <tt>Char</tt> generator.
char :: MonadRandomLike m => m Char
instance GHC.Base.Monad m => GHC.Base.Monad (Data.Random.Generics.Internal.Types.AMonadRandom m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Data.Random.Generics.Internal.Types.AMonadRandom m)
instance GHC.Base.Functor m => GHC.Base.Functor (Data.Random.Generics.Internal.Types.AMonadRandom m)
instance GHC.Show.Show (Data.Random.Generics.Internal.Types.SomeData m)
instance GHC.Show.Show (Data.Random.Generics.Internal.Types.Alias m)
instance GHC.Base.Functor (Data.Random.Generics.Internal.Types.RejectT m)
instance GHC.Base.Applicative (Data.Random.Generics.Internal.Types.RejectT m)
instance GHC.Base.Monad (Data.Random.Generics.Internal.Types.RejectT m)
instance Control.Monad.Trans.Class.MonadTrans Data.Random.Generics.Internal.Types.RejectT
instance Control.Monad.Trans.Class.MonadTrans Data.Random.Generics.Internal.Types.AMonadRandom
instance Data.Random.Generics.Internal.Types.MonadRandomLike Test.QuickCheck.Gen.Gen
instance Data.Random.Generics.Internal.Types.MonadRandomLike m => Data.Random.Generics.Internal.Types.MonadRandomLike (Data.Random.Generics.Internal.Types.RejectT m)
instance Control.Monad.Random.Class.MonadRandom m => Data.Random.Generics.Internal.Types.MonadRandomLike (Data.Random.Generics.Internal.Types.AMonadRandom m)

module Data.Random.Generics.Internal.Oracle

-- | We build a dictionary which reifies type information in order to
--   create a Boltzmann generator.
--   
--   We denote by <tt>n</tt> (or <a>count</a>) the number of types in the
--   dictionary.
--   
--   Every type has an index <tt>0 &lt;= i &lt; n</tt>; the variable <tt>X
--   i</tt> represents its generating function <tt>C_i(x)</tt>, and <tt>X
--   (i + k*n)</tt> the GF of its <tt>k</tt>-th "pointing"
--   <tt>C_i[k](x)</tt>; we have
--   
--   <pre>
--   C_i[0](x) = C_i(x)
--   C_i[k+1](x) = x * C_i[k]'(x)
--   </pre>
--   
--   where <tt>C_i[k]'</tt> is the derivative of <tt>C_i[k]</tt>. See also
--   <a>point</a>.
--   
--   The <i>order</i> (or <i>valuation</i>) of a power series is the index
--   of the first non-zero coefficient, called the <i>leading
--   coefficient</i>.
data DataDef m
DataDef :: Int -> Int -> HashMap TypeRep (Either Aliased Ix) -> HashMap Ix SomeData' -> HashMap Aliased (Ix, Alias m) -> HashMap C [(Integer, Constr, [C'])] -> HashMap Ix (Nat, Integer) -> HashMap Ix Int -> DataDef m

-- | Number of registered types
[count] :: DataDef m -> Int

-- | Number of iterations of the pointing operator
[points] :: DataDef m -> Int

-- | Map from types to indices
[index] :: DataDef m -> HashMap TypeRep (Either Aliased Ix)

-- | Inverse map from indices to types
[xedni] :: DataDef m -> HashMap Ix SomeData'

-- | Inverse map to aliases
[xedni'] :: DataDef m -> HashMap Aliased (Ix, Alias m)

-- | Structure of types and their pointings (up to <a>points</a>, initially
--   0)
--   
--   Primitive types and empty types are mapped to an empty constructor
--   list, and can be distinguished using <a>dataTypeRep</a> on the
--   <a>SomeData</a> associated to it by <a>xedni</a>.
--   
--   The integer is a multiplicity which can be &gt; 1 for pointings.
[types] :: DataDef m -> HashMap C [(Integer, Constr, [C'])]

-- | Leading term <tt>a * x ^ u</tt> of the generating functions
--   <tt>C_i[k](x)</tt> in the form (u, a).
--   
--   <ul>
--   <li><i>Order <tt>u</tt></i> Smallest size of objects of a given
--   type.</li>
--   <li><i>Leading coefficient <tt>a</tt></i> number of objects of
--   smallest size.</li>
--   </ul>
[lTerm] :: DataDef m -> HashMap Ix (Nat, Integer)

-- | Degrees of the generating functions, when applicable: greatest size of
--   objects of a given type.
[degree] :: DataDef m -> HashMap Ix Int

-- | A pair <tt>C i k</tt> represents the <tt>k</tt>-th "pointing" of the
--   type at index <tt>i</tt>, with generating function <tt>C_i[k](x)</tt>.
data C
C :: Ix -> Int -> C
data AC
AC :: Aliased -> Int -> AC
type C' = (Maybe Aliased, C)
newtype Aliased
Aliased :: Int -> Aliased
type Ix = Int
data Nat
Zero :: Nat
Succ :: Nat -> Nat
natToInt :: Nat -> Int
infinity :: Nat
dataDef :: [Alias m] -> DataDef m

-- | Find all types that may be types of subterms of a value of type
--   <tt>a</tt>.
--   
--   This will loop if there are infinitely many such types.
collectTypes :: Data a => [Alias m] -> proxy a -> DataDef m

-- | Primitive datatypes have <tt>C(x) = x</tt>: they are considered as
--   having a single object (<tt>lCoef</tt>) of size 1 (<tt>order</tt>)).
primOrder :: Int
primOrder' :: Nat
primlCoef :: Integer

-- | The type of the first argument of <a>gunfold</a>.
type GUnfold m = forall b r. Data b => m (b -> r) -> m r

-- | Type of <a>xedni'</a>.
type AMap m = HashMap Aliased (Ix, Alias m)
collectTypesM :: Data a => proxy a -> State (DataDef m) (Either Aliased Ix, ((Nat, Integer), Maybe Int))
chaseType :: Data a => proxy a -> ((Maybe (Alias m), Ix) -> AMap m -> AMap m) -> State (DataDef m) (Either Aliased Ix, ((Nat, Integer), Maybe Int))

-- | Traversal of the definition of a datatype.
traverseType :: Data a => proxy a -> Ix -> State (DataDef m) (Either Aliased Ix, ((Nat, Integer), Maybe Int))
traverseType' :: Data a => proxy a -> DataType -> State (DataDef m) ([(Integer, Constr, [(Maybe Aliased, C)])], ((Nat, Integer), Maybe Int))

-- | If <tt>(u, a)</tt> represents a power series of leading term <tt>a * x
--   ^ u</tt>, and similarly for <tt>(u', a')</tt>, this finds the leading
--   term of their sum.
--   
--   The comparison of <a>Nat</a> is unrolled here for maximum laziness.
lPlus :: (Nat, Integer) -> (Nat, Integer) -> (Nat, Integer)

-- | Sum of a list of series.
lSum :: [(Nat, Integer)] -> (Nat, Integer)

-- | Leading term of a product of series.
lMul :: (Nat, Integer) -> (Nat, Integer) -> (Nat, Integer)
lProd :: [(Nat, Integer)] -> (Nat, Integer)
maxDegree :: [Maybe Int] -> Maybe Int

-- | Pointing operator.
--   
--   Populates a <a>DataDef</a> with one more level of pointings.
--   (<a>collectTypes</a> produces a dictionary at level 0.)
--   
--   The "pointing" of a type <tt>t</tt> is a derived type whose values are
--   essentially values of type <tt>t</tt>, with one of their constructors
--   being "pointed". Alternatively, we may turn every constructor into
--   variants that indicate the position of points.
--   
--   <pre>
--   -- Original type
--   data Tree = Node Tree Tree | Leaf
--   -- Pointing of Tree
--   data Tree'
--     = Tree' Tree -- Point at the root
--     | Node'0 Tree' Tree -- Point to the left
--     | Node'1 Tree Tree' -- Point to the right
--   -- Pointing of the pointing
--   -- Notice that the "points" introduced by both applications of pointing
--   -- are considered different: exchanging their positions (when different)
--   -- produces a different tree.
--   data Tree''
--     = Tree'' Tree' -- Point 2 at the root, the inner Tree' places point 1
--     | Node'0' Tree' Tree -- Point 1 at the root, point 2 to the left
--     | Node'1' Tree Tree' -- Point 1 at the root, point 2 to the right
--     | Node'0'0 Tree'' Tree -- Points 1 and 2 to the left
--     | Node'0'1 Tree' Tree' -- Point 1 to the left, point 2 to the right
--     | Node'1'0 Tree' Tree' -- Point 1 to the right, point 2 to the left
--     | Node'0'1 Tree Tree'' -- Points 1 and 2 to the right
--   </pre>
--   
--   If we ignore points, some constructors are equivalent. Thus we may
--   simply calculate their multiplicity instead of duplicating them.
--   
--   Given a constructor with <tt>c</tt> arguments <tt>C x_1 ... x_c</tt>,
--   and a sequence <tt>p_0 + p_1 + ... + p_c = k</tt> corresponding to a
--   distribution of <tt>k</tt> points (<tt>p_0</tt> are assigned to the
--   constructor <tt>C</tt> itself, and for <tt>i &gt; 0</tt>, <tt>p_i</tt>
--   points are assigned within the <tt>i</tt>-th subterm), the
--   multiplicity of the constructor paired with that distribution is the
--   multinomial coefficient <tt>multinomial k [p_1, ..., p_c]</tt>.
point :: DataDef m -> DataDef m

-- | An oracle gives the values of the generating functions at some
--   <tt>x</tt>.
type Oracle = HashMap C Double

-- | Find the value of <tt>x</tt> such that the average size of the
--   generator for the <tt>k-1</tt>-th pointing is equal to <tt>size</tt>,
--   and produce the associated oracle. If the size is <tt>Nothing</tt>,
--   find the radius of convergence.
--   
--   The search evaluates the generating functions for some values of
--   <tt>x</tt> in order to run a binary search. The evaluator is
--   implemented using Newton's method, the convergence of which has been
--   shown for relevant systems in <i>Boltzmann Oracle for Combinatorial
--   Systems</i>, C. Pivoteau, B. Salvy, M. Soria.
makeOracle :: DataDef m -> TypeRep -> Maybe Double -> Oracle

-- | Generating function definition. This defines a <tt>Phi_i[k]</tt>
--   function associated with the <tt>k</tt>-th pointing of the type at
--   index <tt>i</tt>, such that:
--   
--   <pre>
--   C_i[k](x)
--     = Phi_i[k](x, C_0[0](x), ..., C_(n-1)[0](x),
--                ..., C_0[k](x), ..., C_(n-1)[k](x))
--   </pre>
--   
--   Primitive datatypes have <tt>C(x) = x</tt>: they are considered as
--   having a single object (<tt>lCoef</tt>) of size 1 (<tt>order</tt>)).
phi :: Num a => DataDef m -> C -> [(Integer, constr, [C'])] -> a -> Vector a -> a

-- | Maps a key representing a type <tt>a</tt> (or one of its pointings) to
--   a generator <tt>m a</tt>.
type Generators m = (HashMap AC (SomeData m), HashMap C (SomeData m))

-- | Build all involved generators at once.
makeGenerators :: MonadRandomLike m => DataDef m -> Oracle -> Generators m
type SmallGenerators m = (HashMap Aliased (SomeData m), HashMap Ix (SomeData m))

-- | Generators of values of minimal sizes.
smallGenerators :: MonadRandomLike m => DataDef m -> SmallGenerators m
generate :: Applicative m => GUnfold (ReaderT [SomeData m] m)
defGen :: (Data a, MonadRandomLike m) => m a
(?) :: DataDef m -> C -> Int

-- | <pre>
--   dd ? (listCs dd !! i) = i
--   </pre>
listCs :: DataDef m -> [C]
ix :: C -> Int

-- | <pre>
--   dd ? (dd ?! i) = i
--   </pre>
(?!) :: DataDef m -> Int -> C
getGenerator :: (Functor m, Data a) => DataDef m -> Generators m -> proxy a -> Int -> m a
getSmallGenerator :: (Functor m, Data a) => DataDef m -> SmallGenerators m -> proxy a -> m a
frequencyWith :: (Show r, Ord r, Num r, Monad m) => (r -> m r) -> [(r, m a)] -> m a
(#!) :: (?loc :: CallStack, Eq k, Hashable k) => HashMap k v -> k -> v

-- | <tt>partitions k n</tt>: lists of non-negative integers of length
--   <tt>n</tt> with sum less than or equal to <tt>k</tt>.
partitions :: Int -> Int -> [[Int]]

-- | Multinomial coefficient.
--   
--   <pre>
--   multinomial n ps == factorial n `div` product [factorial p | p &lt;- ps]
--   </pre>
multinomial :: Int -> [Int] -> Integer

-- | Binomial coefficient.
--   
--   <pre>
--   binomial n k == factorial n `div` (factorial k * factorial (n-k))
--   </pre>
binomial :: Int -> Int -> Integer
instance GHC.Generics.Constructor Data.Random.Generics.Internal.Oracle.C1_0C
instance GHC.Generics.Datatype Data.Random.Generics.Internal.Oracle.D1C
instance GHC.Generics.Constructor Data.Random.Generics.Internal.Oracle.C1_0AC
instance GHC.Generics.Datatype Data.Random.Generics.Internal.Oracle.D1AC
instance GHC.Generics.Constructor Data.Random.Generics.Internal.Oracle.C1_0Aliased
instance GHC.Generics.Datatype Data.Random.Generics.Internal.Oracle.D1Aliased
instance GHC.Show.Show (Data.Random.Generics.Internal.Oracle.DataDef m)
instance GHC.Show.Show Data.Random.Generics.Internal.Oracle.Nat
instance GHC.Classes.Ord Data.Random.Generics.Internal.Oracle.Nat
instance GHC.Classes.Eq Data.Random.Generics.Internal.Oracle.Nat
instance GHC.Generics.Generic Data.Random.Generics.Internal.Oracle.C
instance GHC.Show.Show Data.Random.Generics.Internal.Oracle.C
instance GHC.Classes.Ord Data.Random.Generics.Internal.Oracle.C
instance GHC.Classes.Eq Data.Random.Generics.Internal.Oracle.C
instance GHC.Generics.Generic Data.Random.Generics.Internal.Oracle.AC
instance GHC.Show.Show Data.Random.Generics.Internal.Oracle.AC
instance GHC.Classes.Ord Data.Random.Generics.Internal.Oracle.AC
instance GHC.Classes.Eq Data.Random.Generics.Internal.Oracle.AC
instance GHC.Generics.Generic Data.Random.Generics.Internal.Oracle.Aliased
instance GHC.Show.Show Data.Random.Generics.Internal.Oracle.Aliased
instance GHC.Classes.Ord Data.Random.Generics.Internal.Oracle.Aliased
instance GHC.Classes.Eq Data.Random.Generics.Internal.Oracle.Aliased
instance Data.Hashable.Class.Hashable Data.Random.Generics.Internal.Oracle.C
instance Data.Hashable.Class.Hashable Data.Random.Generics.Internal.Oracle.AC
instance Data.Hashable.Class.Hashable Data.Random.Generics.Internal.Oracle.Aliased
instance GHC.Base.Monoid Data.Random.Generics.Internal.Oracle.Nat

module Data.Random.Generics.Internal

-- | Sized generator.
data SG r
SG :: Size -> Maybe Size -> (Points -> Maybe Double -> r) -> (Points -> r) -> SG r
[minSize] :: SG r -> Size
[maxSizeM] :: SG r -> Maybe Size
[runSG] :: SG r -> Points -> Maybe Double -> r
[runSmallG] :: SG r -> Points -> r

-- | Number of pointing iterations.
type Points = Int
rangeSG :: SG r -> (Size, Maybe Size)

-- | For documentation.
applySG :: SG r -> Points -> Maybe Double -> r
make :: (Data a, MonadRandomLike m) => [Alias m] -> proxy a -> SG (m a)
makeR :: (Data a, MonadRandomLike m) => [AliasR m] -> proxy a -> SG ((Size, Size) -> m a)

-- | The size of a value is its number of constructors.
--   
--   Here, however, the <a>Size'</a> type is interpreted differently to
--   make better use of QuickCheck's size parameter provided by the
--   <a>sized</a> combinator, so that we generate non-trivial data even at
--   very small size values.
--   
--   For infinite types, with objects of unbounded sizes <tt>&gt;
--   minSize</tt>, given a parameter <tt>delta :: <a>Size'</a></tt>, the
--   produced values have an average size close to <tt>minSize +
--   delta</tt>.
--   
--   For example, values of type <tt>Either () [Bool]</tt> have at least
--   two constructors, so
--   
--   <pre>
--   <tt>generator</tt> delta :: <tt>Gen</tt> (Either () [Bool])
--   </pre>
--   
--   will target sizes close to <tt>2 + delta</tt>; the offset becomes less
--   noticeable as <tt>delta</tt> grows to infinity.
--   
--   For finite types with sizes in <tt>[minSize, maxSize]</tt>, the target
--   expected size is obtained by clamping a <a>Size'</a> to <tt>[0,
--   99]</tt> and applying an affine mapping.
type Size' = Int
rescale :: SG r -> Size' -> Double
apply :: SG r -> Points -> Maybe Size' -> r
applyR :: SG ((Size, Size) -> r) -> Points -> Maybe Size' -> (Size', Size') -> r
rescaleInterval :: SG r -> (Size', Size') -> (Size, Size)

-- | <pre>
--   'epsilon' = 0.1
--   </pre>
--   
--   Default approximation ratio.
epsilon :: Double

-- | <pre>
--   (size * (1 - epsilon), size * (1 + epsilon))
--   </pre>
tolerance :: Double -> Int -> (Int, Int)
memo :: (t -> [t2] -> SG r) -> (SG r -> t1 -> Maybe Int -> a) -> t -> t1 -> Int -> a
sparseSized :: (Int -> a) -> Maybe Int -> Int -> a
instance GHC.Base.Functor Data.Random.Generics.Internal.SG


-- | Generic Boltzmann samplers.
--   
--   Here, the words "<i>sampler</i>" and "<i>generator</i>" are used
--   interchangeably.
--   
--   Given an algebraic datatype:
--   
--   <pre>
--   data A = A1 B C | A2 D
--   </pre>
--   
--   a Boltzmann sampler is recursively defined by choosing a constructor
--   with some fixed distribution, and <i>independently</i> generating
--   values for the corresponding fields with the same method.
--   
--   A key component is the aforementioned distribution, defined for every
--   type such that the resulting generator produces a finite value in the
--   end. These distributions are obtained from a precomputed object called
--   <i>oracle</i>, which we will not describe further here.
--   
--   Oracles depend on the target size of the generated data (except for
--   singular samplers), and can be fairly expensive to compute repeatedly,
--   hence some of the functions below attempt to avoid (re)computing too
--   many of them even when the required size changes.
--   
--   When these functions are specialized, oracles are memoized and will be
--   reused for different sizes.
module Data.Random.Generics

-- | The size of a value is its number of constructors.
--   
--   Here, however, the <a>Size'</a> type is interpreted differently to
--   make better use of QuickCheck's size parameter provided by the
--   <a>sized</a> combinator, so that we generate non-trivial data even at
--   very small size values.
--   
--   For infinite types, with objects of unbounded sizes <tt>&gt;
--   minSize</tt>, given a parameter <tt>delta :: <a>Size'</a></tt>, the
--   produced values have an average size close to <tt>minSize +
--   delta</tt>.
--   
--   For example, values of type <tt>Either () [Bool]</tt> have at least
--   two constructors, so
--   
--   <pre>
--   <tt>generator</tt> delta :: <tt>Gen</tt> (Either () [Bool])
--   </pre>
--   
--   will target sizes close to <tt>2 + delta</tt>; the offset becomes less
--   noticeable as <tt>delta</tt> grows to infinity.
--   
--   For finite types with sizes in <tt>[minSize, maxSize]</tt>, the target
--   expected size is obtained by clamping a <a>Size'</a> to <tt>[0,
--   99]</tt> and applying an affine mapping.
type Size' = Int

-- | <pre>
--   <a>generatorSR</a> :: Int -&gt; <tt>Gen</tt> a
--   <a>asMonadRandom</a> . <a>generatorSR</a> :: <tt>MonadRandom</tt> m =&gt; Int -&gt; m a
--   </pre>
--   
--   Singular ceiled rejection sampler.
generatorSR :: (Data a, MonadRandomLike m) => Size' -> m a

-- | <pre>
--   <a>generatorP</a> :: Int -&gt; <tt>Gen</tt> a
--   <a>asMonadRandom</a> . <a>generatorP</a> :: <tt>MonadRandom</tt> m =&gt; Int -&gt; m a
--   </pre>
--   
--   Generator of pointed values.
generatorP :: (Data a, MonadRandomLike m) => Size' -> m a

-- | Pointed generator with rejection.
generatorPR :: (Data a, MonadRandomLike m) => Size' -> m a

-- | Generator with rejection and dynamic average size.
generatorR :: (Data a, MonadRandomLike m) => Size' -> m a

-- | Pointed generator.
generatorP' :: (Data a, MonadRandomLike m) => Size' -> m a

-- | Pointed generator with rejection.
generatorPR' :: (Data a, MonadRandomLike m) => Size' -> m a

-- | Ceiled rejection sampler with given average size.
generatorR' :: (Data a, MonadRandomLike m) => Size' -> m a

-- | Basic boltzmann sampler with no optimization.
generator' :: (Data a, MonadRandomLike m) => Size' -> m a
generatorSRWith :: (Data a, MonadRandomLike m) => [AliasR m] -> Size' -> m a
generatorPWith :: (Data a, MonadRandomLike m) => [Alias m] -> Size' -> m a
generatorPRWith :: (Data a, MonadRandomLike m) => [AliasR m] -> Size' -> m a
generatorRWith :: (Data a, MonadRandomLike m) => [AliasR m] -> Size' -> m a
generatorPWith' :: (Data a, MonadRandomLike m) => [Alias m] -> Size' -> m a
generatorPRWith' :: (Data a, MonadRandomLike m) => [AliasR m] -> Size' -> m a
generatorRWith' :: (Data a, MonadRandomLike m) => [AliasR m] -> Size' -> m a
generatorWith' :: (Data a, MonadRandomLike m) => [Alias m] -> Size' -> m a

-- | Number of pointing iterations.
type Points = Int
generatorM :: (Data a, MonadRandomLike m) => [Alias m] -> Points -> Size' -> m a
generatorMR :: (Data a, MonadRandomLike m) => [AliasR m] -> Points -> Size' -> (Size', Size') -> m a

-- | Boltzmann sampler without rejection.
generator_ :: (Data a, MonadRandomLike m) => [Alias m] -> Points -> Maybe Size' -> m a

-- | Boltzmann sampler with rejection.
generatorR_ :: (Data a, MonadRandomLike m) => [AliasR m] -> Points -> Maybe Size' -> (Size', Size') -> m a

-- | <tt><a>MonadRandomLike</a> m</tt> defines basic components to build
--   generators, allowing the implementation to remain abstract over both
--   the <a>Gen</a> type and <a>MonadRandom</a> instances.
--   
--   For the latter, the wrapper <a>AMonadRandom</a> is provided to avoid
--   overlapping instances.
class Monad m => MonadRandomLike m where incr = return ()

-- | Called for every constructor. Counter for ceiled rejection sampling.
incr :: MonadRandomLike m => m ()

-- | <tt>doubleR upperBound</tt>: generates values in <tt>[0,
--   upperBound]</tt>.
doubleR :: MonadRandomLike m => Double -> m Double

-- | <tt>integerR upperBound</tt>: generates values in <tt>[0,
--   upperBound-1]</tt>.
integerR :: MonadRandomLike m => Integer -> m Integer

-- | Default <tt>Int</tt> generator.
int :: MonadRandomLike m => m Int

-- | Default <tt>Double</tt> generator.
double :: MonadRandomLike m => m Double

-- | Default <tt>Char</tt> generator.
char :: MonadRandomLike m => m Char
newtype AMonadRandom m a
AMonadRandom :: m a -> AMonadRandom m a
[asMonadRandom] :: AMonadRandom m a -> m a

-- | Main constructor for <a>Alias</a>.
alias :: (Monad m, Data a, Data b) => (a -> m b) -> Alias m

-- | Main constructor for <a>AliasR</a>.
aliasR :: (Monad m, Data a, Data b) => (a -> m b) -> AliasR m

-- | <pre>
--   coerceAlias :: Alias m -&gt; Alias (AMonadRandom m)
--   </pre>
coerceAlias :: Coercible m n => Alias m -> Alias n

-- | <pre>
--   coerceAliases :: [Alias m] -&gt; [Alias (AMonadRandom m)]
--   </pre>
coerceAliases :: Coercible m n => [Alias m] -> [Alias n]
data Alias m
Alias :: !(m a -> m b) -> Alias m
type AliasR m = Alias (RejectT m)