In my experience, Haskell's comparatively complex and - arguably - also rather ad hoc type system can make a discussion of monads quite involved and hard to follow.

For those who approach Haskell with some Prolog or Mercury background, it may be useful to know that Prolog's Definite Clause Grammars (DCGs) are very similar to monads. In Prolog, a DCG clause of the form

    head -->
        goal_1,
        goal_2,
        ...,
        goal_n.

is implicitly augmented with 2 additional arguments that are threaded through as follows:

    head(S0, S) -->
        goal_1(S0, S1),
        goal_2(S1, S2),
        ...,
        goal_n(S_(n-1), S).

It is in these 2 arguments that you can implicitly pass around additional information such as counters, list differences, "global" variables, and states in general. Prolog provides dedicated syntax (called semicontext notation) to access these implicit arguments if needed. Often, they are simply threaded through implicitly throughout large portions of code without any modification.

Thus, it is obvious that DCGs, and hence monads, can save a lot of typing that would arise if you had to pass around these arguments explicitly. Also, they let you focus on the essence by making data that is only relevant to a small set of predicates (or functions) implicit in your programs.

It may be easier to understand these concepts if you can discuss them in isolation from a type system.