examples would be helpful

[cad0p]

Hi, could you provide us a simple example of how to use your tests to test if a functor instance is ok?

Thanks

example below

class Functor f where
  fmap :: (a -> b) -> f a -> f b

data Tree a = Leaf a | Node (Tree a) (Tree a)
  deriving Show

{-|
  Example: 
  >fmap (+1) ( Node (Leaf 1) (Leaf 2) )
-}
instance Functor Tree where
  fmap f (Leaf a) = Leaf (f a)
  fmap f (Node a b) = Node (fmap f a) (fmap f b)

[nbloomf]

Hi! Thank you for asking; this does need more documentation.

You can see some examples in action in the test module for this package here: https://github.com/nbloomf/tasty-quickcheck-laws/blob/master/test/Main.hs (However that's not necessarily much more helpful.)

The most straightforward way to test a Functor instance is with the testFunctorLaws function, the signature of which is here: https://hackage.haskell.org/package/tasty-quickcheck-laws-0.0.3/docs/Test-Tasty-QuickCheck-Laws-Functor.html

Note that it takes a bunch of Proxy arguments; these are only needed to fix the types. (If I were writing this today I'd probably use TypeApplications instead.) The types to fix are:

1. the functor constructor being tested, in this case Tree
2. the "equality context", which is not relevant here so we can just use ()
3. arbitrary value types, which are used to generate the test data

We also pass in an equality test with type forall u. Eq u => t -> f u -> f u -> Bool. For most types this is basically ==, but checking equality is a little more complicated for some instances (like Reader).

For example, the composite law for functors asserts that given any functions f :: a -> b and g :: b -> c and any value x :: a, fmap (g . f) x is "equal to" (fmap g . fmap f) x. This a, b, and c are the value types fixed by proxies.

I haven't checked this in ghc to be sure, but I think your Tree functor instance type can be tested with something like this:

testFunctorLaws (Proxy :: Proxy Tree) (Proxy :: Proxy ()) (Proxy :: Proxy Bool) (Proxy :: Proxy Int) (Proxy :: Proxy Char) (const (==))

Of course you can replace Bool, Int, and Char with other types. You'll also need an Arbitrary instance for f a and a Typeable instance for f, which can be derived.

The testFunctorLawsN functions (for N = 1,2,3) are shortcuts for calling testFunctorLaws against all possible combinations of three value types taken from a set of 1, 2, or 3 respectively.

[nbloomf]

I should also mention that this integrates with a testing library called tasty. A minimal complete example looks more like this:

module Tree

import Test.Tasty
import Test.Tasty.QuickCheck.Laws
import Test.QuickCheck
import Data.Typeable

tests :: IO ()
tests = defaultMain $ testGroup "Laws"
  [ testFunctorLaws
    (Proxy :: Proxy Tree) (Proxy :: Proxy ())
    (Proxy :: Proxy Bool) (Proxy :: Proxy Int) (Proxy :: Proxy Char)
    (const (==))
  ]

data Tree a = Leaf a | Node (Tree a) (Tree a)
  deriving (Eq, Show, Typeable)

instance Functor Tree where
  fmap f (Leaf a) = Leaf (f a)
  fmap f (Node a b) = Node (fmap f a) (fmap f b)

instance (Arbitrary a) => Arbitrary (Tree a) where
  arbitrary = ...

[cad0p]

Hi @nbloomf , thanks the info!

Unfortunately, I am having this issue here:

No instance for (GHC.Base.Functor Tree)
        arising from a use of ‘testFunctorLaws’
    • In the expression:
        testFunctorLaws
          (Proxy :: Proxy Tree) (Proxy :: Proxy ()) (Proxy :: Proxy Bool)
          (Proxy :: Proxy Int) (Proxy :: Proxy Char) (const (==))

[nbloomf]

Hm; that error message tells me that the expected Functor instance for Tree is not in scope. I can think of two things that might cause that.

1. If the Functor instance is defined in another module, but not imported in the module where testFunctorLaws is being used, then we'd see an error like this. The remedy for that is to add a line like import Module.Containing.Functor.Instance to the module where testFunctorLaws is used, so as to bring that instance in scope at the call site.
2. I notice that in the original example code there is a definition for a class called Functor. If this is in your code then I would also expect an error like this. The fact that GHC.Base.Functor is fully qualified in the error message is relevant here; GHC usually only does that when the same name appears in different modules and needs to be disambiguated. If you have a local Functor class, then this will not match the built in GHC.Base.Functor class definition (which is the one expected by testFunctorLaws) even though it has the same methods, but it will silently make the local instance declaration refer to the local Functor class and not to GHC.Base.Functor. In this case the remedy is to delete the local Functor class definition (the instance declaration for Tree should be fine as is).

If neither of those fixes the error, I'd need to see the whole module (or better yet a minimal version that gives the same error) to give more precise advice.

[cad0p]

Thank you, it was exactly what you wrote here!