You can also use it for representing errors, for representing global read-only variables, for representing global write-only variables, for representing non-determinism, for representing continuations, and other things (since you can write your own).

For example, this is a really minimalistic arithmetic syntax tree interpreter in Haskell. You could write errors using the Either type:

  data Term = Constant Int | Divide Term Term
  
  eval :: Term -> Either String Int
  eval (Constant n) = n
  eval (Divide left right) =
    case eval left of
      Left errorString -> Left errorString
      Right leftResult ->
        case eval right of
          Left errorString -> Left errorString
          Right rightResult ->
            if rightResult == 0
              then Left "Division by zero"
              else Right (div leftResult rightResult)

It's cumbersome, and there's a staircase growing. Because Either is a monad, you could rewrite the division op like this:

  eval (Divide left right) = do
    leftResult <- eval left
    rightResult <- eval right
    if rightResult == 0
      then Left "Division by zero"
      else Right (div leftResult rightResult)

This is a good article about the either monad: https://mmhaskell.com/blog/2022/3/3/using-either-as-a-monad

The state monad is basically a wrapper over a pure function that takes a state and returns a tuple with the result and a new state. In an imperative language, you'd just actually change state, rather than doing that.

An example from this wiki page: https://en.wikibooks.org/wiki/Haskell/Understanding_monads/S...

In an imperative language, for pseudo-random numbers, you could modify global variables every time you want a new random number. Haskell lets you do this in IO functions. But a pure way would be to return the result of the new global variable every time.

  -- randomR takes a range, so randomR (1,6) produces a random number between 1 and 6
  rollPair :: StdGen -> ((Int, Int), StdGen)
  rollPair s0 =
    let (r1, s1) = randomR (1,6) s0
        (r2, s2) = randomR (1,6) s1
    in ((r1, r2), s2)

It's annoying. You could use the state monad to simplify this:

  rollDieS :: State StdGen Int
  rollDieS = state (randomR (1,6))

  rollPairS :: State StdGen (Int, Int)
  rollPairS = do
    r1 <- rollDieS
    r2 <- rollDieS
    return (r1, r2)