This file provides a generic implementation for counting how many times a data constructor appears in a value. We use two different type classes in order to achieve this, called Countable (for types of kind *) and Countable1 (for types of kind (* -> *)).

class Countable (a :: *) where
    count :: a -> ConsMap

class Countable1 (f :: * -> *) where
    count1 :: f a -> ConsMap

Let us suppose we have the following type definition:

data Tree = Leaf | Node Tree Tree

if we want to count how many times each type constructor appears within a given value of type Tree, we need to add the following instance derivations:

deriving instance Generic Tree
instance Countable Tree

Then, we can count type constructors over values of type Tree:

count (Node (Node Leaf Leaf) (Node Leaf Leaf))
==> fromList [("Leaf",4),("Node",3)]

Note that, if the Tree data type definition is available, the `deriving instance Generic Tree` could be avoided by including Generic at the type definition deriving clause:

data Tree = Leaf | Node Tree Tree deriving Generic

Countable requires every subtype of a Countable data type to be also Countable in order to work. If we modify our Tree definition as

data GTree a = GLeaf | GNode GTree a GTree

then is necessary to add the following instance derivations:

instance deriving Generic a => Generic (GTree a)
instance (Generic a, Countable a) => Countable (GTree a)

and the Generic and Countable derivations for whatever a we want to use. For example, let a be Bool (Bool already has a Generic instance):

instance Countable Bool

then we can count type constructors on values of type `GTree Bool`

count (GNode (GNode GLeaf False GLeaf) True (GNode GLeaf True GLeaf))
==> fromList [("False",1),("GLeaf",4),("GNode",3),("True",2)]

but what if we are just interested in counting GLeaf and GNode type constructors within values of type `GTree a`? Using Countable type class would require to provide (or derive) proper Generic and Countable instances for whatever type we instantiate a with. Fortunately, we can define a new type class, Countable1, for types of kind (* -> *) that does not count type constructors further than the outter data type. Later, we derive a Countable1 instance for GTree.

instance Countable1 GTree

count1 (GNode (GNode GLeaf 1 GLeaf) 2 (GNode GLeaf 3 GLeaf))
==> fromList [("GLeaf",4),("GNode",3)]

count1 (GNode (GNode GLeaf "a" GLeaf) "b" (GNode GLeaf "c" GLeaf))
==> fromList [("GLeaf",4),("GNode",3)]