hedgehog-0.6: Hedgehog will eat all your bugs.

Safe HaskellNone
LanguageHaskell98

Hedgehog.Internal.Gen

Contents

Synopsis

Transformer

type Gen = GenT Identity Source #

Generator for random values of a.

newtype GenT m a Source #

Monad transformer which can generate random values of a.

Constructors

GenT 

Fields

Instances

MMonad GenT Source # 

Methods

embed :: Monad n => (forall a. m a -> GenT n a) -> GenT m b -> GenT n b #

MonadTrans GenT Source # 

Methods

lift :: Monad m => m a -> GenT m a #

Distributive GenT Source # 

Associated Types

type Transformer (f :: (* -> *) -> * -> *) (GenT :: (* -> *) -> * -> *) (m :: * -> *) :: Constraint Source #

Methods

distribute :: Transformer f GenT m => GenT (f m) a -> f (GenT m) a Source #

MonadBase b m => MonadBase b (GenT m) Source # 

Methods

liftBase :: b α -> GenT m α #

MonadWriter w m => MonadWriter w (GenT m) Source # 

Methods

writer :: (a, w) -> GenT m a #

tell :: w -> GenT m () #

listen :: GenT m a -> GenT m (a, w) #

pass :: GenT m (a, w -> w) -> GenT m a #

MonadState s m => MonadState s (GenT m) Source # 

Methods

get :: GenT m s #

put :: s -> GenT m () #

state :: (s -> (a, s)) -> GenT m a #

MonadReader r m => MonadReader r (GenT m) Source # 

Methods

ask :: GenT m r #

local :: (r -> r) -> GenT m a -> GenT m a #

reader :: (r -> a) -> GenT m a #

MonadError e m => MonadError e (GenT m) Source # 

Methods

throwError :: e -> GenT m a #

catchError :: GenT m a -> (e -> GenT m a) -> GenT m a #

Monad m => Monad (GenT m) Source # 

Methods

(>>=) :: GenT m a -> (a -> GenT m b) -> GenT m b #

(>>) :: GenT m a -> GenT m b -> GenT m b #

return :: a -> GenT m a #

fail :: String -> GenT m a #

Functor m => Functor (GenT m) Source # 

Methods

fmap :: (a -> b) -> GenT m a -> GenT m b #

(<$) :: a -> GenT m b -> GenT m a #

Monad m => Applicative (GenT m) Source # 

Methods

pure :: a -> GenT m a #

(<*>) :: GenT m (a -> b) -> GenT m a -> GenT m b #

liftA2 :: (a -> b -> c) -> GenT m a -> GenT m b -> GenT m c #

(*>) :: GenT m a -> GenT m b -> GenT m b #

(<*) :: GenT m a -> GenT m b -> GenT m a #

MonadIO m => MonadIO (GenT m) Source # 

Methods

liftIO :: IO a -> GenT m a #

Monad m => Alternative (GenT m) Source # 

Methods

empty :: GenT m a #

(<|>) :: GenT m a -> GenT m a -> GenT m a #

some :: GenT m a -> GenT m [a] #

many :: GenT m a -> GenT m [a] #

Monad m => MonadPlus (GenT m) Source # 

Methods

mzero :: GenT m a #

mplus :: GenT m a -> GenT m a -> GenT m a #

MonadCatch m => MonadCatch (GenT m) Source # 

Methods

catch :: Exception e => GenT m a -> (e -> GenT m a) -> GenT m a #

MonadThrow m => MonadThrow (GenT m) Source # 

Methods

throwM :: Exception e => e -> GenT m a #

PrimMonad m => PrimMonad (GenT m) Source # 

Associated Types

type PrimState (GenT m :: * -> *) :: * #

Methods

