Movatterモバイル変換

{-# LANGUAGE Trustworthy #-}{-# LANGUAGE NoImplicitPrelude           , ExistentialQuantification           , MagicHash           , RecordWildCards           , PatternSynonyms  #-}{-# OPTIONS_HADDOCK hide #-}------------------------------------------------------------------------------- |-- 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.0instanceShowSomeExceptionwhereshowsPrecp(SomeExceptione)=showsPrecpe{- |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=SomeExceptionfromException(SomeExceptione)=caste-- | Render this exception value in a human-friendly manner.---- Default implementation: @'show'@.---- @since 4.8.0.0displayException::e->StringdisplayException=show-- | @since 3.0instanceExceptionSomeExceptionwheretoExceptionse=sefromException=JustdisplayException(SomeExceptione)=displayExceptione-- |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=toExceptionDivideByZerooverflowException=toExceptionOverflowratioZeroDenomException=toExceptionRatioZeroDenominatorunderflowException=toExceptionUnderflow-- | @since 4.0.0.0instanceExceptionArithException-- | @since 4.0.0.0instanceShowArithExceptionwhereshowsPrec_Overflow=showString"arithmetic overflow"showsPrec_Underflow=showString"arithmetic underflow"showsPrec_LossOfPrecision=showString"loss of precision"showsPrec_DivideByZero=showString"divide by zero"showsPrec_Denormal=showString"denormal"showsPrec_RatioZeroDenominator=showString"Ratio has zero denominator"