Monad transformers and free monads
Monads do not always compose: if M and L are arbitrary monads then neither M∘L nor L∘M will be a monad in the general case. However, being able to compose monads is very useful: for example, one monad may describe database transactions while another represents reading from the Web, and so we would like to write monadic code that reads from the Web and writes the results into a database. The type of this program would be some sort of composition of the two monads, because the code must express an arbitrary combination of both effects. In order to be able to write such code, ideally we would like to be able to compose two arbitrary monads.

One way to compose monads is through monad transformers. A monad transformer for a monad M is a functor of functors T_M that, for any monad L, yields a natural transformation L ~> T_ML, which creates a new monad T_ML such that there exists a natural embedding transformation L ~> T_ML. (These natural transformations must commute with the monads' defining natural transformations, in an appropriate sense; see https://en.wikipedia.org/wiki/Monad_transformer for precise conditions.) 

It is not obvious how to construct a monad transformer T_M for a given monad M. I couldn't find a general construction. All "nice" monads have a monad transformer; is there an example of a monad for which no monad transformer exists? Here is a paper with a more abstract view of monad transformers; but it also does not seem to offer a systematic derivation of transformers from monads.

So far, I found four specific classes of monads M for which a monad transformer can be constructed systematically. I call these transformers Outside, Inside, Free, and Adjoint transformers.

1. The Outside transformer exists for any (recursive-)polynomial monad M and is defined as the composition T_ML = L∘M, with the "foreign" monad L on the outside of the type expression.

The List monad,

List t = 1 + t × List t,

and the Maybe (a.k.a. Option) monad, M t = 1 + t, are classic examples of (recursive-)polynomial monads, and the Outside transformer is standard for them.

2. The Inside transformer exists for a certain limited class of of exponential-polynomial monads M, and is defined as the composition T_ML = M∘L, with the "foreign" monad L on the inside.

Examples of suitable monads are Reader, Writer, and State monads, as well as any monad of the form S t -> t where S is a contrafunctor. The product of any two such monads is again a monad of the same class; I studied their properties in more detail in a previous post.

It is interesting that the Continuation monad (t -> r) -> r does not have an Inside transformer. The (practically extremely useful) "Future" monad can be seen formally as a particular case of the Continuation monad with r = 0, and so it does not have an Inside transformer. (Neither does it have an Outside transformer.)

3. The Free monad transformer exists for the free A-monad, where A is any functor (see http://www.haskellforall.com/2012/07/free-monad-transformers.html and https://github.com/ekmett/free/issues/3).
The free A-monad is defined recursively as the functor F = Id + A∘F, or if we write this type equation using an explicit type parameter t,
F t = t + A(F t).

Statement. The Free transformer defined recursively as

T_FL = L∘(Id + A∘T_FL)

defines a monad for any monad L.

Proof.
Writing out the type parameter t and denoting T_FL for brevity by T, we have the recursive type equation

T t = L (t + A(T t)),

where the occurrence of T in the right-hand side can be already assumed to have the monadic properties by induction.

The embedding transformation L ~> T is defined by embedding into L(Id + 0). To establish the monadic property T∘T~>T, we use the existing natural transformations L∘L~>L and Id ~> L, and consider that we would like to obtain the following chain of natural transformations

T∘T = L(T t + A(T(T t))) ~> L(t + A(T t)).

Note that we can transform T(T t) ~> T t by using the inductive assumption. The difficult part is the argument of L, which is a disjunction. We cannot transform L(x+y)~> ... + ... because L is not necessarily co-distributive. Instead, we need to map this disjunction to some other type. We use the following trick: transform

A (T t) = 0 + A(T t) ~> L(0 + A(T t))

where the last step uses the L-point transformation (r ~> L r). The result is that we have transformed A(T t) into a value of type T t. Therefore we can write the transformation

T t + A(T t) ~> T t + T t ~> T t (this is just the disjunction of identity transformations T t ~> T t),

and finally we obtain the chain of natural transformations

T∘T = L(T t + A(T(T t))) ~> L(T t + A(T t)) ~> L(T t + T t) ~> L(T t) = L(L(t + A(T t)) ~> L(t + A(T t)) = T t.

Hence we have transformed T∘T~>T as required.
Q.E.D.

Note that the Free A-monad transformer is not itself a free monad of any functor. (Also, neither the free A∘L-monad nor the free L∘A-monad yields monad transformers that satisfy the required laws!) The resulting transformed monad T_FL does not itself automatically have a monad transformer. As a result, it is not clear how to combine two monads that have been transformed with two different Free transformers.

As an aside - it has been fashionable recently to combine free monads using co-products (disjnctions) of functors. For two functors A and B, one combines the free A-monad and the free B-monad by considering the free (A+B)-monad. In this way, we can compose any number of free monads; but the old problems return as soon as we need to mix in a few non-free monads.

4. Finally, the Adjoint transformer exists for monads that are obtained from adjunctions. An adjunction is a pair of functors (F, U) that satisfy certain properties (which I still need to study in more detail before I can translate them into the language of functional type theory). Among those properties are these: the composition F∘U is a monad, and the reverse composition U∘F is a comonad. So, if M is a monad for which we know the explicit adjunction (F, U) such that F∘U = M, then the Adjoint monad transformer for M is defined by

T_ML = F∘L∘U.

[ https://oleksandrmanzyuk.files.wordpress.com/2012/02/calc-mts-with-cat-th1.pdf ]

The monadic property (T_ML)∘(T_ML)~>(T_ML) is easy to verify since we have natural transformations U∘F ~> Id (since U∘F is a comonad) and L∘L ~> L (since L is a monad). Thus we find a chain of natural transformations
(T_ML)∘(T_ML) = F∘L∘U∘F∘L∘U ~> F∘L∘L∘U ~> F∘L∘U = T_ML.

It appears plausible that the transformers of the first three types are particular cases of the fourth, once we find an appropriate adjunction. For instance, examples of adjunctions often involve a forgetful functor. In the language of bare types (when we forget all subcategories), a forgetful functor is simply an identity functor. So, an adjunction (F, U) with F = Id means that U is itself a monad (and a comonad), and that the Adjoint monad transformer for F is T_UL = F∘L∘U=L∘U. This is exactly the same as the Outside monad transformer. Similarly, an Inside monad transformer is obtained from an adjunction (F, U) with U = Id.

This level of generality is elegant but does not give us a systematic procedure for writing a monad transformer corresponding to a given specific monad, such as M t = 1 + t or M t = (1 + t -> r) -> t.

For instance, what adjunction (F, U), if any, underlies the Continuation monad?

Another open question is whether monad transformers are unique. The Inside monad transformer for the State monad, s -> s × M(t),  is not the same as the Adjoint transformer s -> M(s × t). In this case, the Outside transformer is stronger (can be mapped onto the Adjoint transformer, but not vice versa). What is the significance of this?