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)

Defined in Hedgehog.Function.Internal

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

Minimal complete definition

Nothing

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

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

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

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

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.

Minimal complete definition

Nothing

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)