Movatterモバイル変換

{-# LANGUAGE Trustworthy #-}{-# LANGUAGE NoImplicitPrelude, MagicHash #-}{-# LANGUAGE StandaloneDeriving #-}------------------------------------------------------------------------------- |-- Module      :  Control.Exception.Base-- Copyright   :  (c) The University of Glasgow 2001-- License     :  BSD-style (see the file libraries/base/LICENSE)---- Maintainer  :  libraries@haskell.org-- Stability   :  experimental-- Portability :  non-portable (extended exceptions)---- Extensible exceptions, except for multiple handlers.-------------------------------------------------------------------------------moduleControl.Exception.Base(-- * The Exception typeSomeException(..),Exception(..),IOException,ArithException(..),ArrayException(..),AssertionFailed(..),SomeAsyncException(..),AsyncException(..),asyncExceptionToException,asyncExceptionFromException,NonTermination(..),NestedAtomically(..),BlockedIndefinitelyOnMVar(..),FixIOException(..),BlockedIndefinitelyOnSTM(..),AllocationLimitExceeded(..),CompactionFailed(..),Deadlock(..),NoMethodError(..),PatternMatchFail(..),RecConError(..),RecSelError(..),RecUpdError(..),ErrorCall(..),TypeError(..),-- #10284, custom error type for deferred type errors-- * Throwing exceptionsthrowIO,throw,ioError,throwTo,-- * Catching Exceptions-- ** The @catch@ functionscatch,catchJust,-- ** The @handle@ functionshandle,handleJust,-- ** The @try@ functionstry,tryJust,onException,-- ** The @evaluate@ functionevaluate,-- ** The @mapException@ functionmapException,-- * Asynchronous Exceptions-- ** Asynchronous exception controlmask,mask_,uninterruptibleMask,uninterruptibleMask_,MaskingState(..),getMaskingState,-- * Assertionsassert,-- * Utilitiesbracket,bracket_,bracketOnError,finally,-- * Calls for GHC runtimerecSelError,recConError,runtimeError,nonExhaustiveGuardsError,patError,noMethodBindingError,absentError,absentSumFieldError,typeError,nonTermination,nestedAtomically,)whereimportGHC.BaseimportGHC.IOhiding(bracket,finally,onException)importGHC.IO.ExceptionimportGHC.ExceptionimportGHC.Show-- import GHC.Exception hiding ( Exception )importGHC.Conc.SyncimportData.Either------------------------------------------------------------------------------- Catching exceptions-- | The function 'catchJust' is like 'catch', but it takes an extra-- argument which is an /exception predicate/, a function which-- selects which type of exceptions we\'re interested in.---- > catchJust (\e -> if isDoesNotExistErrorType (ioeGetErrorType e) then Just () else Nothing)-- >           (readFile f)-- >           (\_ -> do hPutStrLn stderr ("No such file: " ++ show f)-- >                     return "")---- Any other exceptions which are not matched by the predicate-- are re-raised, and may be caught by an enclosing-- 'catch', 'catchJust', etc.catchJust::Exceptione=>(e->Maybeb)-- ^ Predicate to select exceptions->IOa-- ^ Computation to run->(b->IOa)-- ^ Handler->IOacatchJustpahandler=catchahandler'wherehandler'e=casepeofNothing->throwIOeJustb->handlerb-- | A version of 'catch' with the arguments swapped around; useful in-- situations where the code for the handler is shorter.  For example:---- >   do handle (\NonTermination -> exitWith (ExitFailure 1)) $-- >      ...handle::Exceptione=>(e->IOa)->IOa->IOahandle=flipcatch-- | A version of 'catchJust' with the arguments swapped around (see-- 'handle').handleJust::Exceptione=>(e->Maybeb)->(b->IOa)->IOa->IOahandleJustp=flip(catchJustp)------------------------------------------------------------------------------- 'mapException'-- | This function maps one exception into another as proposed in the-- paper \"A semantics for imprecise exceptions\".-- Notice that the usage of 'unsafePerformIO' is safe here.mapException::(Exceptione1,Exceptione2)=>(e1->e2)->a->amapExceptionfv=unsafePerformIO(catch(evaluatev)(\x->throwIO(fx)))------------------------------------------------------------------------------- 'try' and variations.-- | Similar to 'catch', but returns an 'Either' result which is-- @('Right' a)@ if no exception of type @e@ was raised, or @('Left' ex)@-- if an exception of type @e@ was raised and its value is @ex@.-- If any other type of exception is raised than it will be propogated-- up to the next enclosing exception handler.---- >  try a = catch (Right `liftM` a) (return . Left)try::Exceptione=>IOa->IO(Eitherea)trya=catch(a>>=\v->return(Rightv))(\e->return(Lefte))-- | A variant of 'try' that takes an exception predicate to select-- which exceptions are caught (c.f. 'catchJust').  If the exception-- does not match the predicate, it is re-thrown.tryJust::Exceptione=>(e->Maybeb)->IOa->IO(Eitherba)tryJustpa=dor<-tryacaserofRightv->return(Rightv)Lefte->casepeofNothing->throwIOeJustb->return(Leftb)-- | Like 'finally', but only performs the final action if there was an-- exception raised by the computation.onException::IOa->IOb->IOaonExceptioniowhat=io`catch`\e->do_<-whatthrowIO(e::SomeException)------------------------------------------------------------------------------- Some Useful Functions-- | When you want to acquire a resource, do some work with it, and-- then release the resource, it is a good idea to use 'bracket',-- because 'bracket' will install the necessary exception handler to-- release the resource in the event that an exception is raised-- during the computation.  If an exception is raised, then 'bracket' will-- re-raise the exception (after performing the release).---- A common example is opening a file:---- > bracket-- >   (openFile "filename" ReadMode)-- >   (hClose)-- >   (\fileHandle -> do { ... })---- The arguments to 'bracket' are in this order so that we can partially apply-- it, e.g.:---- > withFile name mode = bracket (openFile name mode) hClose--bracket::IOa-- ^ computation to run first (\"acquire resource\")->(a->IOb)-- ^ computation to run last (\"release resource\")->(a->IOc)-- ^ computation to run in-between->IOc-- returns the value from the in-between computationbracketbeforeafterthing=mask$\restore->doa<-beforer<-restore(thinga)`onException`aftera_<-afterareturnr-- | A specialised variant of 'bracket' with just a computation to run-- afterward.--finally::IOa-- ^ computation to run first->IOb-- ^ computation to run afterward (even if an exception-- was raised)->IOa-- returns the value from the first computationa`finally`sequel=mask$\restore->dor<-restorea`onException`sequel_<-sequelreturnr-- | A variant of 'bracket' where the return value from the first computation-- is not required.bracket_::IOa->IOb->IOc->IOcbracket_beforeafterthing=bracketbefore(constafter)(constthing)-- | Like 'bracket', but only performs the final action if there was an-- exception raised by the in-between computation.bracketOnError::IOa-- ^ computation to run first (\"acquire resource\")->(a->IOb)-- ^ computation to run last (\"release resource\")->(a->IOc)-- ^ computation to run in-between->IOc-- returns the value from the in-between computationbracketOnErrorbeforeafterthing=mask$\restore->doa<-beforerestore(thinga)`onException`aftera------- |A pattern match failed. The @String@ gives information about the-- source location of the pattern.newtypePatternMatchFail=PatternMatchFailString-- | @since 4.0instanceShowPatternMatchFailwhereshowsPrec_(PatternMatchFailerr)=showStringerr-- | @since 4.0instanceExceptionPatternMatchFail------- |A record selector was applied to a constructor without the-- appropriate field. This can only happen with a datatype with-- multiple constructors, where some fields are in one constructor-- but not another. The @String@ gives information about the source-- location of the record selector.newtypeRecSelError=RecSelErrorString-- | @since 4.0instanceShowRecSelErrorwhereshowsPrec_(RecSelErrorerr)=showStringerr-- | @since 4.0instanceExceptionRecSelError------- |An uninitialised record field was used. The @String@ gives-- information about the source location where the record was-- constructed.newtypeRecConError=RecConErrorString-- | @since 4.0instanceShowRecConErrorwhereshowsPrec_(RecConErrorerr)=showStringerr-- | @since 4.0instanceExceptionRecConError------- |A record update was performed on a constructor without the-- appropriate field. This can only happen with a datatype with-- multiple constructors, where some fields are in one constructor-- but not another. The @String@ gives information about the source-- location of the record update.newtypeRecUpdError=RecUpdErrorString-- | @since 4.0instanceShowRecUpdErrorwhereshowsPrec_(RecUpdErrorerr)=showStringerr-- | @since 4.0instanceExceptionRecUpdError------- |A class method without a definition (neither a default definition,-- nor a definition in the appropriate instance) was called. The-- @String@ gives information about which method it was.newtypeNoMethodError=NoMethodErrorString-- | @since 4.0instanceShowNoMethodErrorwhereshowsPrec_(NoMethodErrorerr)=showStringerr-- | @since 4.0instanceExceptionNoMethodError------- |An expression that didn't typecheck during compile time was called.-- This is only possible with -fdefer-type-errors. The @String@ gives-- details about the failed type check.---- @since 4.9.0.0newtypeTypeError=TypeErrorString-- | @since 4.9.0.0instanceShowTypeErrorwhereshowsPrec_(TypeErrorerr)=showStringerr-- | @since 4.9.0.0instanceExceptionTypeError------- |Thrown when the runtime system detects that the computation is-- guaranteed not to terminate. Note that there is no guarantee that-- the runtime system will notice whether any given computation is-- guaranteed to terminate or not.dataNonTermination=NonTermination-- | @since 4.0instanceShowNonTerminationwhereshowsPrec_NonTermination=showString"<<loop>>"-- | @since 4.0instanceExceptionNonTermination------- |Thrown when the program attempts to call @atomically@, from the @stm@-- package, inside another call to @atomically@.dataNestedAtomically=NestedAtomically-- | @since 4.0instanceShowNestedAtomicallywhereshowsPrec_NestedAtomically=showString"Control.Concurrent.STM.atomically was nested"-- | @since 4.0instanceExceptionNestedAtomically-----recSelError,recConError,runtimeError,nonExhaustiveGuardsError,patError,noMethodBindingError,absentError,typeError::Addr#->a-- All take a UTF8-encoded C stringrecSelErrors=throw(RecSelError("No match in record selector "++unpackCStringUtf8#s))-- No location info unfortunatelyruntimeErrors=errorWithoutStackTrace(unpackCStringUtf8#s)-- No location info unfortunatelyabsentErrors=errorWithoutStackTrace("Oops!  Entered absent arg "++unpackCStringUtf8#s)nonExhaustiveGuardsErrors=throw(PatternMatchFail(untangles"Non-exhaustive guards in"))recConErrors=throw(RecConError(untangles"Missing field in record construction"))noMethodBindingErrors=throw(NoMethodError(untangles"No instance nor default method for class operation"))patErrors=throw(PatternMatchFail(untangles"Non-exhaustive patterns in"))typeErrors=throw(TypeError(unpackCStringUtf8#s))-- GHC's RTS calls thisnonTermination::SomeExceptionnonTermination=toExceptionNonTermination-- GHC's RTS calls thisnestedAtomically::SomeExceptionnestedAtomically=toExceptionNestedAtomically-- Introduced by unarise for unused unboxed sum fieldsabsentSumFieldError::aabsentSumFieldError=absentError" in unboxed sum."#