CODEWITHSUNDEEP
haskellerror-handling
John F. Miller
John F. Miller

Reputation: 27217

ErrorT catchError in practice

I have a very typical setup with a set of functions in the IO monad that can throw errors. To date I have just been dealing with errors at the end of the monad chain by pattern matching the Either result from runErrorT:

replLisp :: LispScope -> String -> IO String
replLisp s input = do
  result <- runErrorT (evalLisp s input)
  return $ either (id) (show) result

I would now like to add some error handling to my Hacked little scheme, but I'm having trouble making the type checker happy.

How does one use catchError? An example or two would be helpful.

This is my latest attempt:

catch :: [LispVal] -> IOThrowsError LispVal
catch [action rescue] = do
  eval action >>= catchError $ eval rescue

Upvotes: 3

Views: 1865

Answers (2)

Thomas M. DuBuisson
Thomas M. DuBuisson

Reputation: 64740

Here is an example use of catchError to recover from a prior call to throwError:

import Control.Monad.Error
import Control.Monad.Identity

type MyMonad = ErrorT String Identity
runMyMonad = runIdentity . runErrorT

main = do
        let x = runMyMonad (func 5 0)
        print x

func :: Double -> Double -> MyMonad Double
func w x = do
        y <- (divider x) `catchError` (\_ -> return 1)
        return (w + y)

divider :: Double -> MyMonad Double
divider x = do
        when (x == 0) (throwError "Can not divide by zero!")
        return (10 / x)

Despite passing 0 in for division we can complete with the handlers result of 1 to obtain output of Right 6.0.

Does this help? Your question didn't really say what the issue was.

Upvotes: 6

Edward Z. Yang
Edward Z. Yang

Reputation: 26742

Error monads like Either and Maybe don't allow you to observe the error from within the same monad: you have to run the monad in order to observe it. Exceptions in IO are one notable exception (ahem) because IO is the end of the line... you can't go any further from there.

You have a few possibilities:

  • Since you're writing a mini-interpreter, it's probably a good idea to explicitly manage all the exceptions, using the ErrorT monad only for true, unrecoverable errors.

  • For any call that may error that you want to be able to recover from, perform a runErrorT and inspect that result, before passing along the result in the current monad.

Upvotes: 0

Related Questions