Hedgehog.Function

The general procedure for generating functions of type A -> B looks something like this:

{-# language DeriveGeneric #-}
{-# language TypeApplications #-}

import Hedgehog
import Hedgehog.Function

data A = ...
  deriving (Generic, ...)

instance Arg A
instance Vary A

genB :: MonadGen m => m B
genB = ...

prop_test :: Property
prop_test =
  property $ do
    f <- forAllFn $ fn @A genB
    ...

Here's an example of how to use the library to test the "fmap composition" law.

ScopedTypeVariables and TypeApplications are recommended for ease of use. RankNTypes is only necessary for this example.

{-# language RankNTypes #-}
{-# language ScopedTypeVariables, TypeApplications #-}

import Hedgehog
import Hedgehog.Function
import qualified Hedgehog.Gen as Gen
import qualified Hedgehog.Range as Range

map_compose
  :: forall f a b c
   . ( Functor f
     , Show (f a)
     , Show a, Arg a, Vary a
     , Show b, Arg b, Vary b
     , Show c
     , Eq (f c)
     , Show (f c)
     )
  => (forall x. Gen x -> Gen (f x))
  -> Gen a
  -> Gen b
  -> Gen c
  -> Property
map_compose genF genA genB genC =
  property $ do
    g <- forAllFn $ fn @a genB
    f <- forAllFn $ fn @b genC
    xs <- forAll $ genF genA
    fmap (f . g) xs === fmap f (fmap g xs)

prop_map_list :: Property
prop_map_list =
  map_compose
    (Gen.list (Range.constant 0 100))
    Gen.bool
    Gen.bool
    Gen.bool

Documentation

module GHC.Generics

data Fn a b

The type of randomly-generated functions

Instances

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

Methods

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

show :: Fn a b -> String

showList :: [Fn a b] -> ShowS

Generation

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

Run the function generator to retrieve a function

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

Evaluate an Fn

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

Generate a function

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

Generate a function using the user-supplied co-generator

Building

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

Reify a function whose domain has an instance of Generic

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

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

Reify a function on Integrals

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

Methods

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

Arg Int

Methods

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

Arg Int8

Methods

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

Arg Int16

Methods

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

Arg Int32

Methods

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

Arg Int64

Methods

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

Arg Integer

Methods

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

Arg Ordering

Methods

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

Arg ()

Methods

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

Arg Void

Methods

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

Arg a => Arg [a]

Methods

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

Arg a => Arg (Maybe a)

Methods

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

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

Methods

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

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

Methods

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

Varying

module Data.Functor.Contravariant

module Data.Functor.Contravariant.Divisible

data 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))

Instances

Divisible (CoGenT m)

Methods

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

conquer :: CoGenT m a

Decidable (CoGenT m)

Methods

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

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

Contravariant (CoGenT m)

Methods

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

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

type CoGen = CoGenT Identity

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

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

varyIntegral :: Integral a => CoGenT m a

Build a co-generator for an Integral type

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

Methods

vary :: CoGenT m Bool

Vary Int

Methods

vary :: CoGenT m Int

Vary Int8

Methods

vary :: CoGenT m Int8

Vary Int16

Methods

vary :: CoGenT m Int16

Vary Int32

Methods

vary :: CoGenT m Int32

Vary Int64

Methods

vary :: CoGenT m Int64

Vary Integer

Methods

vary :: CoGenT m Integer

Vary Ordering

Methods

vary :: CoGenT m Ordering

Vary Word8

Methods

vary :: CoGenT m Word8

Vary ()

Methods

vary :: CoGenT m ()

Vary Void

Methods

vary :: CoGenT m Void

Vary a => Vary [a]

Methods

vary :: CoGenT m [a]

Vary a => Vary (Maybe a)

Methods

vary :: CoGenT m (Maybe a)

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

Methods

vary :: CoGenT m (Either a b)

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

Methods

vary :: CoGenT m (a, b)