What Is a Monad?

To answer this question, let’s first understand the problem it solves. Take the following code as an example:

if (a > b) {
    if (c < d) {
        if (e != f) {
            ...
        }
    }
}

One can immediately see that the code is deeply nested and difficult to comprehend. Keen readers might argue this could be solved with early returns. True in some cases, but not entirely, because:

• The deep nesting problem isn’t limited to if blocks alone.

• Even with early returns, the code might become long and difficult to follow.

• Above all, we may not want to return right away; we might want to do something else, like adding an error message to an array.

In the above example, the unit of operation is comparison. Similarly, the unit of operation in a loop is iteration, and in async/await, it’s an external call. From this, a monad can be practically defined as a pattern/construct/container/wrapper that encapsulates a unit of operation and chains subsequent operations in a flattened way.

The above example can be rewritten as below: where If and AndIf are extension methods

If( _ => a > b)
.AndIf(_ => c < d)
.AndIf(_ => e != f);

This is an over-simplified example, and that’s intentional, as many other posts about monads dive into complex details, leading readers to misunderstand what they really are.

Similarly, nested for loops can be simplified as below:

From:

foreach (var outerItem in outerCollection)
{
    foreach (var innerItem in outerItem.innerCollection)
    {
         ...
    }
}

To:

outerCollection.SelectMany(innerItem => ...);

TypeScript Example

In TypeScript, here’s an example with nested callbacks and the async/await equivalent:

// Using nested callbacks
function getUserInfoWithCallback() {
    fetchUserData((user) => {
        fetchUserProfile(user.id, (profile) => {
            console.log("User data:", user);
            console.log("User profile:", profile);
            // More nested operations could go here
        });
    });
}

// Using async/await
async function getUserInfoMonadic() {
    const user = await fetchUserData();
    const profile = await fetchUserProfile(user.id);
    console.log("User data:", user);
    console.log("User profile:", profile);
}

Am I a Functional Programmer?

Absolutely not (well, maybe—actually, I don’t know). Contrary to popular belief, monads aren’t exclusive to functional languages. Languages like C# and JavaScript are more than happy to sneak them in under different names (looking at you, async/await). If you’ve ever been caught in callback hell or wrangled with nested foreach loops, you’ve already encountered the kinds of issues that monads can help clean up.

Pro tip: You can stop feeling guilty about using monads outside of functional programming—it’s not cheating; it’s efficient coding.

Let’s defer the usual definition until the end because, let’s be honest, the only thing scarier than “Category Theory” is the phrase “Category Theory for Beginners.” In essence, monads help manage data transformations in a readable and declarative way. They structure your code around sequences of operations, ensuring each step flows neatly into the next without trapping readers in a labyrinth of early returns and conditionals.

Think of monads as tidy helpers for your code, ensuring the solution feels more like a conversation than an interrogation.

Composing Operations with Monads

Monads provide a way to compose multiple operations in a clear, organized sequence. For example, if you’re validating data, monads can help you set up a chain where each validation runs only if the previous one succeeded, saving you from a jungle of nested statements.

Example in C#:

var result = email.Validate()
.Then(_ => password.Validate())
.Then(_ => username.Validate())
.Map((e, p, u) => new(e, p, u));

This code is declarative and easy to read. Each validation step is composed neatly, without excessive conditionals or manual error handling. For this to work, email, password, and username should adhere to a common interface, say IValidated or IValidatable, and Validate() should return the same type. For the adventurous C# programmer, you can add Select and SelectMany methods to these types so that LINQ query syntax can be used, like so:

from validatedEmail in email.Validate()
from validatedPassword in password.Validate()
from validatedUsername in username.Validate()
select new UserRegistration(validatedEmail, validatedPassword, validatedUsername);

Fear not—many languages have their own way of expressing monad continuations. Just as with design patterns, understanding monads is less about memorizing their structure and more about recognizing when they solve a particular problem.

The Hyped-Up Monad Problem

Here’s the kicker: a lot of literature makes monads sound like mystical constructs with powers beyond mortal comprehension. This over-glorification can set readers up for disappointment. Yes, monads are useful, but they’re not an arcane force that transforms code into pure gold. They’re a design pattern—like the Singleton or Factory patterns—but with an actual definition.

Fun fact: The term “design pattern” is often code for “not exactly defined, but sounds good.” At least monads have actual definitions!

Monads, Category Theory, and Why We Should (Mostly) Ignore It

Yes, monads come from category theory, and understanding that foundation is great for abstraction. But for the everyday developer, thinking of monads as design patterns for readability is often more practical. Sure, learning category theory can make pseudocode nearly identical to real code across languages, but nobody’s handing out gold stars for that. Here’s the theoretical definition:

A monad is defined as a triple (T,η,μ)(T, \eta, \mu)(T,η,μ), where:

• TTT is a functor that maps objects and morphisms between categories.

• η\etaη (unit) wraps a value in the monadic context, like Just x for Maybe.

• μ\muμ (bind) flattens nested monads, ensuring operations combine smoothly.

Monad Laws (Ignore if You’re Sane)

For those interested, monads must satisfy three laws to chain operations reliably:

• Left Identity: return x >>= f is the same as f x

• Right Identity: m >>= return is the same as m

• Associativity: (m >>= f) >>= g is the same as m >>= (\x -> f x >>= g)

Final Thoughts

Monads are best thought of as a design pattern for readability, not a complex mathematical structure only for the elite. In essence, monads help you nested code to be flattened and chained. There are some advanced theory behind how these can also be used to isolate side-effects from the business logic. We did not deal with that in this post though. By keeping things grounded and applying monads where they naturally fit, we can avoid the hype and find practical solutions. And remember: if you ever feel the urge to start with “In category theory…”—just don’t.

