# Algebraic Data Types

We've used algebraic data types throughout Creative Scala, but we've been a bit informal in how we describe them. At this stage a bit more rigour is useful.

An algebraic data type is built from two components: - logical ors; and - logical ands.

The List data type is a great example of an algebraic data type, as it uses both patterns. A List is Nil or a pair (the logical or pattern) and a pair has a head and a tail (the logical and pattern). Point is another example. A Point is either Cartesian or Polar. A Cartesian has an x and y coordinate, while a Polar has a radius and an angle. Note it's not necessary to use both patterns to be an algebraic data type.

Being functional programmers we naturally have some fancy words for the logical or and logical and patterns. They are: - a sum type for the logical or; and - a product type for the logical and.

The concept of an algebraic data type is not specific to Scala. Let's get some practice working with the concept before we see how to write algebraic data types in Scala.

#### Exercises {-}

##### Path Elements {-}

The PathElement type, used to construct paths, is a simple algebraic data type. You've used PathElement quite a bit so far. How do you think PathElement is defined in terms of sum and product types?

<div class="solution"> A PathElement is a sum type, as it is: - a MoveTo; or - a LineTo; or - a CurveTo.

A MoveTo is a product type that holds a single point (where to move to).

A LineTo is a product type that holds a single point (the end point of the line).

A CurveTo is a product type that holds three points: two control points and the end point of the line. </div>

##### Totally Turtles {-}

The Instruction type we used to control the turtle is also an algebraic data type. How do you think Instruction is defined?

<div class="solution"> An Instruction is: - a Forward; or - a Turn; or - a Branch; or - a NoOp

Therefore Instruction is a sum type. Forward, Turn, and Branch are all product types.

A Forward holds a distance, which is a Double.

A Turn holds an angle, which is an Angle.

A Branch holds a List[Instruction]---therefore the Instruction type is defined in terms of itself, just like List.

A NoOp holds no data. </div>

### Defining Algebraic Data Types

No we understand how to model data with algebraic data types, let's see how to define our own.

The pattern is this:

• If A is a B or C write
sealed abstract class A extends Product with Serializable
final case class B() extends A
final case class C() extends A

There is a lot boilerplate here, which we can basically ignore beyond accepting it's stuff we have to write. However, if you're interested in what it means (and possibly have some prior object-oriented programming experience).

<div class="info-warning"> Describe sealed etc. here. </div>

To define PathElement we might start with

sealed abstract class PathElement extends Product with Serializable
final case class MoveTo() extends PathElement
final case class LineTo() extends PathElement
final case class CurveTo() extends PathElement

The other half of the pattern is

• If A has a B and C, write
final case class A(b: B, c: C)

<div class="info-warning"> Describe constructor parameters here. </div>

Returning to PathElement, MoveTo and LineTo each have a point (the destination) and CurveTo has a destination point and two control points. So we could write.

sealed abstract class PathElement extends Product with Serializable
final case class MoveTo(to: Point) extends PathElement
final case class LineTo(to: Point) extends PathElement
final case class CurveTo(cp1: Point, cp2: Point, to: Point) extends PathElement

And this is essentially how PathElement is defined in Doodle.

#### Exercise {-}

Define your own algebraic data type to represent Instruction.

<div class="solution"> We can directly turn the textual description into code using the patterns above.

sealed abstract class Instruction extends Product with Serializable
final case class Forward(distance: Double) extends Instruction
final case class Turn(angle: Angle) extends Instruction
final case class Branch(instructions: List[Instruction]) extends Instruction
final case class NoOp() extends Instruction

</div>