[Haskell-tut] Custom Data Types

[wtd]

Introduction

Eventually everyone wants to know how to create their own composite data types. Java/C#/Ruby/C++/etc. prpogrammers create classes. C programmers create structs. Turing programmers create records. It's natural to want to group related bits of data together and give a name to that basic data form.

Learning by Example

In a recent debate with rizzix, I used the example of a Name data type. It's one I frequently use, so I thought I'd use it again here, and perhaps explain its construction in greater detail.

Declaration and Constructors

We start out by declaring the type.

code:

data Name = ...

The keyword data tells the compiler that we're introducing a new data type. In this case that type is called "Name". The ellipsis stands in for constructors which wil take any number of arguments and in excange give us a Name. These constructors may have any name (including the name of the type), as long they all have unique names.

Starting simply, let's have a single constructor which takes a single argument, giving us a Name that consists of a single String.

code:

data Name = Name1 String

The 1 in the constructor's name denotes that we're only storing one name. Now, with that done, let's add two more constructors. The first of these will handle a Name with both first and last names, and the second will handle the possibility of no name at all.

code:

data Name = Name1 String | Name2 String String | NoName

This last constructor is known as a unary constructor, since it takes no arguments.

Pattern Matching

You should note that in the constructor declarations I didn't give the arguments names, but rather simply specified their types. The reasoning behind this is clear as we see pattern matching in action.

Let's say I want to get the last name from a Name. How do I do that? How can I tell if a Name is a Name1, Name2 or NoName? The answer is simple. Aside from simply saying that a function has an argument, and that argument is of a given type, we can very specifically overload the function to only match one form of that data type.

First we declare a function "lastName" as taking a Name and returning a String.

code:

lastName :: Name -> String

Now we define the function.

code:

lastName (Name2 first last) = last

The "first" and "last" here are patterns which stand in for the two String arguments lassed to Name2 originally. We can then use these names in the function body.

In fact, a bit more on pattern matching: we never cared about the value of the individual's first name, so instead of giving that a name, we can use an underscore to indicate that we don't care about its value.

code:

lastName (Name2 _ last) = last

We can use the same type of pattern matching to get a first name. Let's say this time, though, that we want to define the function for the Name1 formof the Name type as well.

code:

firstName :: Name -> String firstName (Name1 first) = first firstName (Name2 first _) = first

The Case Expression

It's important to note that this kind of pattern matching is also how Haskell's case expression works.

We could have written firstName as follows.

code:

firstName :: Name -> String firstName name =   case name of     Name1 first -> first     Name2 first _ -> first

Robustness

Of course, this isn't very robust. There's no definition of lastName for Name1 or NoName, and firstName isn't defined for NoName. Obviously, this is because those forms of Name don't have the data we're trying to extra.

Haskell has a data type we can use for this, and seeing it will give you further idea of how data types can be used.

The Maybe type is a generic type which is either Just a value, or Nothing. It's declared like so:

code:

data Maybe a = Just a | Nothing

With it we can declare firstName and lastName as:

code:

firstName :: Name -> Maybe String lastName :: Name -> Maybe String

We can thend efine the functions as:

code:

firstName (Name1 first) = Just first firstName (Name2 first _) = Just first firstName NoName = Nothing lastName (Name1 _) = Nothing lastName (Name2 _ last) = Just last lastName NoName = Nothing

We can now use pattern matching on these values.

code:

let bob = Name1 "Bob" in    case lastName bob of       Just name -> print name       Nothing -> print "No last name."

Polymorphism

Let's take a simple example. We want a function which will converta Name into a suitable String for output. In Haskell we normally use the show function to do just this. Getting show (and functions which rely on it) to accept a Name is a matter of polymorphism.

Polymorphism in Haskell involves classes, as it does in so many languages. However, Haskell's notion of classes is a bit different from what Java programmers, for instance, normally think of. Instead it is more closely related to that language's idea of interfaces or abstract classes.

A class in Haskell is simply a function or set of functions which must be defined for a data type in order for that data type to belong to that class. A data type which does belong to that class is said to be an instance of it. The show function is required to be defined for something to be an instance of the Show class.

The Show class' declaration looks something like:

code:

class Show a where    show :: a -> String

The "a" stands in as a generic type which can represent any type. We specify that type when we declare our Name type to be an instance of Show.

code:

instance Show Name where    show (Name1 first) = first    show (Name2 first last) = first ++ " " ++ last    show NoName = "no name"

Classes are later used to constrain genericity. For instance, the print function is a generic function which takes any type, so long as it's an instance of the Show class. Its declaration is:

code:

print :: (Show a) => a -> IO ()

Deriving

Similarly, we can check for equality between names by making Name an instance of the Eq class. This class is interesting because it declares two functions: the == and /= operators, but it provides a default definition for the /= operator.

code:

class Eq a where    (==) :: a -> a -> Bool    (/=) :: a -> a -> Bool    m /= n = not (m == n)

Consequently, we need only define the == operator for Name.

code:

instance Eq Name where    Name1 n1 == Name1 n2 = n1 == n2    Name2 f1 l1 == Name2 f2 l2 = f1 == f2 && l1 == l2    NoName == NoName = True

Of course, we'd have to write several definitions to cover the various combinations. For a relatively simple comparison like this, it becomes quite useful to use the deriving keyword which automatically creates definitions required by basic classes like Eq.

Using deriving is done when the data type is declared.

code:

data Name = Name1 String | Name2 String String | NoName    deriving (Eq)

Of course, for finer grained control, you should write the code yourself. For instance, the default behavior of deriving the Ord class, which involves comparisons, won't give us the ability to compare based on last name first.

code:

instance Ord Name where    compare (Name1 f1) (Name1 f2) =       compare f1 f2    compare (Name1 f1) Name2 f2 _) =       compare f1 f2    compare (Name2 f1 l1) (Name1 f2) =       compare f1 f2    compare (Name2 f1 l1) (Name2 f2 l2) =       if l1 == l2          then compare f1 f2          else compare l1 l2    compare NoName NoName = EQ    compare _ NoName = GT    compare NoName _ = LT

Polymorphism with a Custom Class

Of course, nothing limits us to classes included in the standard library. Let's define a new data type which incorporates a Name. We then have two new functions to get the first and last names.

code:

type Age = Int data Person = Person Name Age    deriving (Eq) personFirstName :: Person -> Maybe String personFirstName (Person name _) = firstName name personLastName (Person name _) = lastName name

Of course, it's silly to introduce two new functions rather than reusing the firstName and lastName functions. To do this we'll have to create a HasName class for these two functions.

code:

class HasName a where    firstName :: a -> Maybe String    lastName :: a -> Maybe String

We can then make Name and Person both instances of HasName.

code:

instance HasName Name where    firstName (Name1 first) = Just first    firstName (Name2 first _) = Just first    firstName NoName = Nothing    lastName (Name1 _) = Nothing    lastName (Name2 _ last) = Just last    lastName NoName = Nothing instance HasName Person where    firstName (Person name _) = firstName name    lastName (Person name _) = lastName name

Further Details

If further details on this subject are desired, please let me know.