Monads, functors, and applicatives are three common concepts in functional programming that help you deal with effects, transformations, and compositions of functions. But how do you choose which one to use in your projects? In this article, you'll learn the basics of these concepts, how they differ, and when to use them in your code.
Monads, functors, and applicatives are all examples of abstractions that let you work with functions in a generic and consistent way. They are based on mathematical concepts, but you don't need to know the details to use them in your code. The main idea is that they allow you to apply functions to values that are wrapped or contained in some context, such as a list, an option, or a future. For example, you can map a function over a list of numbers, or bind a function to an option value.
Contrary to the first paragraph's content, you can't learn this from this (original content). You need code examples to see this beauty. The actual code examples don't need to be long - because Monads often make the code shorter. But, the examples depend on language & core/standard library, and on understanding of that language and its ecosystem (the library involved). For example, Rust's Option struct is a Monad, but unless you know it and have seen non-Monad usage of it (ugly), you can't appreciate the beauty of Monads. Hence, if this article stays language-independent, it can't introduce anyone to anything. It can only confirm what people already know. Which is sweet, but a waste of time, unfortunately.
A monad is just a monoid in the category of endofunctors, what's the problem? ?? In all seriousness, you’ll know you need functional programming concepts when your code becomes a mess of list iteration and conditional branching. Only after encountering this problem, should you look for tools which help solve it such as a monad. In my experience, trying to understand the tool before encountering the problem leads to unnecessary headache. Additionally, monads are often implemented into a library and the implementation can be irrelevant to solving your problem.
The main difference between monads, functors, and applicatives is the way they handle function application and composition. Functors are the simplest abstraction, and they let you apply a function to a value in a context, using a method called map. For example, you can map a function that adds one to a list of numbers, and get a new list of numbers. Applicatives are a bit more powerful, and they let you apply a function that is also in a context to a value in a context, using a method called apply. For example, you can apply a list of functions that add different numbers to a list of numbers, and get a new list of numbers. Monads are the most powerful abstraction, and they let you apply a function that returns a value in a context to a value in a context, using a method called flatMap or bind. For example, you can bind a function that returns an option value to an option value, and get a new option value.
Monads are useful when you need to deal with effects or dependencies in your code. Effects are things that happen outside of your pure functions, such as reading from a file, writing to a database, or throwing an exception. Dependencies are when the result of one function depends on the result of another function. Monads let you chain these functions together in a way that preserves the context and handles the effects. For example, you can use a monad to read a file, parse its contents, and write the result to another file, without having to worry about errors or null values.
Another great use case of monads is avoiding code reuse. You can define a monad encapsulating a common programming pattern. Take the Maybe monad in Haskell as an example. It encapsulates the equivalent of checking the result of the last computation and short-circuiting if it was Nothing.
Functors are useful when you need to transform values in a context without changing the context. They let you apply pure functions to your values without having to unwrap or rewrap them. For example, you can use a functor to convert a list of strings to a list of integers, or an option of a string to an option of an integer.
Applicatives are useful when you need to apply multiple functions in a context to multiple values in a context. They let you combine your functions and values in a way that preserves the context and handles the effects. For example, you can use an applicative to validate multiple inputs from a form, or to combine multiple futures into a single future.
There is no definitive rule on how to choose between monads, functors, and applicatives, but here are some general guidelines. If you need to deal with effects or dependencies, use monads. If you need to transform values without changing the context, use functors. If you need to apply multiple functions to multiple values, use applicatives. If you can use more than one abstraction, use the simplest one that meets your needs. And if you are not sure, experiment with different options and see what works best for your code.