Monads: Still Confusing People After All These Years

The Eternal Promise

The Fundamental Problem: Solving the Wrong Problems

The Purity Cult: When Ideology Meets Reality

1
-- "Pure" Haskell function
2
add :: Int -> Int -> Int
3
add x y = x + y  -- So pure! So elegant!
4
 
5
-- Actual useful program
6
main :: IO ()
7
main = do
8
  putStrLn "What's your name?"
9
  name <- getLine
10
  putStrLn $ "Hello, " ++ name
11
  -- Congratulations, your entire program is now "impure"

The Monad Tutorial Industrial Complex

1. •"Monads are like burritos"
2. •"Monads are like space suits"
3. •"Monads are like assembly lines"
4. •"Monads are endofunctors in the category of—" [BRAIN.EXE HAS STOPPED RESPONDING]

1. •"I don't understand monads"
2. •"I UNDERSTAND MONADS! I must write a tutorial!"
3. •"I don't understand monads"

Why Haskell Fails at Real Programming

1. The Learning Curve of Existential Dread

2. Simple Things Are Needlessly Complex

1
{-# LANGUAGE OverloadedStrings #-}
2
{-# LANGUAGE DeriveGeneric #-}
3
 
4
import Data.Aeson
5
import GHC.Generics
6
import qualified Data.ByteString.Lazy as B
7
 
8
data Person = Person
9
  { name :: String
10
  , age :: Int
11
  } deriving (Generic, Show)
12
 
13
instance FromJSON Person
14
instance ToJSON Person
15
 
16
-- 47 more lines of boilerplate...

3. The Build System From Hell

• •Cabal hell (deprecated but still everywhere)
• •Stack (Cabal but different)
• •Nix (because one language wasn't complex enough)
• •GHC version conflicts
• •Resolver conflicts
• •Dependency conflicts
• •Conflicts with your will to live

4. Error Messages From Another Dimension

Couldn't match type 'IO String' with '[Char]'
Expected type: String
  Actual type: IO String
In the expression: getLine
In an equation for 'name': name = getLine

The "What Language Are You Even Using?" Problem

1
{-# LANGUAGE OverloadedStrings #-}
2
{-# LANGUAGE GADTs #-}
3
{-# LANGUAGE TypeFamilies #-}
4
{-# LANGUAGE DataKinds #-}
5
{-# LANGUAGE PolyKinds #-}
6
{-# LANGUAGE RankNTypes #-}
7
{-# LANGUAGE FlexibleContexts #-}
8
{-# LANGUAGE AllowAmbiguousTypes #-}
9
{-# LANGUAGE TypeApplications #-}
10
{-# LANGUAGE ScopedTypeVariables #-}
11
{-# LANGUAGE DeriveFunctor #-}
12
{-# LANGUAGE DeriveTraversable #-}
13
{-# LANGUAGE DeriveFoldable #-}
14
{-# LANGUAGE QuantifiedConstraints #-}
15
{-# LANGUAGE UndecidableInstances #-}

The Type System: An Exercise in Academic Showmanship

1
foo :: (Functor f, Applicative g, Monad m, 
2
        MonadTrans t, MonadIO (t m),
3
        HasCallStack, Typeable a) 
4
     => (∀ b. f b -> g b) 
5
     -> t m (f (g a)) 
6
     -> IO (Either String (g a))

The "It's Actually Practical" Delusion

The Academic Echo Chamber

1. •PhD student proposes incomprehensible feature
2. •Three professors write papers about it
3. •Feature gets added with unpronounceable name
4. •Nobody uses it except other PhD students
5. •"Why isn't Haskell mainstream?" they wonder

Real Problems Haskell Can't Solve Elegantly

Debugging Production Issues

Onboarding New Developers

Incremental Development

Library Ecosystem

The Evangelical Complex

• •"Python is nice, but have you considered Haskell?"
• •"JavaScript could learn from Haskell's type system"
• •"Go would be better if it was Haskell"
• •"Rust is just Haskell with worse syntax"
• •"Your grandmother's cookie recipe would benefit from monadic composition"

The Elephant in the Room

• •Shipping features
• •Serving customers
• •Processing payments
• •Scaling systems
• •Training juniors
• •Meeting deadlines
• •Getting paid

In Conclusion

• •Mathematicians become good at user interface design
• •Academic papers start including "Developer Experience" sections
• •Category theory becomes required learning in bootcamps
• •Users start caring about referential transparency
• •My code works on the first try