Question

I have a group of Data.BSON.Document structures that I am digging through, converting each one into a User data structure (I defined User). The function to do the unpacking is pretty straightforward:

docToUser :: Document -> Either String User
docToUser u = do
    name <- look "name" u >>= \(String t) -> return $ unpack t
    email <- look "email" u >>= \(String t) -> return $ unpack t
    token <- look "auth" u >>= \(String t) -> return $ unpack t
    Right $ User name email token

The catch, though, is that it does not actually seem to error out in an Either context. Here are some example runs:

*DB> docToUser ["name" =: "Savanni", "email" =: "[e-mail]", "auth" =: "random_token"]
Right (User {name = "Savanni", email = "[e-mail]", token = "random_token"})
*DB> docToUser ["name" =: "Savanni", "email" =: "[e-mail]", "a" =: "random_token"]
*** Exception: expected "auth" in [ name: "Savanni", email: "[e-mail]", a: "random_token"]

So, the first run returns a user wrapped inside a Right constructor. The second one I expected something such as Left "field not found", but instead get a full exception. Why is this happening instead of an error stored within an Either data structure?

Answer 1

Based on information that I can find from here, here, and general other googling around… the instance for the Either monad does not have a fail implementation. On a guess, that would be why I get an exception instead of Left. I wrote this little test to demonstrate:

eitherMonad :: String -> Either String String
eitherMonad val = do
    if val == "abcd"
        then fail "val is abcd"
        else return "val is something else"

*DB> eitherMonad "abcd"
*** Exception: val is abcd
*DB> eitherMonad "efgh"
Right "val is something else"

On the other hand, fail :: String -> Maybe String really does return Nothing. It would appear that the correct way to do my docToUser conversion is something more akin to this:

docToUser :: Document -> Either String User
docToUser u = do
    let name  = look "name" u :: Maybe Value
    let email = look "email" u :: Maybe Value
    let token = look "auth" u :: Maybe Value
    case (name, email, token) of
        (Just (String n), Just (String e), Just (String t)) -> Right $ User (unpack n) (unpack e) (unpack t)
        (Nothing, _, _) -> Left "username not found"
        (Just (String n), Nothing, _) -> Left "email not found"
        (Just (String n), Just (String e), Nothing) -> Left "auth token not found"
        otherwise -> Left "Something else broke"

I would imagine that can take quite a bit of refinement, especially in detecting and reporting which fields failed. But, this seems to be pretty close to the answer.

I think, given that, that this question is a duplicate of Is there no standard (Either a) monad instance?