In every single Haskell guide I've been through, the term Algebraic Data Types is mentioned at least once. In most cases, the text simply moved on to how types are defined and used. A small minority actually tries to explain why Haskell's data types are called `Algebraic`. An even smaller minority succeeded in getting the point across. Here's me documenting what I've learned so far about them. Hopefully it'd be of some help for future Haskell learners.

### Some background first

`Bool` is one of the simplest data type in Haskell. Its defined as:

``````data Bool = True | False
``````

So when we say an expression is of type `Bool`, what values can it possibly evaluate to? It'd be either `True` or `False`. Correct? 2 possible values.

Here's a quick home-made definition of a type `Weekday`:

``````data Weekday = Monday    |
Tuesday   |
Wednesday |
Thursday  |
Friday    |
Saturday  |
Sunday
``````

Now, if we say that an expression is of type `Weekday`, what are the possible values here. Any of the days we defined would be correct. That gives us 7 possible values whose type would be `Weekday`.

Let's associate (in our minds) types with the number of values possible. So `Bool` is a 2. And `Weekday` is a 7. Similarly, if we check the max and min bounds of `Int`, we can put `Int` to `2 ^ 64` (because that many values are possible with `Int` data type).

This is something to keep in mind going forward. A data type can be associated to a number based on how many values an expression of that type can possibly evaluate to. Also, it is totally legit for a type to have infinite possible values (think `String`).

### Sum

Now we can get to the Algebra part. Here's the all-too-familiar definition of `Maybe`.

``````data Maybe a = Just a | Nothing
--   Maybe a =   a    +   1
``````

Ignore the comment in the second line for now.

What are the possible values of `Maybe a`? That's an absurd question unless we know what `a` is.

Let's do it again. If an expression has type, say, `Maybe Bool`, what values can it have? `Just True`, `Just False` and `Nothing`. 3 values in total. That's 2 boolean values plus 1 new `Nothing` value.

If a variable has type `Maybe Weekday`, the possible values are:

• Just Monday
• Just Tuesday
• Just Wednesday
• Just Thursday
• Just Friday
• Just Saturday
• Just Sunday
• Nothing

So that's 7 `Weekday` values plus 1 `Nothing`. Now check out the comment in the code snippet above again and see if it makes some sense.

The `|` operator in type definitions is acting like `+`. Data constructors which do not take any types (like `Nothing`) act as constants and represent a value in themselves. Let's see one more example of this to cement this insight.

``````data Either a b = Left a | Right b
--   Either a b =    a   +   b
``````

The possible values corresponding to type `Either Bool Weekday` are:

• Left True
• Left False
• Right Monday
• Right Tuesday
• Right Wednesday
• Right Thursday
• Right Friday
• Right Saturday
• Right Sunday

That's 2 + 7 = 9 possible values in total.

### Product

Like the sum, data types can also be defined as products of other data types. Here's a quick example using a custom data type.

``````data Tuple a b = Tuple a b
``````

Let's apply some concrete type to both `a` and `b` and see what values are possible.

For `Tuple Bool Bool`, we have the following possible values:

• Tuple True False
• Tuple True True
• Tuple False False
• Tuple False True

That's 2 * 2 = 4 values.

For `Tuple Bool Weekday`, the possible values are:

• Tuple True Monday
• Tuple True Tuesday
• Tuple True Wednesday
• Tuple True Thursday
• Tuple True Friday
• Tuple True Saturday
• Tuple True Sunday
• Tuple False Monday
• Tuple False Tuesday
• Tuple False Wednesday
• Tuple False Thursday
• Tuple False Friday
• Tuple False Saturday
• Tuple False Sunday

That's 2 * 7 = 14 values.

While `|` acts like sum, specifying data types as composites is similarly equivalent to multiplication. `Tuple Weekday Weekday` will give 49 possible values. Because `Weekday * Weekday` or `7 * 7`.

### Data types follow algebraic laws

We can check this real quick by seeing how they follow distribution. For a refresher, distributive law is defined as

