A Gentle Introduction to Monad Transformers – or, Values as Exceptions

This is useful because we can do easy error handling in the EitherIO monad but we can't run it. We can run the IO monad but handling errors in it sucks ass.

So we handle errors in EitherIO, and make it runnable (ie. convert to the IO monad) by calling runEitherIO.

It's like calling a function that takes a pair when some other API gives you a two element list. The same kind of data, just munging the shape so things work. In pseudocode:

  // EitherIO and runEitherIO in this analogy.
  fun toList((a, b)) -> [a, b]
  fun toPair([a, b]) -> (a, b)

  // Gotta convert to a "runnable" pair before calling the function.
  var latLngList = [blah, blah]
  var resultPair = api1ThatRequiresPair(toPair(latLngList))

  // Convert representations to do operations with a different API.
  api2ThatRequiresList(toList(resultPair))

  data EitherIO e a = EitherIO {
      runEitherIO :: IO (Either e a)
  }

  data EitherIO e a = MakeEitherIO {
      runEitherIO :: IO (Either e a)
  }

  IO (Either e a) -> EitherIO e a

The second function, runEitherIO, is an accessor function for EitherIO's named record field "runEitherIO". It has type

  EitherIO e a -> IO (Either e a)

I hope that helps!

"->" is pronounced to. "::" is pronounced "is a".

EitherIO is a function from "IO (Either e a) -> EitherIO e a".

runEitherIO is a function from "EitherIO e a -> IO (Either e a).

In any function that allows using the IO monad (your main function for example) you'll you'll have:

result <- runEitherIO SomeEitherIOVariable

Result's type is "result :: Either e a". Now you just have a normal Either to deal with.

    public static EitherIO<e, a> method(IO<EitherIO<e,a>> arg)

    public static IO<Either<e,a>> method(EitherIO<e, a> arg)

http://okmij.org/ftp/Haskell/extensible/index.html

I also know of:

http://jozefg.bitbucket.org/posts/2014-07-15-reading-extensi...

However I was wondering if there was a "Gentle introduction to extensible effects".

Edit: I found this presentation: http://ro-che.info/docs/2014-06-14-extensible-effects.html#1...

In the mean time , mtl is almost extensible effects and is very fast.

  [1]The Try type represents a computation that may either result in an exception, or return a successfully computed value. http://www.scala-lang.org/files/archive/nightly/docs/library/index.html#scala.util.Try
  [2]http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote-Duality

I don't see the point you are trying to make here.

Spend some time learning the basic Haskell syntax (it's really not that hard) and you'll be able to get to the "meat" of such articles much, much faster than if the article were written in any other language.