explicitly typed exceptions for haskell (padl'10)

8/14/2019 Explicitly Typed Exceptions for Haskell (PADL'10)

1/101

Explicitly Typed Exceptionsfor Haskell (2011?)

Jos IborraUniversidad Politcnica de Valencia

PADL 2010

Wednesday, January 20, 2010


2/101

Jos Iborra

Explicitly Typed Exceptions for Haskell PADL10

Universidad Politcnica de Valencia

Compare this code in a programming language:

with the equivalent Haskell code

Both can fail with an exception

but only one compiler detects it

publicstaticvoid main(String[] args) { String filepath = args[1]; Reader f = new FileReader(filepath);

doSomethingWith(f); }

main = dofilepath


3/101


4/101

Jos Iborra



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 whatexceptions can be raised inside this block ?



5/101

Jos Iborra



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 whatexceptions can be raised inside this block ?

Checked exceptions are not always a goodthing



6/101

Jos Iborra



To check or not to check ?

I used to think that checked exceptions were reallygreat - Bruce Eckel*

I completely agree that checked exceptionsare a wonderful feature. Its just that existing

implementations are notAnders Heljsberg*

* - http://www.artima.com/intv/handcuffs.html

http://www.artima.com/intv/handcuffs.htmlhttp://www.artima.com/intv/handcuffs.htmlhttp://www.artima.com/intv/handcuffs.htmlhttp://www.artima.com/intv/handcuffs.htmlhttp://www.artima.com/intv/handcuffs.html


7/101

Jos Iborra



Exceptions in Haskell

Extensible Hierarchical Explicit Checked Traced

Haskell 98 (IO) Limited

GHC*(IO) Yes Yes

Either/ErrorTmonad

Yesbut not

composableYes Yes

Yesbut wrongsemantics

EMmonad Yes Yes Yes Yes Yes!

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



8/101

Jos Iborra



Error handling in Haskell

data Expr = Add Expr Expr | Div Expr Expr | Val Double

eval:: Expr -> Double

eval (Val x) = xeval (Add e1 e2) = eval e1 + eval e2

eval (Div e1 e2) = eval e1 / eval e2



9/101

Jos Iborra





eval:: Expr -> Double


eval (Div e1 e2) = caseeval e2 of

0 -> exception !

x2 -> eval e1 / x2



10/101

Jos Iborra





eval:: Expr -> Either exception Double



0 -> Left exception

x2 -> Right (eval e1 / x2)

data Either a b = Left a | Right b



11/101

Jos Iborra





data DivByZero = DivByZero deriving Show

eval:: Expr -> Either DivByZero Doubleeval (Val x) = x

eval (Add e1 e2) = eval e1 + eval e2


0 -> Left DivByZero





12/101

Jos Iborra






eval:: Expr -> Either DivByZero Doubleeval (Val x) = x



0 -> Left DivByZero





13/101

Jos Iborra






eval:: Expr -> Either DivByZero Doubleeval (Val x) = Right x



0 -> Left DivByZero





14/101

Jos Iborra







eval (Add e1 e2) = caseeval e1 of

Right x1 -> caseeval e2 of

Right x2 -> Right(x1 + x2)


0 -> Left DivByZero





15/101

Jos Iborra











Right 0 -> Left DivByZero

Right x2 -> Right (eval e1 / x2)




16/101

Jos Iborra












Right x2 -> caseeval e1 ofRight x1 -> Right(x1 / x2)




17/101

Jos Iborra








Left e -> Left e




Right 0 -> Left DivByZeroRight x2 -> caseeval e1 of

Right x1 -> Right(x1 / x2)




18/101

Jos Iborra








Left e -> Left e


Left e -> Left e


eval (Div e1 e2) = caseeval e2 ofRight 0 -> Left DivByZero





E li i l T d E i f H k ll PADL10


19/101

Jos Iborra








Left e -> Left e


Left e -> Left e


eval (Div e1 e2) = caseeval e2 ofLeft e -> Left e






E li i l T d E i f H k ll PADL10


20/101

Jos Iborra








Left e -> Left e


Left e -> Left e





Left e -> Left e




E li itl T d E ti f H k ll PADL10


21/101

Jos Iborra




data Expr = Add Expr Expr | Div Expr Expr | Val Doubledata DivByZero = DivByZero deriving Show

eval:: Expr -> Either DivByZero Double

eval (Val x) = Right x


Left e -> Left e

Right x1 -> caseeval e2 ofLeft e -> Left e



Left e -> Left e



Left e -> Left eRight x1 -> Right(x1 / x2)




22/101

Jos Iborra

Explicitly Typed Exceptions for Haskell PADL 10


Error handling with monads





Left e -> Left e

Right x1 -> caseeval e2 ofLeft e -> Left e



Left e -> Left e



Left e -> Left eRight x1 -> Right(x1 / x2)

Left e >>= f = Left e

Right x >>= f = f x



23/101



24/101

Jos Iborra







eval (Add e1 e2) = eval e1>>= \x1 -> eval e2 >>=\x2 ->

Right(x1 + x2)




Left e -> Left e



Right x >>= f = f x




25/101

Jos Iborra








Right(x1 + x2)

eval (Div e1 e2) = eval e2>>= \x2 -> casex2 of

0 -> Left DivByZero

x2 -> caseeval e1 of

Left e -> Left e



Right x >>= f = f x




26/101

Jos Iborra








Right(x1 + x2)


0 -> Left DivByZero

x2 -> eval e1>>= \x1 -> Right(x1 / x2)


Right x >>= f = f x




27/101

Jos Iborra

p y yp p







Right(x1 + x2)


0 -> Left DivByZero

x2 -> eval e1>>= \x1 -> Right(x1 / x2)

instance Error e => Monad (Either e) where

Left e >>= f = Left eRight x >>= f = f x

return = Right




28/101

Jos Iborra

p y yp p





eval (Val x) = return x


Right(x1 + x2)

eval (Div e1 e2) = eval e2>>= \x2 -> case x2 of

0 -> Left DivByZero

x2 -> eval e1>>= \x1 -> Right(x1 / x2)



return = Right




29/101

Jos Iborra

p y yp p








return(x1 + x2)


0 -> Left DivByZero

x2 -> eval e1>>= \x1 -> Right(x1 / x2)



return = Right




30/101

Jos Iborra Universidad Politcnica de Valencia







return(x1 + x2)


0 -> Left DivByZero

x2 -> eval e1>>= \x1 -> return(x1 / x2)



return = Right




31/101







eval (Add e1 e2) = do x1 = \x2 ->

case x2 of

0 -> Left DivByZero

x2 -> eval e1>>= \x1 -> return(x1 / x2)

instance Error e => Monad (Either e) whereLeft e >>= f = Left e

Right x >>= f = f x

return = Right




32/101







eval (Add e1 e2) = do x1 >= f = Left e

Right x >>= f = f x

return = Right



33/101



34/101



catch (Right x) handler = Right x

catch (Left e) handler = handler e





eval (Add e1 e2) = do x1


35/101


The Either Monad







36/101


The Either Monad User extensible Hierarchical Checked Explicit

parse :: String -> Either ParseError Expr







37/101





eval:: Expr -> Either DivByZero Doubleparse :: String -> Either ParseError Expr




38/101






data ParseOrDivError = ParseE ParseError

| EvalE DivByZero



39/101



40/101







| 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

run :: String -> Either ParseOrDivError Double

run str = do { e


41/101







| EvalE DivByZero







run str = do { e


42/101







| EvalE DivByZero







run str = do { e


43/101







| EvalE DivByZero


run str = do { e


44/101







| EvalE DivByZero


run str = do

e


45/101







| EvalE DivByZero


run str = do

e return 0




46/101







| EvalE DivByZero


run str = do

e return 0

Warning: Pattern match(es) are non-exhaustiveIn a case alternative:Patterns not matched:

ParseE




47/101







| EvalE DivByZero


run str = do

e return 0




48/101


A monad for Explicitly Typed Exceptions




49/101


Fixing the composability problem

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




50/101



Apply the extensible + hierarchical exceptions datatype ofMarlow*





51/101



Apply the extensible + hierarchical exceptions datatype ofMarlow*data SomeException = e. (Show e, Typeable e) => SomeException e

class Exception e where





52/101





fromException :: SomeException -> e

toException :: e -> SomeException





53/101







defining a new monad of non-explicit, composableexceptions





54/101








newtype C# a = C# (Either SomeException a)

deriving Monad -- C# is isomorphic to Either

throwC# :: Exception e => e -> C# a





55/101











throwC# = C# . Left . toException





56/101
















57/101












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





58/101













User extensible Hierarchical Checked Explicit





59/101


















60/101


















61/101


















62/101


















63/101


data Expr = Add Expr Expr | Div Expr Expr | Val Doubledata DivByZero = DivByZero deriving (Show,Typeable)

instance Exception DivByZero

eval:: Expr -> C# Double


eval (Add e1 e2) = do x1 C# Double

run str = do { e


64/101


The Explicit Exceptions Monad


class Exception e=> Throws e l

throwEM :: Throws e l => e -> EM l athrowEM = EM . Left . toException

newtype EM l a = EM (Either SomeException a) deriving Monad



65/101



66/101



Idea: the type of a computation includes the exceptions itmay throw.

Establish a type-level relationship between a computationand every exception it may throw

Encoded as a list of type class constraints


class Exception e=> Throws e l






67/101



Idea: the type of a computation includes the exceptions itmay throw.

Establish a type-level relationship between a computationand every exception it may throw

Encoded as a list of type class constraints


This is not the most

general typeclass Exception e=> Throws e l






68/101


data Expr = Add Expr Expr | Div Expr Expr | Val Doubledata DivByZero = DivByZero deriving (Show,Typeable)

instance Exception DivByZero

eval:: Throws DivByZero l => Expr -> EM l Double


eval (Add e1 e2) = do x1 EM l Expr

run :: (Throws DivByZero l, Throws ParseError l) =>

String -> EM l Double

run str = do { e


69/101



EM a >>=EMk = EM (a >>=Either ...)

returnEM = EM . returnEither

throwEM :: Throws e l => e -> EM l athrowEM = 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 -> xrunEM (EM (Right x)) = x

tryEM :: EM Any x -> Either SomeException xtryEM (EM x) = x

private

public

The Explicit Exceptions Monad Kernel(a la Lightweight Dependent Types)*

* - Lightweight static capabilities, Kiselyov & Shan, 2007




70/101


Reasoning about exceptions

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




71/101



|M| = m |N| = n

|M >>= N| = m n

|M| =m |N| = n

|if H then M else N

|=m n

|throw e| = {e}|return H| = {} |M| = e2


|C| = c |H| = h

|catch C (e H)| = (c \ {e}) h




72/101



|M| = m |N| = n

|M >>= N| = m n

|M| =m |N| = n

|if H then M else N

|=m n



|C| = c |H| = h

|catch C (e H)| = (c \ {e}) h




73/101



|M| = m |N| = n

|M >>= N| = m n

|M| =m |N| = n

|if H then M else N

|=m n



|C| = c |H| = h

|catch C (e H)| = (c \ {e}) h




74/101


Implementing Catch

catch :: Exception e => EM (Caught e l) a -> (e -> EM l a) -> EM l a

catch = ... --omitted, as before

dataCaught e linstanceThrows e (Caught e l)

instance Throws e l => Throws e (Caught e1 l)

|C| = c |H| = h

|catch C (e H)| = (c \ {e}) h




75/101


Implementing Catch





This is not the mostgeneral type

|C| = c |H| = h

|catch C (e H)| = (c \ {e}) h




76/101


Implementing Catch





|C| = c |H| = h

|catch C (e H)| = (c \ {e}) h



C


77/101


Implementing Catch





parse :: Throws ParseError l => String -> EM l Expr

run :: ... => String -> ...

run str = do

e ...

eval e

|C| = c |H| = h

|catch C (e H)| = (c \ {e}) h



I l C h


78/101


Implementing Catch






run :: ... => String -> ...

run str = do

e ...

eval e

(`catch` \ParseError -> ..) :: EM (Caught ParseError l2) a -> EM l2 a

|C| = c |H| = h

|catch C (e H)| = (c \ {e}) h



I l C h


79/101


Implementing Catch






run :: ... => String -> ...

run str = do

e ...

eval e


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

|C| = c |H| = h

|catch C (e H)| = (c \ {e}) h



80/101


I l i C h


81/101


Implementing Catch






run :: ... => String -> ...

run str = do

e ...

eval e



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

|C| = c |H| = h

|catch C (e H)| = (c \ {e}) h



I l i C h


82/101


Implementing Catch






run :: ... => String -> ...

run str = do

e ...

eval e

|C| = c |H| = h

|catch C (e H)| = (c \ {e}) h



I l i C h


83/101


Implementing Catch






run :: ... => String -> ...

run str = do

e ...

eval e

|C| = c |H| = h

|catch C (e H)| = (c \ {e}) h



I l i C h


84/101


Implementing Catch






run :: ... => String -> ...

run str = do

e ...

eval e

(`catch` \DivByZero -> ..) :: EM (Caught DivByZero l2) a -> EM l2 a

|C| = c |H| = h

|catch C (e H)| = (c \ {e}) h



I l ti C t h


85/101


Implementing Catch






run :: ... => String -> ...

run str = do

e ...

eval e



|C| = c |H| = h

|catch C (e H)| = (c \ {e}) h



86/101


I l ti C t h


87/101


Implementing Catch






run :: ... => String -> ...

run str = do

e ...

eval e



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

|C| = c |H| = h

|catch C (e H)| = (c \ {e}) h



R i EM t ti


88/101


Running EM computations

Checked version demanding that no exceptions leak:

runEM:: EM l a -> a

runEM (EM (Right x)) = x

:t parse some string

:t runEM (parse some string)No instance for (Throws ParseError l)

Possible fix:

add an instance declaration for (Throws ParseError l)

parse some string :: Throws ParseError l => EM l Expr





89/101


Unchecked version accepting computations which mayraise any exception


data Any

instanceThrows e Any

tryEM :: EM Any a -> Either SomeException a

tryEM (EM x) = x

:t tryEM (parse this)

tryEM (parse this) :: Either SomeException Expr



90/101




91/101


Unchecked version accepting computations which mayraise any exception


data Any

instanceThrows e Any

tryEM :: EM Any a -> Either SomeException a

tryEM (EM x) = x

:t tryEM (parse this)

tryEM (parse this) :: Either SomeException Expr



92/101




93/101



Selectively turning exceptions into unchecked exceptions

data OnlyUnchecked

class Exception e => UncheckedException e

instance UncheckedException e => Throws e OnlyUnchecked

runEM :: EM OnlyUnchecked a -> a

runEM (EM (Right x)) = xrunEM (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 ...

type flag





94/101




I completely agree that checked exceptionsare a wonderful feature. Its just that existing




http://www.artima.com/intv/handcuffs.html


95/101




I completely agree that checked exceptionsare a wonderful feature. Itsjust that existing


* - Monads are like Burritos, Brent Yorgey

Burritos* make great exception libraries -Jose Iborra

http://www.artima.com/intv/handcuffs.htmlhttp://www.artima.com/intv/handcuffs.htmlhttp://www.artima.com/intv/handcuffs.htmlhttp://www.artima.com/intv/handcuffs.htmlhttp://www.artima.com/intv/handcuffs.htmlhttp://www.artima.com/intv/handcuffs.html


96/101


Choice (of Monad)


97/101


( )

class Monad m => MonadFailure e m where

failure :: e -> m a

instanceMonadFailure 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

run :: (MonadFailure DivByZero m, MonadFailure ParseError m) =>

String -> m Double

parse :: (MonadFailure ParseError m) => String -> m Expr

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



Choice (of Monad)


98/101



failure :: e -> m a






String -> m Double

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





Choice (of Monad)


99/101



failure :: e -> m a






String -> m Double

run :: String -> Maybe Double






Choice (of Monad)


100/101



failure :: e -> m a






String -> m Double

run :: String -> Maybe Double


run :: ...





101/101

Thanks

explicitly typed exceptions for haskell (padl'10)

Documents