Hedgehog.Function.Internal

Documentation

data a :-> c where infixr 5

Shrinkable, showable functions

Claessen, K. (2012, September). Shrinking and showing functions:(functional pearl). In ACM SIGPLAN Notices (Vol. 47, No. 12, pp. 73-80). ACM.

Constructors

Unit :: c -> () :-> c

Nil :: a :-> c

Pair :: (a :-> (b :-> c)) -> (a, b) :-> c

Sum :: (a :-> c) -> (b :-> c) -> Either a b :-> c

Map :: (a -> b) -> (b -> a) -> (b :-> c) -> a :-> c

Instances

Functor ((:->) r)

Defined in Hedgehog.Function.Internal

Methods

fmap :: (a -> b) -> (r :-> a) -> r :-> b

(<$) :: a -> (r :-> b) -> r :-> a

(Show a, Show b) => Show (a :-> b)

Defined in Hedgehog.Function.Internal

Methods

showsPrec :: Int -> (a :-> b) -> ShowS

show :: (a :-> b) -> String

showList :: [a :-> b] -> ShowS

table :: (a :-> c) -> [(a, c)]

Tabulate the function

class GArg a where

Minimal complete definition

gbuild'

Methods

gbuild' :: (a x -> c) -> a x :-> c

Instances

GArg (V1 :: * -> *)

Defined in Hedgehog.Function.Internal

Methods

gbuild' :: (V1 x -> c) -> V1 x :-> c

GArg (U1 :: * -> *)

Defined in Hedgehog.Function.Internal

Methods

gbuild' :: (U1 x -> c) -> U1 x :-> c

Arg b => GArg (K1 a b :: * -> *)

Defined in Hedgehog.Function.Internal

Methods

gbuild' :: (K1 a b x -> c) -> K1 a b x :-> c

(GArg a, GArg b) => GArg (a :+: b)

Defined in Hedgehog.Function.Internal

Methods

gbuild' :: ((a :+: b) x -> c) -> (a :+: b) x :-> c

(GArg a, GArg b) => GArg (a :*: b)

Defined in Hedgehog.Function.Internal

Methods

gbuild' :: ((a :*: b) x -> c) -> (a :*: b) x :-> c

GArg c => GArg (M1 a b c)

Defined in Hedgehog.Function.Internal

Methods

gbuild' :: (M1 a b c x -> c0) -> M1 a b c x :-> c0

gbuild :: (Generic a, GArg (Rep a)) => (a -> c) -> a :-> c

Reify a function whose domain has an instance of Generic

class Arg a where

instance Arg A where allows functions which take As to be reified

Methods

build :: (a -> c) -> a :-> c

build :: (Generic a, GArg (Rep a)) => (a -> c) -> a :-> c

Instances

Arg Bool

Defined in Hedgehog.Function.Internal

Methods

build :: (Bool -> c) -> Bool :-> c

Arg Int

Defined in Hedgehog.Function.Internal

Methods

build :: (Int -> c) -> Int :-> c

Arg Int8

Defined in Hedgehog.Function.Internal

Methods

build :: (Int8 -> c) -> Int8 :-> c

Arg Int16

Defined in Hedgehog.Function.Internal

Methods

build :: (Int16 -> c) -> Int16 :-> c

Arg Int32

Defined in Hedgehog.Function.Internal

Methods

build :: (Int32 -> c) -> Int32 :-> c

Arg Int64

Defined in Hedgehog.Function.Internal

Methods

build :: (Int64 -> c) -> Int64 :-> c

Arg Integer

Defined in Hedgehog.Function.Internal

Methods

build :: (Integer -> c) -> Integer :-> c

Arg Ordering

Defined in Hedgehog.Function.Internal

Methods

build :: (Ordering -> c) -> Ordering :-> c

Arg ()

Defined in Hedgehog.Function.Internal

Methods

build :: (() -> c) -> () :-> c

Arg Void

Defined in Hedgehog.Function.Internal

Methods

build :: (Void -> c) -> Void :-> c

Arg a => Arg [a]

Defined in Hedgehog.Function.Internal

Methods

build :: ([a] -> c) -> [a] :-> c

Arg a => Arg (Maybe a)

Defined in Hedgehog.Function.Internal

Methods

build :: (Maybe a -> c) -> Maybe a :-> c

(Arg a, Arg b) => Arg (Either a b)

Defined in Hedgehog.Function.Internal

Methods

build :: (Either a b -> c) -> Either a b :-> c

(Arg a, Arg b) => Arg (a, b)

Defined in Hedgehog.Function.Internal

Methods

build :: ((a, b) -> c) -> (a, b) :-> c

variant :: Word64 -> GenT m b -> GenT m b

variant' :: Word64 -> CoGenT m b -> CoGenT m b

class GVary a where

Minimal complete definition

gvary'

Methods

gvary' :: CoGenT m (a x)

Instances

GVary (V1 :: * -> *)

Defined in Hedgehog.Function.Internal

Methods

gvary' :: CoGenT m (V1 x)

GVary (U1 :: * -> *)

Defined in Hedgehog.Function.Internal

Methods

gvary' :: CoGenT m (U1 x)

Vary b => GVary (K1 a b :: * -> *)

Defined in Hedgehog.Function.Internal

Methods

gvary' :: CoGenT m (K1 a b x)

(GVary a, GVary b) => GVary (a :+: b)

Defined in Hedgehog.Function.Internal

Methods

gvary' :: CoGenT m ((a :+: b) x)

(GVary a, GVary b) => GVary (a :*: b)

Defined in Hedgehog.Function.Internal

Methods