primitive :: (State# (PrimState (GenT m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (GenT m)), a#)) -> GenT m a #

MonadResource m => MonadResource (GenT m) Source # 

Methods

liftResourceT :: ResourceT IO a -> GenT m a #

Monad m => MonadGen (GenT m) Source # 

Methods

liftGen :: Gen a -> GenT m a Source #

shrinkGen :: (a -> [a]) -> GenT m a -> GenT m a Source #

pruneGen :: GenT m a -> GenT m a Source #

scaleGen :: (Size -> Size) -> GenT m a -> GenT m a Source #

freezeGen :: GenT m a -> GenT m (a, GenT m a) Source #

MFunctor * GenT Source # 

Methods

hoist :: Monad m => (forall a. m a -> n a) -> t m b -> t n b #

(Monad m, Semigroup a) => Semigroup (GenT m a) Source # 

Methods

(<>) :: GenT m a -> GenT m a -> GenT m a #

sconcat :: NonEmpty (GenT m a) -> GenT m a #

stimes :: Integral b => b -> GenT m a -> GenT m a #

(Monad m, Monoid a) => Monoid (GenT m a) Source # 

Methods

mempty :: GenT m a #

mappend :: GenT m a -> GenT m a -> GenT m a #

mconcat :: [GenT m a] -> GenT m a #

type Transformer t GenT m Source # 
type PrimState (GenT m) Source # 
type PrimState (GenT m) = PrimState m

class Monad m => MonadGen m where Source #

Class of monads which can generate input data for tests.

The functions on this class can, and should, be used without their Gen suffix by importing Hedgehog.Gen qualified.

Minimal complete definition

liftGen, shrinkGen, pruneGen, scaleGen, freezeGen

Methods

liftGen :: Gen a -> m a Source #

See Gen.lift

shrinkGen :: (a -> [a]) -> m a -> m a Source #

See Gen.shrink

pruneGen :: m a -> m a Source #

See Gen.prune

scaleGen :: (Size -> Size) -> m a -> m a Source #

See Gen.scale

freezeGen :: m a -> m (a, m a) Source #

See Gen.freeze

Instances

MonadGen m => MonadGen (MaybeT m) Source # 

Methods

liftGen :: Gen a -> MaybeT m a Source #

shrinkGen :: (a -> [a]) -> MaybeT m a -> MaybeT m a Source #

pruneGen :: MaybeT m a -> MaybeT m a Source #

scaleGen :: (Size -> Size) -> MaybeT m a -> MaybeT m a Source #

freezeGen :: MaybeT m a -> MaybeT m (a, MaybeT m a) Source #

Monad m => MonadGen (GenT m) Source # 

Methods

liftGen :: Gen a -> GenT m a Source #

shrinkGen :: (a -> [a]) -> GenT m a -> GenT m a Source #

pruneGen :: GenT m a -> GenT m a Source #

scaleGen :: (Size -> Size) -> GenT m a -> GenT m a Source #

freezeGen :: GenT m a -> GenT m (a, GenT m a) Source #

MonadGen m => MonadGen (ExceptT x m) Source # 

Methods

liftGen :: Gen a -> ExceptT x m a Source #

shrinkGen :: (a -> [a]) -> ExceptT x m a -> ExceptT x m a Source #

pruneGen :: ExceptT x m a -> ExceptT x m a Source #

scaleGen :: (Size -> Size) -> ExceptT x m a -> ExceptT x m a Source #

freezeGen :: ExceptT x m a -> ExceptT x m (a, ExceptT x m a) Source #

(MonadGen m, Monoid w) => MonadGen (WriterT w m) Source # 

Methods

liftGen :: Gen a -> WriterT w m a Source #

shrinkGen :: (a -> [a]) -> WriterT w m a -> WriterT w m a Source #

pruneGen :: WriterT w m a -> WriterT w m a Source #

scaleGen :: (Size -> Size) -> WriterT w m a -> WriterT w m a Source #

freezeGen :: WriterT w m a -> WriterT w m (a, WriterT w m a) Source #

MonadGen m => MonadGen (StateT s m) Source # 

Methods

liftGen :: Gen a -> StateT s m a Source #

shrinkGen :: (a -> [a]) -> StateT s m a -> StateT s m a Source #

pruneGen :: StateT s m a -> StateT s m a Source #

scaleGen :: (Size -> Size) -> StateT s m a -> StateT s m a Source #

freezeGen :: StateT s m a -> StateT s m (a, StateT s m a) Source #

MonadGen m => MonadGen (IdentityT * m) Source # 

Methods

liftGen :: Gen a -> IdentityT * m a Source #

shrinkGen :: (a -> [a]) -> IdentityT * m a -> IdentityT * m a Source #

pruneGen :: IdentityT * m a -> IdentityT * m a Source #

scaleGen :: (Size -> Size) -> IdentityT * m a -> IdentityT * m a Source #

freezeGen :: IdentityT * m a -> IdentityT * m (a, IdentityT * m a) Source #

MonadGen m => MonadGen (StateT s m) Source # 

Methods

liftGen :: Gen a -> StateT s m a Source #

shrinkGen :: (a -> [a]) -> StateT s m a -> StateT s m a Source #

pruneGen :: StateT s m a -> StateT s m a Source #

scaleGen :: (Size -> Size) -> StateT s m a -> StateT s m a Source #

freezeGen :: StateT s m a -> StateT s m (a, StateT s m a) Source #

(MonadGen m, Monoid w) => MonadGen (WriterT w m) Source # 

Methods

liftGen :: Gen a -> WriterT w m a Source #

shrinkGen :: (a -> [a]) -> WriterT w m a -> WriterT w m a Source #

pruneGen :: WriterT w m a -> WriterT w m a Source #

scaleGen :: (Size -> Size) -> WriterT w m a -> WriterT w m a Source #

freezeGen :: WriterT w m a -> WriterT w m (a, WriterT w m a) Source #

MonadGen m => MonadGen (ReaderT * r m) Source # 

Methods

liftGen :: Gen a -> ReaderT * r m a Source #

shrinkGen :: (a -> [a]) -> ReaderT * r m a -> ReaderT * r m a Source #

pruneGen :: ReaderT * r m a -> ReaderT * r m a Source #

scaleGen :: (Size -> Size) -> ReaderT * r m a -> ReaderT * r m a Source #

freezeGen :: ReaderT * r m a -> ReaderT * r m (a, ReaderT * r m a) Source #

(MonadGen m, Monoid w) => MonadGen (RWST r w s m) Source # 

Methods

liftGen :: Gen a -> RWST r w s m a Source #

shrinkGen :: (a -> [a]) -> RWST r w s m a -> RWST r w s m a Source #

pruneGen :: RWST r w s m a -> RWST r w s m a Source #

scaleGen :: (Size -> Size) -> RWST r w s m a -> RWST r w s m a Source #

freezeGen :: RWST r w s m a -> RWST r w s m (a, RWST r w s m a) Source #

(MonadGen m, Monoid w) => MonadGen (RWST r w s m) Source # 

Methods

liftGen :: Gen a -> RWST r w s m a Source #

shrinkGen :: (a -> [a]) -> RWST r w s m a -> RWST r w s m a Source #

pruneGen :: RWST r w s m a -> RWST r w s m a Source #

scaleGen :: (Size -> Size) -> RWST r w s m a -> RWST r w s m a Source #

freezeGen :: RWST r w s m a -> RWST r w s m (a, RWST r w s m a) Source #

Combinators

lift :: MonadGen m => Gen a -> m a Source #

Lift a vanilla Gen in to a MonadGen.

Shrinking

shrink :: MonadGen m => (a -> [a]) -> m a -> m a Source #

Apply a shrinking function to a generator.

This will give the generator additional shrinking options, while keeping the existing shrinks intact.

prune :: MonadGen m => m a -> m a Source #

Throw away a generator's shrink tree.

Size

small :: MonadGen m => m a -> m a Source #

Make a generator smaller by scaling its size parameter.

scale :: MonadGen m => (Size -> Size) -> m a -> m a Source #

Adjust the size parameter by transforming it with the given function.

resize :: MonadGen m => Size -> m a -> m a Source #

Override the size parameter. Returns a generator which uses the given size instead of the runtime-size parameter.

sized :: MonadGen m => (Size -> m a) -> m a Source #

Construct a generator that depends on the size parameter.

Integral

integral :: (MonadGen m, Integral a) => Range a -> m a Source #

Generates a random integral number in the given [inclusive,inclusive] range.

When the generator tries to shrink, it will shrink towards the origin of the specified Range.

For example, the following generator will produce a number between 1970 and 2100, but will shrink towards 2000:

integral (Range.constantFrom 2000 1970 2100) :: Gen Int

Some sample outputs from this generator might look like:

=== Outcome ===
1973
=== Shrinks ===
2000
1987
1980
1976
1974
=== Outcome ===
2061
=== Shrinks ===
2000
2031
2046
2054
2058
2060

integral_ :: (MonadGen m, Integral a) => Range a -> m a Source #

Generates a random integral number in the [inclusive,inclusive] range.

This generator does not shrink.

int :: MonadGen m => Range Int -> m Int Source #

Generates a random machine integer in the given [inclusive,inclusive] range.

This is a specialization of integral, offered for convenience.

int8 :: MonadGen m => Range Int8 -> m Int8 Source #

Generates a random 8-bit integer in the given [inclusive,inclusive] range.

This is a specialization of integral, offered for convenience.

int16 :: MonadGen m => Range Int16 -> m Int16 Source #

Generates a random 16-bit integer in the given [inclusive,inclusive] range.

This is a specialization of integral, offered for convenience.

int32 :: MonadGen m => Range Int32 -> m Int32 Source #

Generates a random 32-bit integer in the given [inclusive,inclusive] range.

This is a specialization of integral, offered for convenience.

int64 :: MonadGen m => Range Int64 -> m Int64 Source #

Generates a random 64-bit integer in the given [inclusive,inclusive] range.

This is a specialization of integral, offered for convenience.

word :: MonadGen m => Range Word -> m Word Source #

Generates a random machine word in the given [inclusive,inclusive] range.

This is a specialization of integral, offered for convenience.

word8 :: MonadGen m => Range Word8 -> m Word8 Source #

Generates a random byte in the given [inclusive,inclusive] range.

This is a specialization of integral, offered for convenience.

word16 :: MonadGen m => Range Word16 -> m Word16 Source #

Generates a random 16-bit word in the given [inclusive,inclusive] range.

This is a specialization of integral, offered for convenience.

word32 :: MonadGen m => Range Word32 -> m Word32 Source #

Generates a random 32-bit word in the given [inclusive,inclusive] range.

This is a specialization of integral, offered for convenience.

word64 :: MonadGen m => Range Word64 -> m Word64 Source #

Generates a random 64-bit word in the given [inclusive,inclusive] range.

This is a specialization of integral, offered for convenience.

Floating-point

realFloat :: (MonadGen m, RealFloat a) => Range a -> m a Source #

Generates a random floating-point number in the [inclusive,exclusive) range.

This generator works the same as integral, but for floating point numbers.

realFrac_ :: (MonadGen m, RealFrac a) => Range a -> m a Source #

Generates a random fractional number in the [inclusive,exclusive) range.

This generator does not shrink.

float :: MonadGen m => Range Float -> m Float Source #

Generates a random floating-point number in the [inclusive,exclusive) range.

This is a specialization of realFloat, offered for convenience.

double :: MonadGen m => Range Double -> m Double Source #

Generates a random floating-point number in the [inclusive,exclusive) range.

This is a specialization of realFloat, offered for convenience.

Enumeration

enum :: (MonadGen m, Enum a) => a -> a -> m a Source #

Generates an element from an enumeration.

This generator shrinks towards the first argument.

For example:

enum 'a' 'z' :: Gen Char

enumBounded :: (MonadGen m, Enum a, Bounded a) => m a Source #

Generates a random value from a bounded enumeration.

This generator shrinks towards minBound.

For example:

enumBounded :: Gen Bool

bool :: MonadGen m => m Bool Source #

Generates a random boolean.

This generator shrinks to False.

This is a specialization of enumBounded, offered for convenience.

bool_ :: MonadGen m => m Bool Source #

Generates a random boolean.

This generator does not shrink.

Characters

binit :: MonadGen m => m Char Source #

Generates an ASCII binit: '0'..'1'

octit :: MonadGen m => m Char Source #

Generates an ASCII octit: '0'..'7'

digit :: MonadGen m => m Char Source #

Generates an ASCII digit: '0'..'9'

hexit :: MonadGen m => m Char Source #

Generates an ASCII hexit: '0'..'9', 'a'..'f', 'A'..'F'

lower :: MonadGen m => m Char Source #

Generates an ASCII lowercase letter: 'a'..'z'

upper :: MonadGen m => m Char Source #

Generates an ASCII uppercase letter: 'A'..'Z'

alpha :: MonadGen m => m Char Source #

Generates an ASCII letter: 'a'..'z', 'A'..'Z'

alphaNum :: MonadGen m => m Char Source #

Generates an ASCII letter or digit: 'a'..'z', 'A'..'Z', '0'..'9'

ascii :: MonadGen m => m Char Source #

Generates an ASCII character: '\0'..'\127'

latin1 :: MonadGen m => m Char Source #

Generates a Latin-1 character: '\0'..'\255'

unicode :: MonadGen m => m Char Source #

Generates a Unicode character, excluding noncharacters and invalid standalone surrogates: '\0'..'\1114111' (excluding '\55296'..'\57343')

unicodeAll :: MonadGen m => m Char Source #

Generates a Unicode character, including noncharacters and invalid standalone surrogates: '\0'..'\1114111'

Strings

string :: MonadGen m => Range Int -> m Char -> m String Source #

Generates a string using Range to determine the length.

This is a specialization of list, offered for convenience.

text :: MonadGen m => Range Int -> m Char -> m Text Source #

Generates a string using Range to determine the length.

utf8 :: MonadGen m => Range Int -> m Char -> m ByteString Source #

Generates a UTF-8 encoded string, using Range to determine the length.

bytes :: MonadGen m => Range Int -> m ByteString Source #

Generates a random ByteString, using Range to determine the length.

Choice

constant :: MonadGen m => a -> m a Source #

Trivial generator that always produces the same element.

This is another name for pure / return.

element :: MonadGen m => [a] -> m a Source #

Randomly selects one of the elements in the list.

This generator shrinks towards the first element in the list.

The input list must be non-empty.

choice :: MonadGen m => [m a] -> m a Source #

Randomly selects one of the generators in the list.

This generator shrinks towards the first generator in the list.

The input list must be non-empty.

frequency :: MonadGen m => [(Int, m a)] -> m a Source #

Uses a weighted distribution to randomly select one of the generators in the list.

This generator shrinks towards the first generator in the list.

The input list must be non-empty.

recursive :: MonadGen m => ([m a] -> m a) -> [m a] -> [m a] -> m a Source #

Modifies combinators which choose from a list of generators, like choice or frequency, so that they can be used in recursive scenarios.

This combinator modifies its target to select one of the generators in either the non-recursive or the recursive list. When a selection is made from the recursive list, the Size is halved. When the Size gets to one or less, selections are no longer made from the recursive list, this ensures termination.

A good example of where this might be useful is abstract syntax trees:

data Expr =
    Var String
  | Lam String Expr
  | App Expr Expr

-- Assuming we have a name generator
genName :: MonadGen m => m String

-- We can write a generator for expressions
genExpr :: MonadGen m => m Expr
genExpr =
  Gen.recursive Gen.choice [
      -- non-recursive generators
      Var <$> genName
    ] [
      -- recursive generators
      Gen.subtermM genExpr (x -> Lam <$> genName <*> pure x)
    , Gen.subterm2 genExpr genExpr App
    ]

If we wrote the above example using only choice, it is likely that it would fail to terminate. This is because for every call to genExpr, there is a 2 in 3 chance that we will recurse again.

Conditional

discard :: MonadGen m => m a Source #

Discards the whole generator.

ensure :: MonadGen m => (a -> Bool) -> m a -> m a Source #

Discards the generator if the generated value does not satisfy the predicate.

filter :: MonadGen m => (a -> Bool) -> m a -> m a Source #

Generates a value that satisfies a predicate.

This is essentially:

filter p gen = mfilter p gen <|> filter p gen

It differs from the above in that we keep some state to avoid looping forever. If we trigger these limits then the whole generator is discarded.

just :: MonadGen m => m (Maybe a) -> m a Source #

Runs a Maybe generator until it produces a Just.

This is implemented using filter and has the same caveats.

Collections

maybe :: MonadGen m => m a -> m (Maybe a) Source #

Generates a Nothing some of the time.

list :: MonadGen m => Range Int -> m a -> m [a] Source #

Generates a list using a Range to determine the length.

seq :: MonadGen m => Range Int -> m a -> m (Seq a) Source #

Generates a seq using a Range to determine the length.

nonEmpty :: MonadGen m => Range Int -> m a -> m (NonEmpty a) Source #

Generates a non-empty list using a Range to determine the length.

set :: (MonadGen m, Ord a) => Range Int -> m a -> m (Set a) Source #

Generates a set using a Range to determine the length.

This may fail to generate anything if the element generator cannot produce a large enough number of unique items to satify the required set size.

map :: (MonadGen m, Ord k) => Range Int -> m (k, v) -> m (Map k v) Source #

Generates a map using a Range to determine the length.

This may fail to generate anything if the keys produced by the generator do not account for a large enough number of unique items to satify the required map size.

Subterms

freeze :: MonadGen m => m a -> m (a, m a) Source #

Freeze the size and seed used by a generator, so we can inspect the value which it will produce.

This is used for implementing list and subtermMVec. It allows us to shrink the list itself before trying to shrink the values inside the list.

subterm :: MonadGen m => m a -> (a -> a) -> m a Source #

Constructs a generator from a sub-term generator.

Shrinks to the sub-term if possible.

subtermM :: MonadGen m => m a -> (a -> m a) -> m a Source #

Constructs a generator from a sub-term generator.

Shrinks to the sub-term if possible.

subterm2 :: MonadGen m => m a -> m a -> (a -> a -> a) -> m a Source #

Constructs a generator from two sub-term generators.

Shrinks to one of the sub-terms if possible.

subtermM2 :: MonadGen m => m a -> m a -> (a -> a -> m a) -> m a Source #

Constructs a generator from two sub-term generators.

Shrinks to one of the sub-terms if possible.

subterm3 :: MonadGen m => m a -> m a -> m a -> (a -> a -> a -> a) -> m a Source #

Constructs a generator from three sub-term generators.

Shrinks to one of the sub-terms if possible.

subtermM3 :: MonadGen m => m a -> m a -> m a -> (a -> a -> a -> m a) -> m a Source #

Constructs a generator from three sub-term generators.

Shrinks to one of the sub-terms if possible.

Combinations & Permutations

subsequence :: MonadGen m => [a] -> m [a] Source #

Generates a random subsequence of a list.

shuffle :: MonadGen m => [a] -> m [a] Source #

Generates a random permutation of a list.

This shrinks towards the order of the list being identical to the input list.

Sampling Generators

sample :: MonadIO m => Gen a -> m a Source #

Generate a sample from a generator.

print :: (MonadIO m, Show a) => Gen a -> m () Source #

Run a generator with a random seed and print the outcome, and the first level of shrinks.

Gen.print (Gen.enum 'a' 'f')
=== Outcome ===
'd'
=== Shrinks ===
'a'
'b'
'c'

printTree :: (MonadIO m, Show a) => Gen a -> m () Source #

Run a generator with a random seed and print the resulting shrink tree.

Gen.printTree (Gen.enum 'a' 'f')
'd'
 ├╼'a'
 ├╼'b'
 │  └╼'a'
 └╼'c'
    ├╼'a'
    └╼'b'
       └╼'a'

This may not terminate when the tree is very large.

printWith :: (MonadIO m, Show a) => Size -> Seed -> Gen a -> m () Source #

Print the value produced by a generator, and the first level of shrinks, for the given size and seed.

Use print to generate a value from a random seed.

printTreeWith :: (MonadIO m, Show a) => Size -> Seed -> Gen a -> m () Source #

Print the shrink tree produced by a generator, for the given size and seed.

Use printTree to generate a value from a random seed.

Internal

These functions are exported in case you need them in a pinch, but are not part of the public API and may change at any time, even as part of a minor update.

Transfomer

runGenT :: Size -> Seed -> GenT m a -> Tree (MaybeT m) a Source #

Runs a generator, producing its shrink tree.

mapGenT :: (Tree (MaybeT m) a -> Tree (MaybeT n) b) -> GenT m a -> GenT n b Source #

Map over a generator's shrink tree.

generate :: MonadGen m => (Size -> Seed -> a) -> m a Source #

Generate a value with no shrinks from a Size and a Seed.

liftTree :: Tree (MaybeT m) a -> GenT m a Source #

Lift a predefined shrink tree in to a generator, ignoring the seed and the size.

runDiscardEffect :: Monad m => Tree (MaybeT m) a -> Tree m (Maybe a) Source #

Run the discard effects through the tree and reify them as Maybe values at the nodes. Nothing means discarded, Just means we have a value.

Size

golden :: Size -> Size Source #

Scale a size using the golden ratio.

golden x = x / φ
golden x = x / 1.61803..

Shrinking

atLeast :: Int -> [a] -> Bool Source #

Check that list contains at least a certain number of elements.

Characters

isSurrogate :: Char -> Bool Source #

Check if a character is in the surrogate category.

isNoncharacter :: Char -> Bool Source #

Check if a character is one of the noncharacters '\65534', '\65535'.

Subterms

data Vec n a where Source #

Constructors

Nil :: Vec Z a 
(:.) :: a -> Vec n a -> Vec (S n) a infixr 5 

Instances

Functor (Vec n) Source # 

Methods

fmap :: (a -> b) -> Vec n a -> Vec n b #

(<$) :: a -> Vec n b -> Vec n a #

Foldable (Vec n) Source # 

Methods

fold :: Monoid m => Vec n m -> m #

foldMap :: Monoid m => (a -> m) -> Vec n a -> m #

foldr :: (a -> b -> b) -> b -> Vec n a -> b #

foldr' :: (a -> b -> b) -> b -> Vec n a -> b #

foldl :: (b -> a -> b) -> b -> Vec n a -> b #

foldl' :: (b -> a -> b) -> b -> Vec n a -> b #

foldr1 :: (a -> a -> a) -> Vec n a -> a #

foldl1 :: (a -> a -> a) -> Vec n a -> a #

toList :: Vec n a -> [a] #

null :: Vec n a -> Bool #

length :: Vec n a -> Int #

elem :: Eq a => a -> Vec n a -> Bool #

maximum :: Ord a => Vec n a -> a #

minimum :: Ord a => Vec n a -> a #

sum :: Num a => Vec n a -> a #

product :: Num a => Vec n a -> a #

Traversable (Vec n) Source # 

Methods

traverse :: Applicative f => (a -> f b) -> Vec n a -> f (Vec n b) #

sequenceA :: Applicative f => Vec n (f a) -> f (Vec n a) #

mapM :: Monad m => (a -> m b) -> Vec n a -> m (Vec n b) #

sequence :: Monad m => Vec n (m a) -> m (Vec n a) #

data Nat Source #

Constructors

Z 
S Nat 

subtermMVec :: MonadGen m => Vec n (m a) -> (Vec n a -> m a) -> m a Source #

Constructs a generator from a number of sub-term generators.

Shrinks to one of the sub-terms if possible.

Sampling

renderNodes :: (Monad m, Show a) => Size -> Seed -> Gen a -> Tree m String Source #

Render a generator as a tree of strings.