GHC.Exception.Type

Авторские права	(c) Университет Глазго 1998-2002
Лицензия	см. libraries/base/LICENSE
Поддержка	cvs-ghc@haskell.org
Устойчивость	внутренняя
Переносимость	непереносимая (расширения GHC)
Безопасный Haskell	Достоверный
Язык	Haskell2010

class (Typeable e, Show e) => Exception e where Исходный код

Любой тип, который вы хотите бросить или перехватить как исключение, должен быть экземпляром класса Exception. Простейший случай — это новый тип исключения непосредственно под корнем:

data MyException = ThisException | ThatException
    deriving Show

instance Exception MyException

Определения методов по умолчанию в классе Exception делают то, что нам нужно в этом случае. Теперь вы можете бросить и перехватить ThisException и ThatException как исключения:

*Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException))
Caught ThisException

В более сложных примерах вы можете захотеть определить целую иерархию исключений:

---------------------------------------------------------------------
-- Make the root exception type for all the exceptions in a compiler

data SomeCompilerException = forall e . Exception e => SomeCompilerException e

instance Show SomeCompilerException where
    show (SomeCompilerException e) = show e

instance Exception SomeCompilerException

compilerExceptionToException :: Exception e => e -> SomeException
compilerExceptionToException = toException . SomeCompilerException

compilerExceptionFromException :: Exception e => SomeException -> Maybe e
compilerExceptionFromException x = do
    SomeCompilerException a <- fromException x
    cast a

---------------------------------------------------------------------
-- Make a subhierarchy for exceptions in the frontend of the compiler

data SomeFrontendException = forall e . Exception e => SomeFrontendException e

instance Show SomeFrontendException where
    show (SomeFrontendException e) = show e

instance Exception SomeFrontendException where
    toException = compilerExceptionToException
    fromException = compilerExceptionFromException

frontendExceptionToException :: Exception e => e -> SomeException
frontendExceptionToException = toException . SomeFrontendException

frontendExceptionFromException :: Exception e => SomeException -> Maybe e
frontendExceptionFromException x = do
    SomeFrontendException a <- fromException x
    cast a

---------------------------------------------------------------------
-- Make an exception type for a particular frontend compiler exception

data MismatchedParentheses = MismatchedParentheses
    deriving Show

instance Exception MismatchedParentheses where
    toException   = frontendExceptionToException
    fromException = frontendExceptionFromException

Теперь мы можем перехватить исключение MismatchedParentheses как MismatchedParentheses, SomeFrontendException или SomeCompilerException, но не другие типы, например IOException:

*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: IOException))
*** Exception: MismatchedParentheses

data SomeException Исходный код

Тип SomeException — корень иерархии типов исключений. При возникновении исключения типа e, оно инкапсулируется в SomeException.

data ArithException Исходный код

Исключения арифметических операций.

divZeroException :: SomeException Исходный код

overflowException :: SomeException Исходный код

ratioZeroDenomException :: SomeException Исходный код

underflowException :: SomeException Исходный код