They're different representations of the same thing.

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))

Take the following with a grain of salt (others correct me if I'm wrong), I'm very new to using monad transformers:

"->" 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)

The EitherIO data type given is

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

But, for the sake of clarity, it can be written as

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

The author pointed out two functions that this EitherIO declaration gave us. One is a constructor, MakeEitherIO, with type

  IO (Either e a) -> EitherIO e a

In other words, MakeEitherIO takes a value of type IO (Either e a) and returns a value of type EitherIO e a (you could think of this as "wrapping" the original IO value).

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)

That is, runEitherIO takes a value of type EitherIO and returns the internal value of type IO (Either e a) (you could think of this as "unwrapping" the IO value).

I hope that helps!