Explicitly Typed Exceptions For Haskell (PADL'10)

Explicitly Typed Exceptions
for Haskell (2011?)

José Iborra
Universidad Politécnica de Valencia
PADL 2010
Wednesday, January 20, 2010

Explicitly Typed Exceptions for Haskell PADL’10
• Compare this code in a programming language:

public static void main(String[] args) {
String filepath = args[1];
Reader f = new FileReader(filepath);
doSomethingWith(f);
}
• with the equivalent Haskell code

main = do
filepath <- liftM head getArgs
contents <- readFile filepath
doSomethingWith contents
• Both can fail with an exception

• but only one compiler detects it
José Iborra Universidad Politécnica de Valencia

• Compare this code in a programming language:

public static void main(String[] args) {
String filepath = args[1];
doSomethingWith(f);
}
• with the equivalent Haskell code

main = do
filepath <- liftM head getArgs
contents <- readFile filepath
doSomethingWith contents
• Both can fail with an exception

• but only one compiler detects it
Main.xxxx:10: unreported exception xxxx.io.FileNotFoundException;
must be caught or declared to be thrown
^
1 error

Checked Exceptions
• Detected and enforced by the compiler
• Usually explicit: possible exceptions appear on the type
• automatically documented
• the programmer has no need to think “what

exceptions can be raised inside this block ?”

Checked Exceptions
• Detected and enforced by the compiler
• Usually explicit: possible exceptions appear on the type
• automatically documented
• the programmer has no need to think “what

exceptions can be raised inside this block ?”
• Checked exceptions are not always a good

thing™

To check or not to check ?
“I used to think that checked exceptions were really

great” - Bruce Eckel*
“I completely agree that checked exceptions

are a wonderful feature. It’s just that existing
implementations are not”
Anders Heljsberg*
* - http://www.artima.com/intv/handcuffs.html

Exceptions in Haskell
Extensible Hierarchical Explicit Checked Traced
Haskell 98 (IO) Limited

GHC*(IO) Yes Yes
Either/ErrorT Yes Yes
but not Yes Yes but wrong
monad composable semantics
EM
Yes Yes Yes Yes Yes!
monad
GHC* - An extensible dynamically typed hierarchy of Exceptions - S. Marlow (2006)

Error handling in Haskell
data Expr = Add Expr Expr | Div Expr Expr | Val Double
eval :: Expr -> Double

eval (Val x) = x
eval (Add e1 e2) = eval e1 + eval e2
eval (Div e1 e2) = eval e1 / eval e2

eval :: Expr -> Double

eval (Val x) = x
eval (Div e1 e2) = case eval e2 of
0 -> exception !
x2 -> eval e1 / x2


data Either a b = Left a | Right b
eval :: Expr -> Either exception Double

eval (Val x) = x
0 -> Left exception
x2 -> Right (eval e1 / x2)


data DivByZero = DivByZero deriving Show
eval :: Expr -> Either DivByZero Double

eval (Val x) = x
0 -> Left DivByZero



eval (Val x) = x
0 -> Left DivByZero



eval (Val x) = Right x
0 -> Left DivByZero



eval (Add e1 e2) = case eval e1 of
Right x1 -> case eval e2 of
Right x2 -> Right(x1 + x2)
0 -> Left DivByZero



Right 0 -> Left DivByZero
Right x2 -> Right (eval e1 / x2)



Right x1 -> Right(x1 / x2)



Left e -> Left e



Left e -> Left e
Left e -> Left e



Left e -> Left e
Left e -> Left e
Left e -> Left e



Left e -> Left e
Left e -> Left e
Left e -> Left e
Left e -> Left e



Left e -> Left e
Left e -> Left e
Left e -> Left e
Left e -> Left e

Error handling with monads


Left e -> Left e
Left e -> Left e
Left e -> Left e
Left e -> Left e
Left e >>= f = Left e

Right x >>= f = f x



eval (Add e1 e2) = e1 >>= \x1 -> case eval e2 of
Left e -> Left e
Left e -> Left e
Left e -> Left e

Right x >>= f = f x



eval (Add e1 e2) = eval e1 >>= \x1 -> eval e2 >>= \x2 ->
Right(x1 + x2)
Left e -> Left e
Left e -> Left e

Right x >>= f = f x



Right(x1 + x2)
eval (Div e1 e2) = eval e2 >>= \x2 ->
case x2 of
0 -> Left DivByZero
x2 -> case eval e1 of
Left e -> Left e

Right x >>= f = f x



Right(x1 + x2)
case x2 of
0 -> Left DivByZero
x2 -> eval e1 >>= \x1 -> Right(x1 / x2)

Right x >>= f = f x



Right(x1 + x2)
case x2 of
0 -> Left DivByZero
x2 -> eval e1 >>= \x1 -> Right(x1 / x2)
instance Error e => Monad (Either e) where

Right x >>= f = f x
return = Right



eval (Val x) = return x
Right(x1 + x2)
case x2 of
0 -> Left DivByZero
x2 -> eval e1 >>= \x1 -> Right(x1 / x2)

Right x >>= f = f x
return = Right



return(x1 + x2)
case x2 of
0 -> Left DivByZero
x2 -> eval e1 >>= \x1 -> Right(x1 / x2)

Right x >>= f = f x
return = Right



return(x1 + x2)
case x2 of
0 -> Left DivByZero
x2 -> eval e1 >>= \x1 -> return(x1 / x2)

Right x >>= f = f x
return = Right



eval (Add e1 e2) = do x1 <- eval e1
x2 <- eval e2
return (x1 + x2)
case x2 of
0 -> Left DivByZero
x2 -> eval e1 >>= \x1 -> return(x1 / x2)

Right x >>= f = f x
return = Right



x2 <- eval e2
return (x1 + x2)
eval (Div e1 e2) = do x1 <- eval e1
x2 <- eval e2
case x2 of
0 -> Left DivByZero
x2 -> return (x1 / x2)

Right x >>= f = f x
return = Right



x2 <- eval e2
return (x1 + x2)
x2 <- eval e2
case x2 of
0 -> throw DivByZero
throw = Left

Right x >>= f = f x
return = Right



x2 <- eval e2
return (x1 + x2)
x2 <- eval e2
case x2 of
throw = Left
catch (Right x) handler = Right x

catch (Left e) handler = handler e

• User extensible
The Either Monad • Hierarchical
• Checked
• Explicit

x2 <- eval e2
return (x1 + x2)
x2 <- eval e2
case x2 of
throw = Left
catch (Right x) handler = Right x

catch (Left e) handler = handler e

• User extensible
The Either Monad

✘
• Hierarchical
• Checked
• Explicit

x2 <- eval e2
return (x1 + x2)
x2 <- eval e2
case x2 of
throw = Left
parse :: String -> Either ParseError Expr
run :: String -> Either ??? Double

run str = do { e <- parse str; eval e }

• User extensible
The Either Monad

✘
• Hierarchical
• Checked
• Explicit


• User extensible
The Either Monad

✘
• Hierarchical
• Checked
• Explicit

data ParseOrDivError = ParseE ParseError

| EvalE DivByZero

• User extensible
The Either Monad

✘
• Hierarchical
• Checked
• Explicit


| EvalE DivByZero
mapError :: (e -> e’) -> Either e a -> Either e’ a

mapError f (Left e) = Left (f e)
mapError f (Right r) = Right r
parse’ = mapError ParseE . parse

eval’ = mapError EvalE . eval

• User extensible
The Either Monad

✘
• Hierarchical
• Checked
• Explicit


| EvalE DivByZero


run :: String -> Either ParseOrDivError Double

run str = do { e <- parse’ str; eval’ e }

• User extensible
The Either Monad

✘
• Hierarchical ✓
• Checked
• Explicit


| EvalE DivByZero




• User extensible
The Either Monad

✘
• Checked ✘
• Explicit


| EvalE DivByZero




• User extensible
The Either Monad

✘
• Checked ✘
• Explicit


| EvalE DivByZero


• User extensible
The Either Monad

✘
• Checked
• Explicit


| EvalE DivByZero

run str = do
e <- parse’ str
eval’ e

• User extensible
The Either Monad

✘
• Checked
• Explicit


| EvalE DivByZero

run str = do
e <- parse’ str
eval’ e `catch` \EvalE DivByZero -> return 0

• User extensible
The Either Monad

✘
• Checked
• Explicit


| EvalE DivByZero

run str = do
e <- parse’ str
Warning: Pattern match(es) are non-exhaustive

In a case alternative:
Patterns not matched:
ParseE

• User extensible
The Either Monad

✘
• Checked
• Explicit ✓


| EvalE DivByZero

run str = do
e <- parse’ str

A monad for Explicitly Typed Exceptions

Fixing the composability problem
* An extensible dynamically typed hierarchy of Exceptions - S. Marlow (2006)


• Apply the extensible + hierarchical exceptions datatype of

Marlow*



Marlow*
data SomeException = ∀ e. (Show e, Typeable e) => SomeException e
class Exception e where



Marlow*

fromException :: SomeException -> e
toException :: e -> SomeException



Marlow*

• defining a new monad of non-explicit, composable

exceptions



Marlow*


exceptions
newtype C# a = C# (Either SomeException a)
deriving Monad -- C# is isomorphic to Either
throwC# :: Exception e => e -> C# a



Marlow*


exceptions

throwC# = C# . Left . toException



Marlow*


exceptions




Marlow*


exceptions

catchC# = ... -- uses casting, slightly more involved



Marlow*


exceptions
• User extensible

• Hierarchical

• Checked
• Explicit



Marlow*


exceptions
• User extensible ✓

• Hierarchical

• Checked
• Explicit



Marlow*


exceptions


• Checked
• Explicit



Marlow*


exceptions


• Checked ✘
• Explicit



Marlow*


exceptions


• Checked ✘
• Explicit ✘


data DivByZero = DivByZero deriving (Show,Typeable)
instance Exception DivByZero
eval :: Expr -> C# Double

x2 <- eval e2
return (x1 / x2)
x2 <- eval e2
case x2 of
0 -> throwC# DivByZero
parse :: String -> C# Expr
run :: String -> C# Double


The Explicit Exceptions Monad
newtype EM l a = EM (Either SomeException a) deriving Monad
class Exception e => Throws e l
throwEM :: Throws e l => e -> EM l a

throwEM = EM . Left . toException



• Idea: the type of a computation includes the exceptions it
may throw.




may throw.
• Establish a type-level relationship between a computation

and every exception it may throw
• Encoded as a list of type class constraints




may throw.
• Establish a type-level relationship between a computation

and every exception it may throw
• Encoded as a list of type class constraints
class Exception e => Throws e l This is not the most

general type


data DivByZero = DivByZero deriving (Show,Typeable)
instance Exception DivByZero
eval :: Throws DivByZero l => Expr -> EM l Double

x2 <- eval e2
return (x1 / x2)
x2 <- eval e2
case x2 of
0 -> throwEM DivByZero
parse :: Throws ParseError l => String -> EM l Expr
run :: (Throws DivByZero l, Throws ParseError l) =>

String -> EM l Double

The Explicit Exceptions Monad Kernel

(a la Lightweight Dependent Types)*

private
public
EM a >>=EM k = EM (a >>=Either ...)
returnEM = EM . returnEither

throwEM = EM . Left . toException --identical to throwC#, modulo the EM wrapper
catchEM :: Exception e => EM (Caught e l) a -> (e -> EM l a) -> EM l a

catchEM = ... -- identical to catchC#, modulo the EM wrapper
runEM :: EM l x -> x
runEM (EM (Right x)) = x
tryEM :: EM Any x -> Either SomeException x

tryEM (EM x) = x
* - Lightweight static capabilities, Kiselyov & Shan, 2007


Reasoning about exceptions

M, N = return H H ∈ pure
| M >>= N
| throw e
| catch M (λe → N )
| if H then M else N


| M >>= N
| throw e
|return H| = {} |M | = e2 |throw e| = {e}
|M | = m |N | = n |M | = m |N | = n
|M >>= N | = m ∪ n |if H then M else N | = m ∪ n
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h


| M >>= N
| throw e
|M | = m |N | = n |M | = m |N | = n
>>=EM :: EM l a -> (a -> EM l b) -> EM l b
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h


| M >>= N
| throw e
|M | = m |N | = n |M | = m |N | = n
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h

Implementing Catch
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h
catch :: Exception e => EM (Caught e l) a -> (e -> EM l a) -> EM l a

catch = ... --omitted, as before
data Caught e l
instance Throws e (Caught e l)
instance Throws e l => Throws e (Caught e1 l)

Implementing Catch
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h

data Caught e l
This is not the most
instance Throws e (Caught e l) general type

Implementing Catch
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h

data Caught e l

Implementing Catch
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h

data Caught e l

run :: ... => String -> ...
run str = do
e <- parse str `catch` \ParseError -> ...
eval e

Implementing Catch
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h

data Caught e l

run :: ... => String -> ...
run str = do
eval e
(`catch` \ParseError -> ..) :: EM (Caught ParseError l2) a -> EM l2 a

Implementing Catch
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h

data Caught e l

run :: ... => String -> ...
run str = do
eval e

parse str :: Throws ParseError l1 => EM l1 Expr

Implementing Catch
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h

data Caught e l

run :: ... => String -> ...
run str = do
eval e

parse `catch` \ParseError... :: Throws ParseError (Caught ParseError l2) => EM l2 Expr

Implementing Catch
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h

data Caught e l

run :: ... => String -> ...
run str = do
eval e

parse `catch` \ParseError... :: EM l2 Expr

Implementing Catch
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h

data Caught e l

run :: ... => String -> ...
run str = do
eval e

Implementing Catch
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h

data Caught e l

run :: ... => String -> ...
run str = do
e <- parse str `catch` \DivByZero -> ...
eval e

Implementing Catch
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h

data Caught e l

run :: ... => String -> ...
run str = do
eval e
(`catch` \DivByZero -> ..) :: EM (Caught DivByZero l2) a -> EM l2 a

Implementing Catch
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h

data Caught e l

run :: ... => String -> ...
run str = do
eval e


Implementing Catch
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h

data Caught e l

run :: ... => String -> ...
run str = do
eval e

parse `catch` \DivByZero... :: Throws ParseError (Caught DivByZero l2) => EM l2 Expr

Implementing Catch
|C| = c |H| = h
|catch C (λe → H)| = (c \ {e}) ∪ h

data Caught e l

run :: ... => String -> ...
run str = do
eval e

parse `catch` \DivByZero... :: Throws ParseError l2 => EM l2 Expr

Running EM computations
• Checked version demanding that no exceptions leak:
runEM :: EM l a -> a
:t parse “some string”

parse “some string” :: Throws ParseError l => EM l Expr
:t runEM (parse “some string”)

No instance for (Throws ParseError l)
Possible fix:
add an instance declaration for (Throws ParseError l)

• Unchecked version accepting computations which may
raise any exception
data Any
instance Throws e Any
tryEM :: EM Any a -> Either SomeException a

tryEM (EM x) = x
:t tryEM (parse “this”)

tryEM (parse “this”) :: Either SomeException Expr

raise any exception
data Any Any is a “type flag”


tryEM (EM x) = x


raise any exception
data Any

tryEM (EM x) = x


• Selectively turning exceptions into unchecked exceptions
data OnlyUnchecked type flag

class Exception e => UncheckedException e
instance UncheckedException e => Throws e OnlyUnchecked
runEM :: EM OnlyUnchecked a -> a

runEM (EM (Left e)) = error (“Unchecked exception: “ ++ show e)

• Selectively turning exceptions into unchecked exceptions
data OnlyUnchecked type flag

class Exception e => UncheckedException e
instance UncheckedException e => Throws e OnlyUnchecked
runEM :: EM OnlyUnchecked a -> a

runEM (EM (Left e)) = error (“Unchecked exception: “ ++ show e)

eval :: Throws DivByZero l => Expr -> EM l Double
instance UncheckedException ParseError
main :: String -> Double

main str = runEM $ do
e <- parse str
eval e `catch` \DivByZero -> ...



Anders Heljsberg*



Anders Heljsberg*
“Burritos* make great exception libraries” -

Jose Iborra
* - Monads are like Burritos, Brent Yorgey



Anders Heljsberg*
“Checked exceptions are great, in a library”

Jose Iborra

Choice (of Monad)

class Monad m => MonadFailure e m where
failure :: e -> m a
instance MonadFailure e Maybe where failure _ = Nothing

instance Error e => MonadFailure e Either where failure = Left
instance Throws e l => MonadFailure e (EM l) where
failure = EM . Left . toException
parse :: (MonadFailure ParseError m) => String -> m Expr

eval :: (MonadFailure DivByZero m) => Expr -> m Double
run :: (MonadFailure DivByZero m, MonadFailure ParseError m) =>

String -> m Double

Choice (of Monad)

failure :: e -> m a



String -> m Double
run :: (Throws DivByZero l, Throws ParseError l) => String -> EM l Double

Choice (of Monad)

failure :: e -> m a



String -> m Double
run :: String -> Maybe Double

Choice (of Monad)

failure :: e -> m a



String -> m Double
run :: String -> Maybe Double
run :: ...

Thanks

Explicitly Typed Exceptions For Haskell (PADL'10)

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Explicitly Typed Exceptions For Haskell (PADL'10)

Uploaded by

Copyright:

Available Formats

Explicitly Typed Exceptions

for Haskell (2011?)

Wednesday, January 20, 2010

• Compare this code in a programming language:

• with the equivalent Haskell code

• Both can fail with an exception

José Iborra Universidad Politécnica de Valencia

Wednesday, January 20, 2010

• Compare this code in a programming language:

• with the equivalent Haskell code

• Both can fail with an exception

José Iborra Universidad Politécnica de Valencia

Wednesday, January 20, 2010

• Detected and enforced by the compiler

• Usually explicit: possible exceptions appear on the type

• the programmer has no need to think “what

José Iborra Universidad Politécnica de Valencia

Wednesday, January 20, 2010

• Detected and enforced by the compiler

• Usually explicit: possible exceptions appear on the type

• the programmer has no need to think “what

• Checked exceptions are not always a good

José Iborra Universidad Politécnica de Valencia

Wednesday, January 20, 2010

To check or not to check ?

“I used to think that checked exceptions were really

“I completely agree that checked exceptions

José Iborra Universidad Politécnica de Valencia

Wednesday, January 20, 2010

Extensible Hierarchical Explicit Checked Traced

Haskell 98 (IO) Limited

GHC* - An extensible dynamically typed hierarchy of Exceptions - S. Marlow (2006)

José Iborra Universidad Politécnica de Valencia

Wednesday, January 20, 2010

Error handling in Haskell

eval :: Expr -> Double

José Iborra Universidad Politécnica de Valencia

Wednesday, January 20, 2010

Error handling in Haskell

eval :: Expr -> Double

José Iborra Universidad Politécnica de Valencia

Wednesday, January 20, 2010

Error handling in Haskell

eval :: Expr -> Either exception Double

José Iborra Universidad Politécnica de Valencia

Wednesday, January 20, 2010

Error handling in Haskell

eval :: Expr -> Either DivByZero Double

José Iborra Universidad Politécnica de Valencia

Wednesday, January 20, 2010

Error handling in Haskell

eval :: Expr -> Either DivByZero Double

José Iborra Universidad Politécnica de Valencia

Wednesday, January 20, 2010

Error handling in Haskell

eval :: Expr -> Either DivByZero Double

José Iborra Universidad Politécnica de Valencia

Wednesday, January 20, 2010

Error handling in Haskell

eval :: Expr -> Either DivByZero Double

José Iborra Universidad Politécnica de Valencia

Wednesday, January 20, 2010

Error handling in Haskell