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