Hello! Today, we will explore functional programming with the concepts of functors, applicatives, and monads. We will discuss what they are and why they matter one step at a time. Note that all the examples will be in Haskell, but you’re not required to know Haskell to read this post. I’ve also added a section at the end following a pretty disappointing interaction with someone associated with the Haskell foundation. Functors: A box can be any data structure surrounded by a context. Said differently, a wrapper or container type that adds additional information or behavior to the underlying data. In this example, we will say that blue boxes represent the possibility of an optional value, which in Haskell is denoted by the Maybe type. But, this concept exists in many languages: Rust with Option, Go with sql.NullString, Java with Optional, etc. Yet, Other types of boxes also exist. For example: A box representing that the wrapped value can be either from one type or another. For example, in Haskell, Either to represent a value that is either Left or Right, or in Rust, Result to represent either a success or an error. More generally, most classic data structures we can think of such as lists, maps, trees, or even strings. Those data structures can contain zero, one, or multiple values inside. For example, a string can be composed of zero, one, or multiple characters. We already know how to apply a function to a simple value; for example, applying a function that adds one to a given int. But what if we want to apply the same function to a value inside a box? We could open the box, extract the value out of it, apply the function, and put the result back in a box. Yet, in Haskell, we can use fmap to apply a function to a box directly; no need to perform all the steps ourselves. fmap is used to apply a transformation function, here (+1), to the value inside a box and put the result inside another box. In this example, the box itself is called a functor. A functor is an abstraction that allows for mapping a function over values inside a context without altering the context of the functor. Not altering the context is crucial; a functor is not similar to the box in Schrödinger’s experiment. In quantum physics, opening a box alters the state of what’s inside. Here, this is not the case: the box with the value 42 remains identical. Examine the Haskell code for this example: fmapEx :: Maybe Int -- A function returning a Maybe Int fmapEx = fmap (+ 1) (Just 42) -- Result: Just 43 If you’re unfamiliar with Haskell, let’s spend 30 seconds on this snippet. The first line defines the signature of fmapEx, a function that takes no input and produces a Maybe Int output. The second line represents the core logic of
