Question

The purpose for this particular portion of code is to make the size function more efficient than simply counting all the elements in elems. I’ve settled on summing the two types that make up the list, but I can’t seem to create the signature of the size function.

instance (Finite a, Finite b) => Finite (Either a b) where
    elems = combineLists [Left x | x <- elems] [Right x | x <-elems]
    size ??? = (size a) + (size b)

From Prelude, we know that Either a b = Left a | Right b.

The first thing I tried was to match Either, but of course it is a type, so that doesn’t work. Next, I tried ((Left a) | (Right b)), but no go on that either. Nothing else seems to match the type Either a b.

I was able to get size (Left a) to compile, but since it’s missing the b component, I receive the error:

Ambiguous type variable `b' in the constraint:
  `Finite b' arising from a use of `size' at <interactive>:1:0-12

which of course makes sense in the context, but I really have no clue how to match Either a b.

Anybody have any thoughts?

Answer 1

Something of type Either a b is either a Left a or a Right b, so you have two cases that can be handled separately:

size (Left x) = size x
size (Right x) = size x

The error about the ambiguous type variable is a separate issue.
If you just type something like size (Left 1) into the interpreter, the system can’t deduce what the “right” type of that Left 1 value would be. It could be Either Int anything and as long as it is not known what type that anything is, it cannot be checked if it is in class Finite (which is required by size).

You can avoid that problem by specifying an explicit type signature:

size (Left 1 :: Either Int String)