Safe Haskell | None |
---|---|

Language | Haskell2010 |

## Synopsis

- law_cataCancel :: (Eq a, Show a, Steppable t f, Recursive t f, Functor f, MonadTest m) => Algebra f a -> f t -> m ()
- law_cataRefl :: (Eq t, Show t, Steppable t f, Recursive t f, MonadTest m) => t -> m ()
- law_anaRefl :: (Eq t, Show t, Steppable t f, Corecursive t f, MonadTest m) => t -> m ()
- embeddableOfHeight :: (Steppable t f, Functor f) => Gen (f Void) -> (Gen t -> Gen (f t)) -> Size -> Gen t
- genAlgebra :: (Steppable t f, Functor f) => Gen (f Void) -> (Gen t -> Gen (f t)) -> Algebra Maybe (Gen t)
- genCorecursive :: Corecursive t f => (a -> f a) -> Gen a -> Gen t

# Documentation

law_cataCancel :: (Eq a, Show a, Steppable t f, Recursive t f, Functor f, MonadTest m) => Algebra f a -> f t -> m () Source #

law_anaRefl :: (Eq t, Show t, Steppable t f, Corecursive t f, MonadTest m) => t -> m () Source #

NB: Since this requires both a `Corecursive`

and `Eq`

instance on the same
type, it _likely_ requires instances from yaya-unsafe.

embeddableOfHeight :: (Steppable t f, Functor f) => Gen (f Void) -> (Gen t -> Gen (f t)) -> Size -> Gen t Source #

Creates a generator for any `Steppable`

type whose pattern functor has
terminal cases (e.g., not `Identity`

or `((,) a)`). `leaf`

can only
generate terminal cases, and `any`

can generate any case. If the provided
`any`

generates terminal cases, then the resulting tree may have a height
less than the `Size`

, otherwise it will be a perfect tree with a height of
exactly the provided `Size`

.

This is similar to `recursive`

in that it separates the non-recursive
cases from the recursive ones, except
• the types here also ensure that the non-recursive cases aren’t recursive,
• different generator distributions may be used for rec & non-rec cases, and
• the non-recursive cases aren’t included in recursive calls (see above for
why).

If there’s no existing `Gen (f Void)` for your pattern functor, you can
either create one manually, or pass `discard`

to the usual
`Gen a -> Gen (f a)` generator.

genAlgebra :: (Steppable t f, Functor f) => Gen (f Void) -> (Gen t -> Gen (f t)) -> Algebra Maybe (Gen t) Source #

Builds a generic tree generator of a certain height.

genCorecursive :: Corecursive t f => (a -> f a) -> Gen a -> Gen t Source #

Creates a generator for potentially-infinite values.