``````a * (b + c) == (a * b) + (a * c)
``````

Let's see if we can prove that this law holds for data types. Left side of equation first. We need a data type which corresponds to `a * (b + c)`. We already know from above that `Either b c` is equivalent to `b + c`. To multiply it with `a`, we put that in a composite data type as follows.

``````data DLeft a b c = DLeft a (Either b c)
--   DLeft a b c =       a * (b + c)
``````

Next, we'll construct a data type which corresponds to right side of equation.

``````data DRight a b c = DRLeft a b | DRRight a c
--   DRight a b c =   (a * b)  +  (a * c)
``````

All that's left is to see if those two give the same number of possible values. Let's put `a = Bool`, `b = Bool` and `c = Weekday`.

`DLeft Bool Bool Weekday` will have the following values:

• DLeft True (Left True)
• DLeft True (Left False)
• DLeft True (Left Sunday)
• DLeft True (Right Monday)
• DLeft True (Right Tuesday)
• DLeft True (Right Wednesday)
• DLeft True (Right Thursday)
• DLeft True (Right Friday)
• DLeft True (Right Saturday)
• DLeft True (Right Sunday)
• DLeft False (Left True)
• DLeft False (Left False)
• DLeft False (Right Sunday)
• DLeft False (Right Monday)
• DLeft False (Right Tuesday)
• DLeft False (Right Wednesday)
• DLeft False (Right Thursday)
• DLeft False (Right Friday)
• DLeft False (Right Saturday)
• DLeft False (Right Sunday)

Which are be `Bool * (Bool + Weekday)` or `2 * (2 + 7)` = 18 values in total.

Let's see if the `DRight Bool Bool Weekday` offers the same number of values.

• DRLeft False False
• DRLeft False True
• DRLeft True False
• DRLeft True True
• DRRight False Monday
• DRRight False Tuesday
• DRRight False Wednesday
• DRRight False Thursday
• DRRight False Friday
• DRRight False Saturday
• DRRight False Sunday
• DRRight False Monday
• DRRight True Tuesday
• DRRight True Wednesday
• DRRight True Thursday
• DRRight True Friday
• DRRight True Saturday
• DRRight True Sunday

That's `(Bool * Bool) + (Bool * Weekday)` or `(2 * 2) + (2 * 7)` = 18 values.

Hence Proved! I always loved writing this :)

### Exponents

Sum and product aren't the only operations out there. One of the most common data types in Haskell is actually exponential. We know them as `(->)` or more generally as functions.
This is a lot bigger topic but I will quickly list out how to visualise them.

For our example, we'll use a simple function of type `Weekday -> Bool`. How many ways are possible to write a function of that type while being total (not skipping any Weekdays).

• myFunc Monday = True
• myFunc Tuesday = True
• myFunc Wednesday = True
• myFunc Thursday = True
• myFunc Friday = True
• myFunc Saturday = True
• myFunc Sunday = True

Note that above is just one possible definition of such a function, not 7. This function can now take a Weekday (any one of them) and return a Bool. It may have been better to write it in short like `myFunc _ = True`.
We're talking about how many ways a function can be defined, instead of the number of possible values in previous operations.
If we change any of the `True` in above definition to `False`, it's a whole new function. What if we change a couple of `True` above to `False`? That's yet another function. Writing all that will make this the longest post ever.
So I'm gonna believe in reader and leave them to write all the possible definitions. In the end, the number of ways a similarly trivial function from `Weekday -> Bool` can be defined is 128 which is `2 ^ 7` or `Bool ^ Weekday`.

To formalise it, a function `a -> b` corresponds to algebraic operation `b ^ a`.

### Conclusion

I wrote this post for a select species of programmers who like to know what they're playing with with usability of that knowledge being non-consequential. I think that in general course of things, all the text above is not super handy and will probably not help someone write that awesome web server or parser. So, sincere apologies if I wasted your time.

For a fuller discussion on the algebra of data types, including recursive types, there's a great series of posts here.

I'll appreciate any and all feedback. Use this reddit thread. Thanks for reading!