Question

I would like to define data types hierarchically, such as:

data Cat = BigCat | SmallCat
data Animal = Cat | Dog

And then write a function that will take Animals as arguments, and write it with pattern matching like this:

bigger::Animal -> Animal -> Bool
bigger SmallCat BigCat = False
bigger BigCat SmallCat = True
bigger Dog Cat = True
bigger Cat Dog = False

The compiler complains. It doesn’t want to match the type Animal explicitely written in the function signature against the type Cat in the first and second lines of pattern matching. Why won’t haskell admit that a big cat or small cat is an animal?

Answer 1

You mix up types with their constructors. A type is something of which you can create variables. A type constructor is what you use to create such data. In you code, data Animal = Cat | Dog declares a type Animal with the two constructors Cat and Dog. In the other line, you define a datatype Cat. This is no problem since types and constructors don’t share the same namespace.

If you want to have an object of type Cat embedded in your Animal (if the constructor Cat is used), you can add a field to the constructor:

data Animal = Cat Cat | Dog

This means: “Animal is a type that has two constructors, Cat and Dog. Cat has a field of type Cat and Dog has none.” If you want to create objects with the constructor Cat, you have to pass an object of type Cat to it:

myCat = Cat BigCat

If you want to match on an Animal, you have to list all fields of the matched constructor. Compare a corrected version of your code:

data Cat = BigCat | SmallCat
data Animal = Cat Cat | Dog

bigger :: Animal -> Animal -> Bool
bigger (Cat SmallCat) (Cat BigCat)   = False
bigger (Cat BigCat)   (Cat SmallCat) = True
bigger Dog            (Cat _)        = True
bigger (Cat _)         Dog           = False

The _ denotes a don’t care – regardless of the object passed, this will always match.