Thanks to my YouTube subscriptions list. Or, as I call it, my “self-imposed online university.” Each channel I have subscribed has genuinely helped me, whether it’s learning how to debug a stubborn nvim plugin, figuring out why curries refuse to curry me, or finally understanding the history behind the pawn structure I keep messing up in the end game. But somewhere along the way, my curiosity spiralled out of control, and now I’m drowning in content, wondering if “YouTube Subscriber” counts as a profession.

The basics: I subscribed to all these channels because I believed they would make me smarter, more productive, and be a better version of myself. But instead, I’ve become a walking encyclopedia of half-digested knowledge, an “expert” who knows a little about everything and a lot about avoiding real work. At this rate, my productivity graph looks like it was hit by a segmentation fault.

The Productivity Paradox: Welcome to the Land of Infinite Notifications

Every day, I start with the noble intention of achieving something meaningful—maybe progress a bit on one of many coding projects lying around, or even (gasp) get a workout in. But then the YouTube notifications hit, and I’m sucked into a vortex of “urgent” videos. Watching one turns into watching five, and before I know it, I’m “learning” about medieval Mongolian war strategies… and no, I have no idea how I got there either.

On good days, I convince myself that all this content is making me more well-rounded. On bad days, I’m just a guy with many browser tabs open on “How to optimize my code” while simultaneously watching a live stream on how to lose gracefully in chess. Every notification promises something critical, like “5 Mind-Blowing JavaScript Hacks,” and here I am, choosing to watch rather than code, only to forget every single hack as soon as the video ends.

My Own Productivity Saboteur

So, what did I learn from all these channels? Well, nothing… at least nothing that can be found in a resume. Somewhere between “Geography Now” and “Fireship,” I realized I’m not as committed to growth as I thought. I’m more like a kid at a candy store, grabbing everything and savoring nothing.

A shoutout to my most favourite youtubers though

• Zach Star

• Sorted Food

• ChessBase India(Beloved Sagar and Amruta)

• Our stupid reactions

• Geography now

• Kings and generals

• 3Blue1Brown

• NileRed

• Roomieofficial and so many more(93 in total 😯)

The (Unpaid) Job of Watching All This: An Exercise in Futility

Honestly, keeping up with my subscriptions feels like a full-time job. There are notifications popping up at all hours, begging me to click. And click, I do. Sometimes, I think I should just add “YouTube Enthusiast” to my LinkedIn profile. But then I realize that the only endorsement I’d get would be for “Avoiding Real Work.”

And this is only my YouTube list. I haven’t even touched on Twitter, where every thread promises “insights that will change your life” (but only if you scroll past 25 tweets), or Twitch, where people are streaming chess and coding for hours while I struggle to watch without also feeling like a passive observer in my own life. Then there are all the ad-hoc suggestions from YouTube, Netflix, prime, appletv, Disney+, hotstar and SonyLiv. My multitasking skills have reached a new high… or low. Let’s call it efficiently overwhelmed.

I May Never Escape, But At Least I’m Entertained

In the end, my subscription explosion is both my joy and my downfall. I have access to endless knowledge, inspiration, and the occasional recipe that I’ll definitely mess up. But really, I’m not fooling anyone. I’ve crossed from “lifelong learner” to “lifelong procrastinator.”

So here’s to all the content creators and their neon LED backdrops, intense chess analyses, and relentless calls to “smash that like button.” You’ve created a world where every notification feels like an invitation to greatness, even if, deep down, I know I’ll be watching rather than doing. Now, if you’ll excuse me, there are 12 new videos waiting for me to ignore all my responsibilities.

The Only Way In: Be a Player
No, I didn’t sneak in disguised as a janitor. But after navigating the Olympic-level security and finally getting to shake hands with some of the top players, my mind started wondering: What if I had been on the other side of the barricades? How would my life have played out if I were not just a fan, but an actual participant in the Olympiad?

Mistaken Identity: How I Became a Player
In my imagined version of events, I was sitting innocently, watching a thrilling game between Viswanathan Anand and his opponent, when suddenly a frazzled organizer ran up to me. “You! Quick! We need you to play!” Naturally, I didn’t hesitate—because, hey, what could go wrong when your chess rating is roughly equivalent to your shoe size?

The Game Begins
As I imagined, I sat down across from a Norwegian grandmaster, trying to look as calm and professional as possible. I opened with the classic pawn to e4. Solid move, right? Except, fifteen moves later, I’d somehow trapped my own queen and built a fortress that would make abstract artists proud.

Miraculous (Imaginary) Victory
But hey, this is my story, so why not dream big? In my mind, just as my opponent was about to finish me off, I pulled off a brilliant, unexpected tactic (thank you, 2 a.m. chess tutorials), and boom—checkmate! Cue the standing ovation.

Back to Reality
Of course, none of this really happened. I did meet my chess heroes—Anand, Harikrishna, Gukesh, and more—but I left the actual playing to the pros. No imaginary glory, no sneaky victories. Just pure admiration and some fantastic memories of chatting with these legends.

The Dream Lives On
In the end, my trip to the 2024 Chess Olympiad was everything I had hoped for and more. I may not have played in the event (this time), but that wild imaginary journey? Let’s just call it a fun detour. Until then, I’ll stick to taking selfies with the masters and enjoy being a fan!

In my mind, they asked me for selfies! 🎉♟️