gvary' :: CoGenT m ((a :*: b) x)

GVary c => GVary (M1 a b c)

Defined in Hedgehog.Function.Internal

Methods

gvary' :: CoGenT m (M1 a b c x)

gvary :: (Generic a, GVary (Rep a)) => CoGenT m a

Build a co-generator for a type which has a Generic instance

class Vary a where

Vary provides a canonical co-generator for a type.

While technically there are many possible co-generators for a given type, we don't get any benefit from caring.

Methods

vary :: CoGenT m a

vary :: (Generic a, GVary (Rep a)) => CoGenT m a

Instances

Vary Bool

Defined in Hedgehog.Function.Internal

Methods

vary :: CoGenT m Bool

Vary Int

Defined in Hedgehog.Function.Internal

Methods

vary :: CoGenT m Int

Vary Int8

Defined in Hedgehog.Function.Internal

Methods

vary :: CoGenT m Int8

Vary Int16

Defined in Hedgehog.Function.Internal

Methods

vary :: CoGenT m Int16

Vary Int32

Defined in Hedgehog.Function.Internal

Methods

vary :: CoGenT m Int32

Vary Int64

Defined in Hedgehog.Function.Internal

Methods

vary :: CoGenT m Int64

Vary Integer

Defined in Hedgehog.Function.Internal

Methods

vary :: CoGenT m Integer

Vary Ordering

Defined in Hedgehog.Function.Internal

Methods

vary :: CoGenT m Ordering

Vary Word8

Defined in Hedgehog.Function.Internal

Methods

vary :: CoGenT m Word8

Vary ()

Defined in Hedgehog.Function.Internal

Methods

vary :: CoGenT m ()

Vary Void

Defined in Hedgehog.Function.Internal

Methods

vary :: CoGenT m Void

Vary a => Vary [a]

Defined in Hedgehog.Function.Internal

Methods

vary :: CoGenT m [a]

Vary a => Vary (Maybe a)

Defined in Hedgehog.Function.Internal

Methods

vary :: CoGenT m (Maybe a)

(Vary a, Vary b) => Vary (Either a b)

Defined in Hedgehog.Function.Internal

Methods

vary :: CoGenT m (Either a b)

(Vary a, Vary b) => Vary (a, b)

Defined in Hedgehog.Function.Internal

Methods

vary :: CoGenT m (a, b)

varyIntegral :: Integral a => CoGenT m a

Build a co-generator for an Integral type

newtype CoGenT m a

A CoGenT m a is used to perturb a GenT m b based on the value of the a. This way, the generated function will have a varying (but still deterministic) right hand side.

Co-generators can be built using Divisible and Decidable, but it is recommended to derive Generic and use the default instance of the Vary type class.

CoGenT m ~ Op (Endo (GenT m b))

Constructors

CoGenT

Fields

• applyCoGenT :: forall b. a -> GenT m b -> GenT m b

Instances

Divisible (CoGenT m)

Defined in Hedgehog.Function.Internal

Methods

divide :: (a -> (b, c)) -> CoGenT m b -> CoGenT m c -> CoGenT m a

conquer :: CoGenT m a

Decidable (CoGenT m)

Defined in Hedgehog.Function.Internal

Methods

lose :: (a -> Void) -> CoGenT m a

choose :: (a -> Either b c) -> CoGenT m b -> CoGenT m c -> CoGenT m a

Contravariant (CoGenT m)

Defined in Hedgehog.Function.Internal

Methods

contramap :: (a -> b) -> CoGenT m b -> CoGenT m a

(>$) :: b -> CoGenT m b -> CoGenT m a

type CoGen = CoGenT Identity

apply' :: (a :-> b) -> a -> Maybe b

Evaluate a possibly partial function

unsafeApply :: (a :-> b) -> a -> b

Evaluate a total function. Unsafe.

data Fn a b

The type of randomly-generated functions

Constructors

Fn b (a :-> Tree (MaybeT Identity) b)

Instances

(Show a, Show b) => Show (Fn a b)

Defined in Hedgehog.Function.Internal

Methods

showsPrec :: Int -> Fn a b -> ShowS

show :: Fn a b -> String

showList :: [Fn a b] -> ShowS

unsafeFromTree :: Functor m => Tree (MaybeT m) a -> m a

Extract the root value from a Tree. Unsafe.

shrinkFn :: (b -> [b]) -> (a :-> b) -> [a :-> b]

Shrink the function

shrinkTree :: Monad m => Tree (MaybeT m) a -> m [Tree (MaybeT m) a]

apply :: Fn a b -> a -> b

Evaluate an Fn

fnWith :: Arg a => CoGen a -> Gen b -> Gen (Fn a b)

Generate a function using the user-supplied co-generator

fn :: (Arg a, Vary a) => Gen b -> Gen (Fn a b)

Generate a function

forAllFn :: (Show a, Show b, Monad m) => Gen (Fn a b) -> PropertyT m (a -> b)

Run the function generator to retrieve a function

via :: Arg b => (a -> b) -> (b -> a) -> (a -> c) -> a :-> c

Reify a function via an isomorphism.

If your function's domain has no instance of Generic then you can still reify it using an isomorphism to a better domain type. For example, the Arg instance for Integral uses an isomorphism from Integral a => a to (Bool, [Bool]), where the first element is the sign, and the second element is the bit-string.

Note: via f g will only be well-behaved if g . f = id and f . g = id

gvia :: GArg b => (a -> b x) -> (b x -> a) -> (a -> c) -> a :-> c

buildIntegral :: (Arg a, Integral a) => (a -> c) -> a :-> c

Reify a function on Integrals