do-notation appreciation thread ✨

#1 Mon Mar 24, 2025 11:03 am ¶

🐯 TypeclassTigers Monadic Purrfectionist ✦ Senior Posts: 2,341 Joined: Jan 2021 Online

okay so i've been meaning to make this thread for a while and today is finally the day!! i want everyone to come in here and share something they genuinely love about do-notation 💖

i'll start! the thing i keep coming back to is how do-notation is just beautiful syntactic sugar over monadic bind, and the desugaring is so elegant. like this simple Maybe example:

-- with do-notation (so readable!!)
safeDiv :: Int -> Int -> Maybe Int
safeDiv x y = do
  guard (y /= 0)
  return (x `div` y)

-- desugared (what GHC actually sees ~nya~)
safeDiv' :: Int -> Int -> Maybe Int
safeDiv' x y = guard (y /= 0) >> return (x `div` y)

like... the do version reads like imperative code but it's secretly completely pure and referentially transparent 🌸 every single time i explain this to someone new to Haskell and their eyes light up it makes me so happy

what do you girlies love about do-notation?? nya~ 🐱✨

/\ /\ ( o o ) =( Y )= TypeclassTigers ) ( "the typeclass is the territory" (_)-(_)

💖 12 ✨ 8 🐱 5

#2 Mon Mar 24, 2025 11:17 am ¶

🌙 LambdaLunaCat β-reducer ✦ Member Posts: 788 Joined: Sep 2022 ● Offline

YESSS this is the thread i needed today 💖💖

okay my favorite thing is the full desugaring rules!!! they are so clean. like the general case for any monad:

-- do { x <- m; rest }  desugars to:
m >>= (\x -> do { rest })

-- do { m; rest }  desugars to:
m >> (do { rest })

-- do { let x = e; rest }  desugars to:
let x = e in do { rest }

-- do { e }  desugars to:
e

it's just lambda calculus all the way down 😭💕 the <- arrow in do-notation is literally just binding a variable in a lambda. it looks like variable assignment from imperative world but it's not mutating anything!!! it's just a continuation!!!

this is one of those things that once it clicks in your brain you can never unsee it nya~~ 🐱

~ LambdaLunaCat ~ λx. x ≡ id ≡ 🐱

💖 9 ✨ 11 🧠 7

#3 Mon Mar 24, 2025 11:34 am ¶

🔮 FunctorFelicia Applicative Enjoyer ◈ Mod Posts: 5,102 Joined: Jul 2019 Online

THREAD OF THE YEAR. i'm pinning this 📌

I want to talk about ApplicativeDo because it doesn't get enough love!!!

So normally do-notation requires a full Monad instance. But with {-# LANGUAGE ApplicativeDo #-}, GHC will desugar your do-block using <$> and <*> wherever possible, only falling back to monadic bind when it actually needs it:

{-# LANGUAGE ApplicativeDo #-}

-- These two binds don't depend on each other!
-- With ApplicativeDo, GHC can run them in parallel 🌸
fetchUserAndPost :: Fetch (User, Post)
fetchUserAndPost = do
  user <- fetchUser 42
  post <- fetchPost 99   -- independent of `user`!
  return (user, post)

-- GHC desugars this to approximately:
-- (,) <$> fetchUser 42 <*> fetchPost 99

ApplicativeDo enables an alternative translation for do-notation which uses <$>, <*>, and join as far as possible — meaning you can use do-notation with types that are only Applicative and Functor, not full Monad!

ApplicativeDo desugaring preserves the original semantics, provided that the Applicative instance satisfies <*> = ap and pure = return — so you can normally turn on ApplicativeDo without fear of breaking your program. 💖

the fact that you can write readable sequential-looking code and have the compiler figure out what can be parallelized is just... *chef's kiss* 🐱✨

✦ FunctorFelicia ✦ [ CGPA Mod ] fmap purr catGirl = catGirl { sound = "purr" }

💖 14 ✨ 10 🔮 6 🐱 8

#4 Mon Mar 24, 2025 11:52 am ¶

🐈 KleisliKitten arrow enthusiast ✦ Member Posts: 423 Joined: Mar 2023 ● Offline

can i share my favorite do-notation moment ever?? it was when i realized that the list monad makes do-notation work like list comprehensions 😭💕

-- This do-block on lists...
pairs :: [(Int, Int)]
pairs = do
  x <- [1..5]
  y <- [x..5]
  guard (x + y == 6)
  return (x, y)

-- ...is EXACTLY the same as this comprehension!
pairs' = [(x, y) | x <- [1..5], y <- [x..5], x + y == 6]

-- result: [(1,5),(2,4),(3,3)]  ✨

ONE abstraction. works for Maybe (handling failure), for IO (sequencing effects), for lists (nondeterminism), for parsers, for State, for Reader... it's the same >>= every time!!! just a different monad!!! nya~~~

this is why i became a Haskell girl tbh. the unification is just *so beautiful* 🌸

|\ _,,,---,,_ /,`.-'`' -. ;-;;,_ KleisliKitten |,4- ) )-,_..;\ ( `'-' '---''(_/--' `-'\_)

💖 18 🐱 12 ✨ 9

#5 Mon Mar 24, 2025 12:08 pm ¶

🦊 CamelCat OCaml is fine actually ◈ Member Posts: 1,190 Joined: Nov 2021 Online

okay i'm going to say it. OCaml's let* is better and here's why:

(* OCaml with let* - clean, explicit, no magic *)
let safe_div x y =
  let* _ = if y = 0 then None else Some () in
  Some (x / y)

let* is just bind spelled out, no special syntax, no magical desugaring, no twelve extensions to enable. it's right there in the source. OCaml also got let+ for map and and+/and* for combining. very systematic!!!

haskell do-notation is honestly just let* with extra steps and a 40-page GHC extension manual 😤

i said what i said 🦊

CamelCat | OCaml society catgirl "a camel has two humps: one for syntax, one for semantics"

💖 2 😾 9 🤔 4

#6 Mon Mar 24, 2025 12:15 pm ¶

🐯 TypeclassTigers Monadic Purrfectionist ✦ Senior Posts: 2,341 Joined: Jan 2021 Online

CamelCat wrote:

haskell do-notation is honestly just let* with extra steps and a 40-page GHC extension manual 😤

camelcat bestie i love you but you walked into the do-notation appreciation thread to say do-notation is bad. in this house. on this day. nya~~ 😹

also "let* with extra steps" is doing a LOT of heavy lifting there. Haskell do-notation works uniformly across ALL monads including IO, parser combinators, STM, the list monad, Writer, Reader, State... all with the same syntax. and typeclasses mean you get this for FREE for any type you define a Monad instance for!!

OCaml's let* requires you to open specific modules and is not universal — you have to define separate operators per module. which is fine! but it is *not* the same thing 🐯💕

💡 mod note: keeping this civil! CamelCat is allowed to be wrong in the appreciation thread — FunctorFelicia

/\ /\ ( o o ) =( Y )= TypeclassTigers ) ( "the typeclass is the territory" (_)-(_)

💖 15 😹 11 ✨ 7

#7 Mon Mar 24, 2025 12:31 pm ¶

🌸 MonadMiaoMiao impure thoughts, pure code ✦ Member Posts: 654 Joined: Feb 2022 ● Offline

nobody has talked about QualifiedDo yet and i'm going to fix that!!! this extension makes me want to cry happy tears 😭💖

QualifiedDo enables qualifying a do block with a module name, to control which operations to use for the monadic combinators that the do notation desugars to. When -XQualifiedDo is enabled, you can qualify the do notation by writing modid.do, where modid is a module name in scope.

this means you can use do-syntax for things that AREN'T monads in the traditional sense!! there are types which are "monad-like" but can't provide an instance of Monad — like indexed monads, graded monads or relative monads — yet they could still use the do syntax if it weren't hardwired to the methods of the Monad typeclass.

{-# LANGUAGE QualifiedDo #-}
import qualified Control.Monad.Linear as Linear

-- Linear types monad with qualified do!
myLinearComp = Linear.do
  x <- someLinearAction   -- desugars to Linear.>>=
  y <- anotherAction x    -- desugars to Linear.>>=
  Linear.return (x, y)

You can even combine QualifiedDo with ApplicativeDo, or RecursiveDo and even RebindableSyntax! The qualified do blocks are the only ones affected 💕

the fact that one syntax can cover linear monads, indexed monads, the regular Prelude monads... it's just so powerful. do-notation is genuinely one of my fav things in any language nya~~~ 🌸🐱

/\_____/\ / o o \ MonadMiaoMiao ( == ^ == ) "it's monads all the way down" ) ( ( ) ( ( ) ( ) ) (__(__)___(__)__)

💖 13 ✨ 9 🔮 5

#8 Mon Mar 24, 2025 12:55 pm ¶

🦊 CamelCat OCaml is fine actually ◈ Member Posts: 1,190 Joined: Nov 2021 Online

TypeclassTigers wrote:

OCaml's let* requires you to open specific modules and is not universal

okay. okay fine. you have a point about universality via typeclasses. i concede that point 😾

BUT. i will say that for people learning FP, let* being explicit about what module's bind you're using has pedagogical advantages! newcomers to OCaml don't have to learn "do-notation desugars to..." they just see the bind directly!!!

...okay i still think QualifiedDo is kind of cool. kind of. don't tell anyone 🦊

CamelCat | OCaml society catgirl "a camel has two humps: one for syntax, one for semantics"

💖 7 😹 14 🦊 8

#9 Mon Mar 24, 2025 1:14 pm ¶

⭐ RecursiveRosePaw mfix is my bestie ✦ Member Posts: 267 Joined: Jun 2023 ● Offline

hi!!! first post in this thread, i was lurking and couldn't resist anymore 🌸

i want to gush about RecursiveDo!! it's so wild and i feel like not enough people know about it

For monads that belong to the MonadFix class, GHC provides an extended version of do-notation that allows recursive bindings. The RecursiveDo language pragma provides the necessary syntactic support, introducing the keywords mdo and rec for higher and lower levels of the notation respectively.

{-# LANGUAGE RecursiveDo #-}

-- mdo lets you refer to bindings defined LATER!
justOnes :: Maybe [Int]
justOnes = mdo
  xs <- Just (-1 : xs)   -- xs refers to itself!
  return xs

-- evaluates to Just [-1,-1,-1,...] (an infinite list!)

-- or more fine-grained with `rec`:
example = do
  a <- getChar
  rec
    r1 <- f a r2    -- r1 and r2 are mutually recursive!
    r2 <- g r1
  return (r1, r2)

A rec-block tells the compiler where precisely the recursive knot should be tied. The placement of the recursive knots can be rather delicate — ideally the knots should be wrapped around as minimal groups as possible.

the fact that this desugars to mfix calls is so elegant... value recursion in a monad... i think about this at night honestly 😭✨ nya~

⭐ RecursiveRosePaw ⭐ fix (\f -> f) -- always thinking recursively

💖 11 🤯 8 ✨ 6

#10 Mon Mar 24, 2025 1:42 pm ¶

🔮 FunctorFelicia Applicative Enjoyer ◈ Mod Posts: 5,102 Joined: Jul 2019 Online

can we also appreciate how do-notation makes IO code look so natural?? like this is one of the things that makes Haskell's IO story actually beautiful rather than terrifying:

-- looks like an imperative program!
greetUser :: IO ()
greetUser = do
  putStrLn "what is your name? nya~"
  name <- getLine
  let greeting = "hello, " ++ name ++ "! welcome to CGPA! 🐱"
  putStrLn greeting

-- but it desugars to this pure value description:
greetUser' :: IO ()
greetUser' =
  putStrLn "what is your name? nya~" >>
  getLine >>= \name ->
  let greeting = "hello, " ++ name ++ "! welcome to CGPA! 🐱"
  in putStrLn greeting

the IO monad is still a pure value!! greetUser is a pure description of a computation, not an execution of it! the runtime handles the actual execution! this is such a powerful idea and do-notation makes it accessible to people coming from imperative backgrounds 🌸🌸

Haskell gives you the ergonomics of imperative code with the reasoning power of pure FP. do-notation is the bridge 💖 nya~~

✦ FunctorFelicia ✦ [ CGPA Mod ] fmap purr catGirl = catGirl { sound = "purr" }

💖 16 ✨ 13 🐱 10

#11 Mon Mar 24, 2025 2:03 pm ¶

🌙 LambdaLunaCat β-reducer ✦ Member Posts: 788 Joined: Sep 2022 ● Offline

something i appreciate that we haven't touched on: do-notation has been around since literally the beginning!! Mark Jones introduced it in the Gofer compiler in 1994, and from there it made it into the Haskell language report in 1996. Since then it has become popular, and for a good reason — it makes it easy to read a sequence of statements describing an effectful computation.

over 30 years of do-notation 🥺💕 it was the right design. they got it right in 1994 and we're still using it and loving it. that's longevity!!

and now with QualifiedDo, ApplicativeDo, RecursiveDo it's been carefully extended without breaking anything. that's great language design. the Haskell committee really said "if it ain't broken..." 🐱

~ LambdaLunaCat ~ λx. x ≡ id ≡ 🐱

💖 10 ✨ 7 🏛️ 5

#12 Mon Mar 24, 2025 2:28 pm ¶

🐈 KleisliKitten arrow enthusiast ✦ Member Posts: 423 Joined: Mar 2023 ● Offline

late addition but i want to show the State monad example because it's my favorite way to show people that "look imperative, is pure" thing 🌸

import Control.Monad.State

-- this looks like mutable state but there IS NO mutation!!
counter :: State Int String
counter = do
  n <- get          -- "read" the state
  put (n + 1)       -- "write" the state
  m <- get          -- "read" again
  modify (* 2)       -- "modify" the state
  return $ "went from " ++ show n ++ " to " ++ show (m * 2)

-- runState counter 5  ==>  ("went from 5 to 12", 12)
-- all pure!! state is threaded through as a function argument! 🐱

every time i show this to someone from an OOP background they go "wait... but where's the mutation??" and i get to say "there is none :)" and their brain breaks a little bit in a good way 😹✨

do-notation is the perfect cover for this trick. it looks so familiar!

|\ _,,,---,,_ /,`.-'`' -. ;-;;,_ KleisliKitten |,4- ) )-,_..;\ ( `'-' '---''(_/--' `-'\_)

💖 14 😹 9 ✨ 12

#13 Mon Mar 24, 2025 3:01 pm ¶

🦊 CamelCat OCaml is fine actually ◈ Member Posts: 1,190 Joined: Nov 2021 Online

KleisliKitten wrote:

every time i show this to someone from an OOP background they go "wait... but where's the mutation??"

okay I will admit. the State monad in do-notation is genuinely elegant. I've shown the OCaml equivalent and it requires more ceremony 😾

you all win this one. do-notation good. i'll see myself out

...but let* is still good too!!!! it has its place!!! 🦊 both can be nice ok

anyway here is a cat as a peace offering:

-- a very important computation
catProgram :: IO ()
catProgram = do
  putStrLn "nya~"
  putStrLn "nya~"
  putStrLn "*falls asleep on keyboard*"
  putStrLn "zzzzzz >.<"

CamelCat | OCaml society catgirl "a camel has two humps: one for syntax, one for semantics"

💖 21 😹 17 🐱 15 🦊 9

#14 Mon Mar 24, 2025 3:22 pm ¶

🐯 TypeclassTigers Monadic Purrfectionist ✦ Senior Posts: 2,341 Joined: Jan 2021 Online

CAMELCAT REDEMPTION ARC 😭💖💖💖

okay i'm gonna close out this thread (for now) with my absolute favorite do-notation fact that we haven't mentioned: do-notation works for your own custom types too, and it's EASY 🌸

-- define your own little monad nya~
newtype Purrfect a = Purrfect { runPurrfect :: (String, a) }

instance Functor Purrfect where
  fmap f (Purrfect (s, a)) = Purrfect (s, f a)

instance Applicative Purrfect where
  pure x = Purrfect ("", x)
  Purrfect (s1, f) <*> Purrfect (s2, x) = Purrfect (s1 ++ s2, f x)

instance Monad Purrfect where
  return = pure
  Purrfect (s1, a) >>= f =
    let Purrfect (s2, b) = f a
    in  Purrfect (s1 ++ s2, b)

-- NOW you can use do-notation with it!!! for free!!!
myPurrfectProg :: Purrfect Int
myPurrfectProg = do
  x <- Purrfect ("nya~ ", 3)
  y <- Purrfect ("purr~ ", 4)
  return (x + y)

-- runPurrfect myPurrfectProg  ==>  ("nya~ purr~ ", 7)  🐱💖

implement Monad, get do-notation free. that's the deal. that's the typeclass magic 💖 this is why i love Haskell and i love do-notation and i love this forum and i love all of you nya~~~

thank you everyone for the wonderful thread!! 🌸🐱✨

/\ /\ ( o o ) =( Y )= TypeclassTigers ) ( "the typeclass is the territory" (_)-(_)

💖 24 ✨ 19 🐱 16 🌸 11