I think a lot of people view monads as these esoteric things that provide some kind of FP enlightenment once you understand them when in reality, they're just a

I think a lot of people view monads as these esoteric things that provide some kind of FP enlightenment once you understand them when in reality, they're just another layer in the list of abstractions one needs to understand to do "useful stuff" in a language like Haskell. Without deep diving into a bunch of monad laws, etc, I think you can bring someone around to what a monad is at a basic level pretty quickly by explaining a few basic things. 1) There are values that can have multiple states. Example: a value of type Maybe could be represented as a "box" holding an underlying value (Just 3 or Just "Hello"), or it can be represented as the absence of a value (Nothing). 2) In OOP parlance, you can think of a functor as an interface with a single method (called fmap). Fmap takes two arguments: a normal function that takes a single value and returns a result and secondly a "boxed value". Fmap simply unwraps the boxed value, applies the function to the underlying result and then re-wraps the value and returns that wrapped value as the result. Fmap is smart enough that if you give it a value like (Nothing) it will simply return Nothing. 3) Monads take the functor mechanics a little further by applying a function that returns a "boxed" value to a "boxed" value. The same types of guarantees that a functor provides regarding handling states appropriately (give me Nothing, I will return Nothing) are baked in for you, which allows you to safely chain one call to the next without having to manually check for invalid data. This is done by a function called "bind" which is represented as the >>= operator in Haskell. Take a contrived function "half" that returns its argument (x) divided by two if the argument is even or returns Nothing otherwise. A "boxed" value is returned in either circumstance. half x = if even x then Just (x `div` 2) else Nothing From here, you can chain calls to half without worrying about whether a previous computation failed. Just 20 >>= half >>= half (returns Just 5) Just 5 >>= half (returns Nothing) Just 5 >>= half >>= half >>= ... (also returns Nothing) The Maybe instance of bind looks like this: instance Monad Maybe where Nothing >>= func = Nothing Just val >>= func = func val As-in, Nothing fed into a function, gives you Nothing back. Just <something> fed into a function gives you the result of the function applied to that value. IMPORTANT: the function returns a "boxed" value because that's what any subsequent call the bind (aka >>=) would expect. Now imagine that this "off the books" computation can work with all sorts of "boxed" types beyond just Maybe. The additional work being done by each bind call happens independently of the function being provided to bind, so you can do things like logging how a result was calculated, build up stateful data structures, etc... having only written the code to do so one time. There's clearly quite a bit more to know about monads and their applications, but I think the above is enough to get someone to understand some of the value they provide (at a very high level).