Question

I’m trying the codes from <Real World Haskell>.

On GHC version 6.10.4:

data ParseState = ParseState {
  string :: String
} deriving (Show)

newtype Parse a = Parse {
  runParse :: ParseState -> Either String (a, ParseState)
}

parse :: Parse a -> String -> Either String a
parse parser initState =
  case runParse parser (ParseState initState) of
    Left err          -> Left err
    Right (result, _) -> Right result

Everything went fine until I changed ‘Left err’ to ‘err@(Left _)’:

--  err@(Left _)      -> err
{-
 -  Occurs check: cannot construct the infinite type:
 -    a = (a, ParseState)
 -  When generalising the type(s) for `parse'
-}

Any ideas?

Answer 1

This is subtle. The case is scrutinizing a value of type Either String (a, ParseState), so when you name the pattern in

err@(Left _) -> err

err has that same type. However, the function’s return type says it should be an Either String a, which doesn’t match err‘s type of Either String (a, ParseState). Looking at the type of Left:

Left :: x -> Either x y

When you use Left in the right-hand side in

Left err -> Left err

You are giving it a chance to choose a different y, namely a instead of (a, ParseState).

So even though the values are the same, the types are not, and so they can’t be substituted.

By the way, there are a few very handy functions for your case in Control.Arrow (specializing to (->) for simplicity):

left :: (a -> a') -> Either a b -> Either a' b
right :: (b -> b') -> Either a b -> Either a b'
(+++) :: (a -> a') -> (b -> b') -> Either a b -> Either a' b'

whose semantics are fixed by the free theorems (read: they only have one reasonable implementation, so they do what you’d expect from their types). So you could write your code as:

parse parser = right fst . runParse parser . ParseState