data.either | Migrated to https : | Functional Programming library

The key is present, but it's wrapped inside another nested object, so you have to unwrap the outer object before you can parse the keys.

The smallest-diff way to do this is probably just inline:

You have:

• A list of values of some type a (in this case a ~ (String, String)). So, xs :: [a]
• A function f from a to some type b in a monadic context, m b. Since you're ignoring the return value, we can imagine b ~ (). So, f :: Monad m => a -> m ().

You want to perform the operation, yielding some monadic context and an unimportant value, m (). So overall, we want some function doStuffWithList :: Monad m => [a] -> (a -> m ()) -> m (). We can search Hoogle for this type, and it yields some results. Unfortunately, as we've chosen to order the arguments, the first several results are little-used functions from other packages. If you scroll further, you start to find stuff in base - very promising. As it turns out, the function you are looking for is traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f (). With that, we can replace your do-block with just:

EitherT monad transformer is not covariant in A or B type parameters

Here you need to import both the type \/ and the value \/.

The syntax for importing type operators is type (\/). The prefix type is necessary for disambiguation - that is, to let the compiler know that you're importing the type, not the value that might have the same name.

And the syntax for importing the value is as usual.

So the whole import would look like this:

As it was suggested in the comments section, types in for comprehension should be aligned and the compiler complains about that: you invoke flatMap on EitherT (implicitly via <-) and as a result return Future instead of expected EitherT.

You need to change return type and re-implement next method:

Your problem is that recBase is not necessarily of type Resource.

The compiler has two points of reference for determining the type of recBase: (1) the fact that recBase.identifiers is used with readIdTypePair and (2) the return type of readRecordJSON.

From the first point the compiler can conclude that:

The first problem is that we need to return something in case the parse value returns a Left … value. We can for example make a function that combines the two "errors" with:

The problem GHCi has here is simply that it doesn't know what type to use for ts. All it knows it that it has to be an instance of RealFrac and of Integral - and also of Show (since asking for a result to be displayed in GHCi implicitly requires a `Show instance, so GHCi knows how to display it as a string in your terminal). And this isn't enough for it to know exactly which type to use - which is what it is complaining about.

The usual way to solve this is to specify the type you want explicitly, such as (note that this will NOT work as I explain below, but it shows the usual way to solve such an "ambiguous type variable" error in GHCi):

That's because of the way the Either Applicative instance works. What you can do is to wrap Either in a newtype: