Movatterモバイル変換

{-# LANGUAGE Trustworthy #-}{-# LANGUAGE NoImplicitPrelude           , ExistentialQuantification           , MagicHash           , RecordWildCards           , PatternSynonyms  #-}{-# OPTIONS_HADDOCK not-home #-}------------------------------------------------------------------------------- |-- Module      :  GHC.Exception.Type-- Copyright   :  (c) The University of Glasgow, 1998-2002-- License     :  see libraries/base/LICENSE---- Maintainer  :  cvs-ghc@haskell.org-- Stability   :  internal-- Portability :  non-portable (GHC extensions)---- Exceptions and exception-handling functions.-------------------------------------------------------------------------------moduleGHC.Exception.Type(Exception(..)-- Class,SomeException(..),ArithException(..),divZeroException,overflowException,ratioZeroDenomException,underflowException)whereimportData.MaybeimportData.Typeable(Typeable,cast)-- loop: Data.Typeable -> GHC.Err -> GHC.ExceptionimportGHC.BaseimportGHC.Show{- |The @SomeException@ type is the root of the exception type hierarchy.When an exception of type @e@ is thrown, behind the scenes it isencapsulated in a @SomeException@.-}dataSomeException=foralle.Exceptione=>SomeExceptione-- | @since 3.0instanceShowSomeExceptionwhereshowsPrec :: Int -> SomeException -> ShowSshowsPrecIntp(SomeExceptionee)=Int -> e -> ShowSforall a. Show a => Int -> a -> ShowSshowsPrecIntpee{- |Any type that you wish to throw or catch as an exception must be aninstance of the @Exception@ class. The simplest case is a new exceptiontype directly below the root:> data MyException = ThisException | ThatException>     deriving Show>> instance Exception MyExceptionThe default method definitions in the @Exception@ class do what we needin this case. You can now throw and catch @ThisException@ and@ThatException@ as exceptions:@*Main> throw ThisException \`catch\` \\e -> putStrLn (\"Caught \" ++ show (e :: MyException))Caught ThisException@In more complicated examples, you may wish to define a whole hierarchyof exceptions:> ---------------------------------------------------------------------> -- 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 = frontendExceptionFromExceptionWe can now catch a @MismatchedParentheses@ exception as@MismatchedParentheses@, @SomeFrontendException@ or@SomeCompilerException@, but not other types, e.g. @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@-}class(Typeablee,Showe)=>ExceptionewheretoException::e->SomeExceptionfromException::SomeException->MaybeetoException=e -> SomeExceptionforall e. Exception e => e -> SomeExceptionSomeExceptionfromException(SomeExceptionee)=e -> Maybe eforall a b. (Typeable a, Typeable b) => a -> Maybe bcastee-- | Render this exception value in a human-friendly manner.---- Default implementation: @'show'@.---- @since 4.8.0.0displayException::e->StringdisplayException=e -> Stringforall a. Show a => a -> Stringshow-- | @since 3.0instanceExceptionSomeExceptionwheretoException :: SomeException -> SomeExceptiontoExceptionSomeExceptionse=SomeExceptionsefromException :: SomeException -> Maybe SomeExceptionfromException=SomeException -> Maybe SomeExceptionforall a. a -> Maybe aJustdisplayException :: SomeException -> StringdisplayException(SomeExceptionee)=e -> Stringforall e. Exception e => e -> StringdisplayExceptionee-- |Arithmetic exceptions.dataArithException=Overflow|Underflow|LossOfPrecision|DivideByZero|Denormal|RatioZeroDenominator-- ^ @since 4.6.0.0deriving(Eq-- ^ @since 3.0,Ord-- ^ @since 3.0)divZeroException,overflowException,ratioZeroDenomException,underflowException::SomeExceptiondivZeroException :: SomeExceptiondivZeroException=ArithException -> SomeExceptionforall e. Exception e => e -> SomeExceptiontoExceptionArithExceptionDivideByZerooverflowException :: SomeExceptionoverflowException=ArithException -> SomeExceptionforall e. Exception e => e -> SomeExceptiontoExceptionArithExceptionOverflowratioZeroDenomException :: SomeExceptionratioZeroDenomException=ArithException -> SomeExceptionforall e. Exception e => e -> SomeExceptiontoExceptionArithExceptionRatioZeroDenominatorunderflowException :: SomeExceptionunderflowException=ArithException -> SomeExceptionforall e. Exception e => e -> SomeExceptiontoExceptionArithExceptionUnderflow-- | @since 4.0.0.0instanceExceptionArithException-- | @since 4.0.0.0instanceShowArithExceptionwhereshowsPrec :: Int -> ArithException -> ShowSshowsPrecInt_ArithExceptionOverflow=String -> ShowSshowStringString"arithmetic overflow"showsPrecInt_ArithExceptionUnderflow=String -> ShowSshowStringString"arithmetic underflow"showsPrecInt_ArithExceptionLossOfPrecision=String -> ShowSshowStringString"loss of precision"showsPrecInt_ArithExceptionDivideByZero=String -> ShowSshowStringString"divide by zero"showsPrecInt_ArithExceptionDenormal=String -> ShowSshowStringString"denormal"showsPrecInt_ArithExceptionRatioZeroDenominator=String -> ShowSshowStringString"Ratio has zero denominator"