# Chapter 16. Advanced Functional Programming

Let’s return to functional programming and discuss some advanced concepts. You can skip this chapter if you’re a beginner, but come back to it if you hear people using terms like *Algebraic Data Types*, *Category Theory*, and *Monads*.

The goal here is to give you a sense of what these concepts are and why they are useful without getting bogged down into too much theory and notation.

# Algebraic Data Types

There are two common uses of the “ADT” acronym, *abstract data types* and *algebraic data types*, which is confusing. The former meaning is common in the object-oriented programming world. It includes our familiar friends like `Seq`

, an abstraction for any of the sequential collections. In contrast, *algebraic data types* comes from the functional programming world. It may be less familiar, but it’s equally important.

The term *algebraic data type* arises because the kinds of data types we’ll discuss obey *algebraic*, i.e., mathematical properties. This is important because if we can prove properties about our types, it raises our confidence that they are bug-free and it promotes safe composition to create more complex data structures and algorithms.

## Sum Types Versus Product Types

Scala types divide into *sum types* and *product types*.

Most of the classes you know are product types. When you define a `case class`

, for example, how many unique instances can you have? Consider this simple example:

`case`

`class`

`Person`

`(`

`name`

`:`

`Name`

`,`

`age`

`:`

`Age`

`)`

You can have as many ...

Get *Programming Scala, 2nd Edition* now with O’Reilly online learning.

O’Reilly members experience live online training, plus books, videos, and digital content from 200+ publishers.