# Functional Structures

Monads are one of the most feared topics for beginners coming to Haskell. But like most programming concepts, they’re not nearly as scary once you actually understand what they are. There are numerous tutorials out there and just as many definitions of what a monad really is and how to explain it to people. This series is Monday Morning Haskell’s attempt to alleviate this sore spot for those just getting into Haskell. We’ll work our way up from the basics, starting with functors and applicative functors to get an intuition for how abstract structures work in Haskell. Then we’ll tackle monads and look at some of the most common ones.

## Part 1: Functors

In part 1, we’ll learn all about functors. These are the simplest Haskell structure to learn about. They are very intuitive, and their typeclass has only a single function. This will help us start building an understanding of abstract structures with a simple example.

## Part 2: Applicative Functors

In part 2, we tackle applicative functors. Applicatives are a little more difficult to understand than functors, but their functionality can still be summed up in a couple simple functions.

In part 3, we finally approach the topics of monads. Now that we have an intuition for how abstract structures work, we’ll examine some of the problems that applicative functors and functors DON’T help us solve. Then we’ll get into the specifics of how we actually use monads.

Our introduction to monads examined the built in types that have a monadic structure. It had a focus on those things that we’ve seen in action, but maybe never thought of monadically. In part 4, we start exploring some of the common monadic idioms that you’ll need outside of the basics. We’ll examine the `Reader` monad, which gives us a global readable state, and the `Writer` monad, which allows us to keep a running value throughout our computations.

Part 5 picks up where part 4 left off, and introduces the `State` monad. This monad allows us to keep a particular type that we can both read from and write to. It opens the door to fully stateful programming, allowing us to do many of the things Haskell supposedely “can’t” do.