One example I've wound up using recently is the one found in Pike's Errors are values where he pretty much implements an ad-hoc monad, but without any of the explicitness and generality that monad-aware languages do. As, in, the code he ends with,

b := bufio.NewWriter(fd)
b.Write(p0[a:b])
b.Write(p1[c:d])
b.Write(p2[e:f])
// and so on
if b.Flush() != nil {
    return b.Flush()
}

should be roughly equivalent to the following pseudo-Haskell

runWriter fd $ \b -> do
  write b p0[a:b]
  write b p1[c:d]
  write b p2[e:f]
  flush b

or in pseudo-Rust with a stabilised try:

let b = bufio::new_writer(fd);
try {
    b.write(p0[a:b])?;
    b.write(p1[c:d])?;
    b.write(p2[e:f])?;
    return b.flush()?;
}

As in, Haskell and Rust would be more explicit about the failure scope, and both the do block and the try and ? signal to the user that here are fallible operations that might not happen, unlike in Go where b might just silently become inert. I guess for this example the "look samey" impulse was stronger than the "be explicit" impulse?

In any case, the Go example should serve to kick off a discussion of an Either/Result monad¹ with a reference to a "real-world" language that is normally the opposite of interested in monads.

¹ Yes, I called the pseudo-Haskell function "runWriter" but that's just because I felt sticking with the "newWriter" name was even wronger