The problem that made monads make sense for me was when I had to chain (err, val) tuples for six or seven functions that only took val and handling the (err, _) bit was awkward. Someone showed how to rewrite it using monads to handle that without the boilerplate and voila.

If someone would make a tutorial that replicates the process you just described, that might be a good way to teach monads.

I strongly suggest starting with a language like Elm to get into FP, since you start to use `map` and `andThen` quite often, but you also get sick of writing `a |> Result.andThen fn1 |> Result.andThen fn2`. This can help a programmer realize why it might be better to have a concise syntax for this, like:

    myFun : String -> Result String Int
    myFun a =
       do b <- fn1 a
          c <- fn2 b
          return c

That said, I think the other problem with Haskell is the definition of the bind operator: it is not obvious to a beginner which concrete function is actually being called for each monadic operation. Idris2, for instance, lets you specify the bind operator in its do notation[0].

[0] https://idris2.readthedocs.io/en/latest/tutorial/interfaces....

The Railway Oriented Programming section in F# For Fun And Profit is basically this.

I think it'd become Just Another Monad Tutorial. Its something that clicks after a bit of FP programming without monads. Simon Peyton-Jones wrote a good paper about how IO worked prior to Monads which is nice - context helps with these things. I remember struggling to understand OO until I got my first junior dev role so I do think it's just practice practice practice to get through these things.

IMO it's probably better to teach the use of applicatives first and then monads.

I like the way that "Learn You a Haskell" puts it:

  "If we have a fancy value and a function that takes a normal value but returns a fancy value, how do we feed that fancy value into the function?"

That's basically all a monad is. If you know what map() does (in Haskell terms, map is a "functor"), then you know what a monad is, as it's just a fancy map().

I'll put it in Rust terms:

  let x: Option<u8> = Some(5);
  fn foo(x: u8) -> Option<u8> {...}

How do we apply the function foo to x? That's what monads are for.