# Pay No Attention to the Monads

###### Aug 7, 2024

This week I came across this great, humerous video by [Low Level Learning](https://youtu.be/dNi__BckudQ?si=VULGBU1tLz_koj2Z) about Haskell, and boy can I say I've been there before.

As someone who did go through with learning Haskell and now enjoys using Haskell, allow me share a helpful tip to you readers who wish to pursue learning Haskell yourselves: Ignore the definitions of things, and just focus on what they allow you to do. Haskell has a strong root in lambda calculus, and although it strengthens the inner working of the language, I know I personally don't know lambda calculus and lack the time to learn it.

You can remember the phrase "a Monad is just a Monoid in the category of Endofunctors" so you, too, can partake in the memery, but otherwise you really don't need to know what a Monad is to learn and use Haskell. In Haskell, a Monad is a typeclass, and a typeclass is much like an interface in Go, or a trait in Rust. It says "types that identify as this can use these special methods/functions". Thats all you need to know to use a Monad. I - to this day - don't even know what a Monad really is.

And to be quite honest, _I don't even really care_.

As far as I'm concerned, a Monad allows me to use `return`, double-pointy-equals (`>>=`), and double-pointy-no-equals (`>>`). It also allows me to use a Monad-identifying type in any non-method function that says it takes a Monad-identifying type as an argument. And since a Monad has to also be Applicative, I get all the methods of that too.

What does Applicative mean? If I were to take an educated guess, it means things can be applied to other things, _but I can't be bothered to care about that either_.

Applicative lets me use `pure` (which is actually the same thing as `return`, or rather `return` is by-default defined as `pure`, for some historic reason), `liftA2`, the Darth-Vader's-Tie-Fighter operator (`<*>`), and both directions of pointy-asterisk (`<*`, `*>`). And also any non-method that takes an Applicative. And also, Applicatives are Functors, so...

(_P.S.: I still don't care what the definition is._)

...Functor lets me use `fmap` and left-pointy-dollar-sign (`<$`) and any non-method that takes a Functor.

And the same idea goes for Monoid, Semigroup, Endo, all the "specialized Monads" like MonadPlus or MonadIO, and any other typeclass with a funny lambda calculus name.

A fair amount of typeclass names aren't confusing, like Traversable, or Foldable, or Alternative, or Fractional, or Eq, or Bounded. Still don't care about the definition of the words, though, at least though these ones I know or can deduce on my own.

### Also, a Word on Symbols

As you may have gathered from the last section, Haskell has _a lot_ of symbol-functions. And you can define your own, too!

But you should really think hard before making your own, because any new developer to Haskell can tell you that random, new symbols are confusing. To which I agree. I personally don't define new symbols where possible, and tout that symbols and iconography are only useful if the symbol's/icon's meaning is universally agreed upon or immediately understandable.

I get that a lot of Haskell's base symbology is derived from lambda calculus and probably universally agreed upon there, albeit I do not posses a Ph.D in Mathematics. I am a simple guy who writes funny robot words. I'll give a pass to the Haskell base library for the lambda-calculus-derived ASCII-ified symbols, but to all the other library authors, know that I'm silently glaring angrily at your documentation on my computer screen when I see a symbol that could have had a regular function name.

Its also harder to verbally say what a symbol is, without giving it some weird name like "double-pointy-equals" or "Darth Vader's Tie Fighter" or "left-fish" (which for the nerds, respectively is "bind" (`>>=`), "apply" (`<*>`), and a left-pointed Kleisli arrow, or left-monadic-composition (`<=<`)).

Just give the symbol-function a proper name, then use that name as the function name. You can still infix text-named-functions, although I personally don't think ``this `leftFish` that`` will catch on.

So for the learners: try not to get hung up on symbols, either. They're just functions that someone thought would be better off without a real name. Or sometimes the symbol is defined as a one-to-one copy of a named function, like how `<$>` is just `fmap` in a pointy, rich trench-coat. Look up the symbol on [hoogle](https://hoogle.haskell.org/), see what it's supposed to do, and carry on.

### The Rest

Of course, there's still quite a bit of other stuff to Haskell, especially in the realms of C-FFI, TemplateHaskell, QuasiQuoters, Pragmas, tooling, and everything else I don't know to mention because I myself am not a Haskell expert.

But for the rest, take things as they come, you mostly don't need to know these to _learn_ Haskell. Pick up enough of Cabal to build and run your code, pick up how to read and write Haskell, and give it a whirl just like any other language.

And most importantly, **pay no attention to the Monads.**