Safe IO, and then a journey about sly HOT 1 CLOSED

That was fun and enlightening. I started with the previously discussed transformation from IO to Try and that was straightforward. It pointed toward a generalism about transformations that simply run the monadic effect - I'll come back to that. It's generally possible to write two kinds of transformations generically.

When there are Monad and MonadT implementations of the same effect, e.g. Either and EitherT, it is generally possible to create a NaturalTransformation from the Monad to the MonadT given a Pure for the argument Monad.

Also, I'm not convinced that it's quite as universal, but it's often possible to create a NaturalTransformation that maps the argument Monad of a MonadT, given a NaturalTransformation from the existing argument Monad to a new one. I'm hesitant to say that this "mapping" transformations are generally possible because I am suspicious about MonadTs that are also a MonadReader. As I was writing MappingReaderT I began to wonder what would have to happen with a different MonadReader where R was itself parameterized with aMonad. If such a MonadT required agreement between its own argument Monad and the Monad parameter of the MonadReader's R then it would probably require the ability to reverse-transform the type parameter of the R type in order to transform the MonadT.

The big realization I had while writing these occurred while I tried to find ways to implement "runners". In order to implement a "runner" NaturalTransformation, a Monad needs to yield another Monad with the same carrier when it's run. However, it's pretty common for a Monad to yield another Monad with a different carrier, e.g. EitherT::runEitherT. This type of operation can be generalized as Fn1<Functor<A, F>, Functor<B, G>> and correctly capture all of the type information, but I can't help but wonder if there might be some use in specializing this kind of function.

I'm going to give it a try. Running EitherT seems like a pretty good first target.

from sly.