Copyright	(c) Dong Han 2017-2018
License	BSD
Maintainer	winterland1989@gmail.com
Stability	experimental
Portability	non-portable
Safe Haskell	Safe-Inferred
Language	Haskell2010

Z.IO.Exception

Contents

The SomeIOException type
Builtin io exception types
Throw io exceptions
Sync exception tools
Re-exports

Description

This module implemented extensible io exception following approach described in /An Extensible Dynamically-Typed Hierarchy of Exceptions/ by Simon Marlow. The implementation in this module has simplified to meet common need. User who want to catch certain type of exceptions can directly use exception types this module provide, which are modeled after IOErrorType from GHC.IO.Exception.

Functions from this package will throw exceptions from this module only instead of the old IOError on IO exceptions. Exceptions from this module contain IOEInfo which is pretty detailed, but this also require user of this module do some extra work to keep error message's quality(provide CallStack, device informations, etc.). New defined IO exceptions are encouraged to include a IOEInfo, since it helps a lot when debugging.

Example for library author defining new io exception:

  data MyNetworkException = MyNetworkException IOEInfo ... deriving Show
  instance Exception MyNetworkException where
        toException = ioExceptionToException
        fromException = ioExceptionFromException

If you're dealing with OS's errno directly, you should convert the errno to libuv's errno in C side with uv_translate_sys_error from hs_uv.h, then use 'throwUVIfMinus/throwUVError' from this module.

Synopsis

data SomeIOException = forall e.Exception e => SomeIOException e
ioExceptionToException :: Exception e => e -> SomeException
ioExceptionFromException :: Exception e => SomeException -> Maybe e
data IOEInfo = IOEInfo {
- ioeName :: Text
- ioeDescription :: Text
- ioeCallStack :: CallStack
}
data AlreadyExists = AlreadyExists IOEInfo
data NoSuchThing = NoSuchThing IOEInfo
data ResourceBusy = ResourceBusy IOEInfo
data ResourceExhausted = ResourceExhausted IOEInfo
data UnexpectedEOF = UnexpectedEOF IOEInfo
data IllegalOperation = IllegalOperation IOEInfo
data PermissionDenied = PermissionDenied IOEInfo
data UnsatisfiedConstraints = UnsatisfiedConstraints IOEInfo
data SystemError = SystemError IOEInfo
data ProtocolError = ProtocolError IOEInfo
data OtherError = OtherError IOEInfo
data InvalidArgument = InvalidArgument IOEInfo
data InappropriateType = InappropriateType IOEInfo
data HardwareFault = HardwareFault IOEInfo
data UnsupportedOperation = UnsupportedOperation IOEInfo
data TimeExpired = TimeExpired IOEInfo
data ResourceVanished = ResourceVanished IOEInfo
data Interrupted = Interrupted IOEInfo
throwOOMIfNull :: HasCallStack => IO (Ptr a) -> IO (Ptr a)
throwUVIfMinus :: (HasCallStack, Integral a) => IO a -> IO a
throwUVIfMinus_ :: (HasCallStack, Integral a) => IO a -> IO ()
throwUVIf :: (HasCallStack, Integral a) => IO a -> (a -> Bool) -> IO a
throwUVIf_ :: (HasCallStack, Integral a) => IO a -> (a -> Bool) -> IO ()
throwUV :: (Integral a, HasCallStack) => a -> IO b
throwECLOSED :: HasCallStack => IO a
throwECLOSEDSTM :: HasCallStack => STM a
throwUVError :: CInt -> IOEInfo -> IO a
throwOtherError :: HasCallStack => Text -> Text -> IO a
unwrap :: (HasCallStack, Print e) => Text -> Either e a -> IO a
unwrap' :: HasCallStack => Text -> Text -> Maybe a -> IO a
catchSync :: Exception e => IO a -> (e -> IO a) -> IO a
ignoreSync :: IO a -> IO ()
assert :: Bool -> a -> a
data ArrayException
- = IndexOutOfBounds String
- | UndefinedElement String
data Handler a = Exception e => Handler (e -> IO a)
catches :: IO a -> [Handler a] -> IO a
allowInterrupt :: IO ()
newtype TypeError = TypeError String
newtype RecUpdError = RecUpdError String
newtype RecSelError = RecSelError String
newtype RecConError = RecConError String
newtype PatternMatchFail = PatternMatchFail String
data NonTermination = NonTermination
newtype NoMethodError = NoMethodError String
data NestedAtomically = NestedAtomically
tryJust :: Exception e => (e -> Maybe b) -> IO a -> IO (Either b a)
try :: Exception e => IO a -> IO (Either e a)
onException :: IO a -> IO b -> IO a
mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
handleJust :: Exception e => (e -> Maybe b) -> (b -> IO a) -> IO a -> IO a
handle :: Exception e => (e -> IO a) -> IO a -> IO a
finally :: IO a -> IO b -> IO a
catchJust :: Exception e => (e -> Maybe b) -> IO a -> (b -> IO a) -> IO a
bracket_ :: IO a -> IO b -> IO c -> IO c
bracketOnError :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
throwTo :: Exception e => ThreadId -> e -> IO ()
data SomeAsyncException = Exception e => SomeAsyncException e
data Deadlock = Deadlock
newtype CompactionFailed = CompactionFailed String
data BlockedIndefinitelyOnSTM = BlockedIndefinitelyOnSTM
data BlockedIndefinitelyOnMVar = BlockedIndefinitelyOnMVar
data AsyncException
- = StackOverflow
- | HeapOverflow
- | ThreadKilled
- | UserInterrupt
newtype AssertionFailed = AssertionFailed String
data AllocationLimitExceeded = AllocationLimitExceeded
ioError :: IOError -> IO a
asyncExceptionToException :: Exception e => e -> SomeException
asyncExceptionFromException :: Exception e => SomeException -> Maybe e
data MaskingState
- = Unmasked
- | MaskedInterruptible
- | MaskedUninterruptible
uninterruptibleMask_ :: IO a -> IO a
uninterruptibleMask :: ((forall a. IO a -> IO a) -> IO b) -> IO b
throwIO :: Exception e => e -> IO a
mask_ :: IO a -> IO a
mask :: ((forall a. IO a -> IO a) -> IO b) -> IO b
interruptible :: IO a -> IO a
getMaskingState :: IO MaskingState
evaluate :: a -> IO a
catch :: Exception e => IO a -> (e -> IO a) -> IO a
data ErrorCall where
- ErrorCallWithLocation String String
- pattern ErrorCall :: String -> ErrorCall
throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a
class (Typeable e, Show e) => Exception e where
- toException :: e -> SomeException
- fromException :: SomeException -> Maybe e
- displayException :: e -> String
data ArithException
- = Overflow
- | Underflow
- | LossOfPrecision
- | DivideByZero
- | Denormal
- | RatioZeroDenominator
data SomeException = Exception e => SomeException e
type HasCallStack = ?callStack :: CallStack
data CallStack
callStack :: HasCallStack => CallStack
module Z.IO.UV.Errno

The `SomeIOException` type

data SomeIOException Source #

The root type of all io exceptions, you can catch all io exception by catching this root type.

Constructors

forall e.Exception e => SomeIOException e

Instances

Instances details

Exception SomeIOException Source #
Instance details Defined in Z.IO.Exception Methods toException :: SomeIOException -> SomeException # fromException :: SomeException -> Maybe SomeIOException # displayException :: SomeIOException -> String #
Show SomeIOException Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> SomeIOException -> ShowS # show :: SomeIOException -> String # showList :: [SomeIOException] -> ShowS #

ioExceptionToException :: Exception e => e -> SomeException Source #

ioExceptionFromException :: Exception e => SomeException -> Maybe e Source #

Builtin io exception types

data IOEInfo Source #

IO exceptions informations.

Constructors

IOEInfo
Fields ioeName :: Text the errno name, e.g. EADDRINUSE, etc. empty if no errno. ioeDescription :: Text description for this io error, can be errno description, or some custom description if no errno. ioeCallStack :: CallStack lightweight partial call-stack

Instances

Instances details

Print IOEInfo Source #
Instance details Defined in Z.IO.Exception Methods toUTF8BuilderP :: Int -> IOEInfo -> Builder () #
Show IOEInfo Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> IOEInfo -> ShowS # show :: IOEInfo -> String # showList :: [IOEInfo] -> ShowS #

data AlreadyExists Source #

Constructors

AlreadyExists IOEInfo

Instances

Instances details

Exception AlreadyExists Source #
Instance details Defined in Z.IO.Exception Methods toException :: AlreadyExists -> SomeException # fromException :: SomeException -> Maybe AlreadyExists # displayException :: AlreadyExists -> String #
Show AlreadyExists Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> AlreadyExists -> ShowS # show :: AlreadyExists -> String # showList :: [AlreadyExists] -> ShowS #

data NoSuchThing Source #

Constructors

NoSuchThing IOEInfo

Instances

Instances details

Exception NoSuchThing Source #
Instance details Defined in Z.IO.Exception Methods toException :: NoSuchThing -> SomeException # fromException :: SomeException -> Maybe NoSuchThing # displayException :: NoSuchThing -> String #
Show NoSuchThing Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> NoSuchThing -> ShowS # show :: NoSuchThing -> String # showList :: [NoSuchThing] -> ShowS #

data ResourceBusy Source #

Constructors

ResourceBusy IOEInfo

Instances

Instances details

Exception ResourceBusy Source #
Instance details Defined in Z.IO.Exception Methods toException :: ResourceBusy -> SomeException # fromException :: SomeException -> Maybe ResourceBusy # displayException :: ResourceBusy -> String #
Show ResourceBusy Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> ResourceBusy -> ShowS # show :: ResourceBusy -> String # showList :: [ResourceBusy] -> ShowS #

data ResourceExhausted Source #

Constructors

ResourceExhausted IOEInfo

Instances

Instances details

Exception ResourceExhausted Source #
Instance details Defined in Z.IO.Exception Methods toException :: ResourceExhausted -> SomeException # fromException :: SomeException -> Maybe ResourceExhausted # displayException :: ResourceExhausted -> String #
Show ResourceExhausted Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> ResourceExhausted -> ShowS # show :: ResourceExhausted -> String # showList :: [ResourceExhausted] -> ShowS #

data UnexpectedEOF Source #

Constructors

UnexpectedEOF IOEInfo

Instances

Instances details

Exception UnexpectedEOF Source #
Instance details Defined in Z.IO.Exception Methods toException :: UnexpectedEOF -> SomeException # fromException :: SomeException -> Maybe UnexpectedEOF # displayException :: UnexpectedEOF -> String #
Show UnexpectedEOF Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> UnexpectedEOF -> ShowS # show :: UnexpectedEOF -> String # showList :: [UnexpectedEOF] -> ShowS #

data IllegalOperation Source #

Constructors

IllegalOperation IOEInfo

Instances

Instances details

Exception IllegalOperation Source #
Instance details Defined in Z.IO.Exception Methods toException :: IllegalOperation -> SomeException # fromException :: SomeException -> Maybe IllegalOperation # displayException :: IllegalOperation -> String #
Show IllegalOperation Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> IllegalOperation -> ShowS # show :: IllegalOperation -> String # showList :: [IllegalOperation] -> ShowS #

data PermissionDenied Source #

Constructors

PermissionDenied IOEInfo

Instances

Instances details

Exception PermissionDenied Source #
Instance details Defined in Z.IO.Exception Methods toException :: PermissionDenied -> SomeException # fromException :: SomeException -> Maybe PermissionDenied # displayException :: PermissionDenied -> String #
Show PermissionDenied Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> PermissionDenied -> ShowS # show :: PermissionDenied -> String # showList :: [PermissionDenied] -> ShowS #

data UnsatisfiedConstraints Source #

Constructors

UnsatisfiedConstraints IOEInfo

Instances

Instances details

Exception UnsatisfiedConstraints Source #
Instance details Defined in Z.IO.Exception Methods toException :: UnsatisfiedConstraints -> SomeException # fromException :: SomeException -> Maybe UnsatisfiedConstraints # displayException :: UnsatisfiedConstraints -> String #
Show UnsatisfiedConstraints Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> UnsatisfiedConstraints -> ShowS # show :: UnsatisfiedConstraints -> String # showList :: [UnsatisfiedConstraints] -> ShowS #

data SystemError Source #

Constructors

SystemError IOEInfo

Instances

Instances details

Exception SystemError Source #
Instance details Defined in Z.IO.Exception Methods toException :: SystemError -> SomeException # fromException :: SomeException -> Maybe SystemError # displayException :: SystemError -> String #
Show SystemError Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> SystemError -> ShowS # show :: SystemError -> String # showList :: [SystemError] -> ShowS #

data ProtocolError Source #

Constructors

ProtocolError IOEInfo

Instances

Instances details

Exception ProtocolError Source #
Instance details Defined in Z.IO.Exception Methods toException :: ProtocolError -> SomeException # fromException :: SomeException -> Maybe ProtocolError # displayException :: ProtocolError -> String #
Show ProtocolError Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> ProtocolError -> ShowS # show :: ProtocolError -> String # showList :: [ProtocolError] -> ShowS #

data OtherError Source #

Constructors

OtherError IOEInfo

Instances

Instances details

Exception OtherError Source #
Instance details Defined in Z.IO.Exception Methods toException :: OtherError -> SomeException # fromException :: SomeException -> Maybe OtherError # displayException :: OtherError -> String #
Show OtherError Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> OtherError -> ShowS # show :: OtherError -> String # showList :: [OtherError] -> ShowS #

data InvalidArgument Source #

Constructors

InvalidArgument IOEInfo

Instances

Instances details

Exception InvalidArgument Source #
Instance details Defined in Z.IO.Exception Methods toException :: InvalidArgument -> SomeException # fromException :: SomeException -> Maybe InvalidArgument # displayException :: InvalidArgument -> String #
Show InvalidArgument Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> InvalidArgument -> ShowS # show :: InvalidArgument -> String # showList :: [InvalidArgument] -> ShowS #

data InappropriateType Source #

Constructors

InappropriateType IOEInfo

Instances

Instances details

Exception InappropriateType Source #
Instance details Defined in Z.IO.Exception Methods toException :: InappropriateType -> SomeException # fromException :: SomeException -> Maybe InappropriateType # displayException :: InappropriateType -> String #
Show InappropriateType Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> InappropriateType -> ShowS # show :: InappropriateType -> String # showList :: [InappropriateType] -> ShowS #

data HardwareFault Source #

Constructors

HardwareFault IOEInfo

Instances

Instances details

Exception HardwareFault Source #
Instance details Defined in Z.IO.Exception Methods toException :: HardwareFault -> SomeException # fromException :: SomeException -> Maybe HardwareFault # displayException :: HardwareFault -> String #
Show HardwareFault Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> HardwareFault -> ShowS # show :: HardwareFault -> String # showList :: [HardwareFault] -> ShowS #

data UnsupportedOperation Source #

Constructors

UnsupportedOperation IOEInfo

Instances

Instances details

Exception UnsupportedOperation Source #
Instance details Defined in Z.IO.Exception Methods toException :: UnsupportedOperation -> SomeException # fromException :: SomeException -> Maybe UnsupportedOperation # displayException :: UnsupportedOperation -> String #
Show UnsupportedOperation Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> UnsupportedOperation -> ShowS # show :: UnsupportedOperation -> String # showList :: [UnsupportedOperation] -> ShowS #

data TimeExpired Source #

Constructors

TimeExpired IOEInfo

Instances

Instances details

Exception TimeExpired Source #
Instance details Defined in Z.IO.Exception Methods toException :: TimeExpired -> SomeException # fromException :: SomeException -> Maybe TimeExpired # displayException :: TimeExpired -> String #
Show TimeExpired Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> TimeExpired -> ShowS # show :: TimeExpired -> String # showList :: [TimeExpired] -> ShowS #

data ResourceVanished Source #

Constructors

ResourceVanished IOEInfo

Instances

Instances details

Exception ResourceVanished Source #
Instance details Defined in Z.IO.Exception Methods toException :: ResourceVanished -> SomeException # fromException :: SomeException -> Maybe ResourceVanished # displayException :: ResourceVanished -> String #
Show ResourceVanished Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> ResourceVanished -> ShowS # show :: ResourceVanished -> String # showList :: [ResourceVanished] -> ShowS #

data Interrupted Source #

Constructors

Interrupted IOEInfo

Instances

Instances details

Exception Interrupted Source #
Instance details Defined in Z.IO.Exception Methods toException :: Interrupted -> SomeException # fromException :: SomeException -> Maybe Interrupted # displayException :: Interrupted -> String #
Show Interrupted Source #
Instance details Defined in Z.IO.Exception Methods showsPrec :: Int -> Interrupted -> ShowS # show :: Interrupted -> String # showList :: [Interrupted] -> ShowS #

Throw io exceptions

throwOOMIfNull Source #

Arguments

:: HasCallStack
=> IO (Ptr a)	the allocation action
-> IO (Ptr a)

Throw ResourceExhausted if allocation return a nullPtr.

throwUVIfMinus Source #

Arguments

:: (HasCallStack, Integral a)
=> IO a	the IO action
-> IO a

Throw appropriate IO exception if return value < 0 (libuv's convention).

throwUVIfMinus_ Source #

Arguments

:: (HasCallStack, Integral a)
=> IO a	the IO action
-> IO ()

Throw appropriate IO exception if return value < 0, otherwise ignore the result.

throwUVIf :: (HasCallStack, Integral a) => IO a -> (a -> Bool) -> IO a Source #

Throw appropriate IO exception if condition is true.

throwUVIf_ :: (HasCallStack, Integral a) => IO a -> (a -> Bool) -> IO () Source #

Throw appropriate IO exception if condition is true, otherwise ignore the result.

throwUV :: (Integral a, HasCallStack) => a -> IO b Source #

Throw a UV Exception with given libuv's errno.

throwECLOSED :: HasCallStack => IO a Source #

Throw ResourceVanished with name ECLOSED and description 'resource is closed'.

throwECLOSEDSTM :: HasCallStack => STM a Source #

STM version of throwECLOSED.

throwUVError :: CInt -> IOEInfo -> IO a Source #

throwOtherError :: HasCallStack => Text -> Text -> IO a Source #

Throw OtherError with custom name and description.

unwrap :: (HasCallStack, Print e) => Text -> Either e a -> IO a Source #

Try to unwrap a value from Right, throw OtherError name desc with desc == toText e if 'Left e'.

unwrap' :: HasCallStack => Text -> Text -> Maybe a -> IO a Source #

Try to unwrap a value from Just, throw OtherError name desc if Nothing.

Sync exception tools

catchSync :: Exception e => IO a -> (e -> IO a) -> IO a Source #

Same as upstream catch, but will not catch asynchronous exceptions

ignoreSync :: IO a -> IO () Source #

Ingore all synchronous exceptions.

Re-exports

assert :: Bool -> a -> a #

If the first argument evaluates to True, then the result is the second argument. Otherwise an AssertionFailed exception is raised, containing a String with the source file and line number of the call to assert.

Assertions can normally be turned on or off with a compiler flag (for GHC, assertions are normally on unless optimisation is turned on with -O or the -fignore-asserts option is given). When assertions are turned off, the first argument to assert is ignored, and the second argument is returned as the result.

data ArrayException #

Exceptions generated by array operations

Constructors

IndexOutOfBounds String	An attempt was made to index an array outside its declared bounds.
UndefinedElement String	An attempt was made to evaluate an element of an array that had not been initialized.

Instances

Instances details

Exception ArrayException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: ArrayException -> SomeException # fromException :: SomeException -> Maybe ArrayException # displayException :: ArrayException -> String #
Show ArrayException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> ArrayException -> ShowS # show :: ArrayException -> String # showList :: [ArrayException] -> ShowS #
Eq ArrayException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: ArrayException -> ArrayException -> Bool # (/=) :: ArrayException -> ArrayException -> Bool #
Ord ArrayException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods compare :: ArrayException -> ArrayException -> Ordering # (<) :: ArrayException -> ArrayException -> Bool # (<=) :: ArrayException -> ArrayException -> Bool # (>) :: ArrayException -> ArrayException -> Bool # (>=) :: ArrayException -> ArrayException -> Bool # max :: ArrayException -> ArrayException -> ArrayException # min :: ArrayException -> ArrayException -> ArrayException #

data Handler a #

You need this when using catches.

Constructors

Exception e => Handler (e -> IO a)

Instances

Instances details

Functor Handler	Since: base-4.6.0.0
Instance details Defined in Control.Exception Methods fmap :: (a -> b) -> Handler a -> Handler b # (<$) :: a -> Handler b -> Handler a #

catches :: IO a -> [Handler a] -> IO a #

Sometimes you want to catch two different sorts of exception. You could do something like

f = expr `catch` \ (ex :: ArithException) -> handleArith ex
         `catch` \ (ex :: IOException)    -> handleIO    ex

However, there are a couple of problems with this approach. The first is that having two exception handlers is inefficient. However, the more serious issue is that the second exception handler will catch exceptions in the first, e.g. in the example above, if handleArith throws an IOException then the second exception handler will catch it.

Instead, we provide a function catches, which would be used thus:

f = expr `catches` [Handler (\ (ex :: ArithException) -> handleArith ex),
                    Handler (\ (ex :: IOException)    -> handleIO    ex)]

allowInterrupt :: IO () #

When invoked inside mask, this function allows a masked asynchronous exception to be raised, if one exists. It is equivalent to performing an interruptible operation (see #interruptible), but does not involve any actual blocking.

When called outside mask, or inside uninterruptibleMask, this function has no effect.

Since: base-4.4.0.0

newtype TypeError #

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: base-4.9.0.0

Constructors

TypeError String

Instances

Instances details

Exception TypeError	Since: base-4.9.0.0
Instance details Defined in Control.Exception.Base Methods toException :: TypeError -> SomeException # fromException :: SomeException -> Maybe TypeError # displayException :: TypeError -> String #
Show TypeError	Since: base-4.9.0.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> TypeError -> ShowS # show :: TypeError -> String # showList :: [TypeError] -> ShowS #

newtype RecUpdError #

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.

Constructors

RecUpdError String

Instances

Instances details

Exception RecUpdError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecUpdError -> SomeException # fromException :: SomeException -> Maybe RecUpdError # displayException :: RecUpdError -> String #
Show RecUpdError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> RecUpdError -> ShowS # show :: RecUpdError -> String # showList :: [RecUpdError] -> ShowS #

newtype RecSelError #

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.

Constructors

RecSelError String

Instances

Instances details

Exception RecSelError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecSelError -> SomeException # fromException :: SomeException -> Maybe RecSelError # displayException :: RecSelError -> String #
Show RecSelError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> RecSelError -> ShowS # show :: RecSelError -> String # showList :: [RecSelError] -> ShowS #

newtype RecConError #

An uninitialised record field was used. The String gives information about the source location where the record was constructed.

Constructors

RecConError String

Instances

Instances details

Exception RecConError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecConError -> SomeException # fromException :: SomeException -> Maybe RecConError # displayException :: RecConError -> String #
Show RecConError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> RecConError -> ShowS # show :: RecConError -> String # showList :: [RecConError] -> ShowS #

newtype PatternMatchFail #

A pattern match failed. The String gives information about the source location of the pattern.

Constructors

PatternMatchFail String

Instances

Instances details

Exception PatternMatchFail	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: PatternMatchFail -> SomeException # fromException :: SomeException -> Maybe PatternMatchFail # displayException :: PatternMatchFail -> String #
Show PatternMatchFail	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> PatternMatchFail -> ShowS # show :: PatternMatchFail -> String # showList :: [PatternMatchFail] -> ShowS #

data NonTermination #

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.

Constructors

NonTermination

Instances

Instances details

Exception NonTermination	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NonTermination -> SomeException # fromException :: SomeException -> Maybe NonTermination # displayException :: NonTermination -> String #
Show NonTermination	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> NonTermination -> ShowS # show :: NonTermination -> String # showList :: [NonTermination] -> ShowS #

newtype NoMethodError #

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.

Constructors

NoMethodError String

Instances

Instances details

Exception NoMethodError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NoMethodError -> SomeException # fromException :: SomeException -> Maybe NoMethodError # displayException :: NoMethodError -> String #
Show NoMethodError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> NoMethodError -> ShowS # show :: NoMethodError -> String # showList :: [NoMethodError] -> ShowS #

data NestedAtomically #

Thrown when the program attempts to call atomically, from the stm package, inside another call to atomically.

Constructors

NestedAtomically

Instances

Instances details

Exception NestedAtomically	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NestedAtomically -> SomeException # fromException :: SomeException -> Maybe NestedAtomically # displayException :: NestedAtomically -> String #
Show NestedAtomically	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> NestedAtomically -> ShowS # show :: NestedAtomically -> String # showList :: [NestedAtomically] -> ShowS #

tryJust :: Exception e => (e -> Maybe b) -> IO a -> IO (Either b a) #

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.

try :: Exception e => IO a -> IO (Either e a) #

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 then it will be propagated up to the next enclosing exception handler.

 try a = catch (Right `liftM` a) (return . Left)

onException :: IO a -> IO b -> IO a #

Like finally, but only performs the final action if there was an exception raised by the computation.

mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> a #

This function maps one exception into another as proposed in the paper "A semantics for imprecise exceptions".

handleJust :: Exception e => (e -> Maybe b) -> (b -> IO a) -> IO a -> IO a #

A version of catchJust with the arguments swapped around (see handle).

handle :: Exception e => (e -> IO a) -> IO a -> IO a #

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)) $
     ...

finally #

Arguments

:: IO a	computation to run first
-> IO b	computation to run afterward (even if an exception was raised)
-> IO a

A specialised variant of bracket with just a computation to run afterward.

catchJust #

Arguments

:: Exception e
=> (e -> Maybe b)	Predicate to select exceptions
-> IO a	Computation to run
-> (b -> IO a)	Handler
-> IO a

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.

bracket_ :: IO a -> IO b -> IO c -> IO c #

A variant of bracket where the return value from the first computation is not required.

bracketOnError #

Arguments

:: IO a	computation to run first ("acquire resource")
-> (a -> IO b)	computation to run last ("release resource")
-> (a -> IO c)	computation to run in-between
-> IO c

Like bracket, but only performs the final action if there was an exception raised by the in-between computation.

bracket #

Arguments

:: IO a	computation to run first ("acquire resource")
-> (a -> IO b)	computation to run last ("release resource")
-> (a -> IO c)	computation to run in-between
-> IO c

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 wraps the release action with mask, which is sufficient to ensure that the release action executes to completion when it does not invoke any interruptible actions, even in the presence of asynchronous exceptions. For example, hClose is uninterruptible when it is not racing other uses of the handle. Similarly, closing a socket (from "network" package) is also uninterruptible under similar conditions. An example of an interruptible action is killThread. Completion of interruptible release actions can be ensured by wrapping them in in uninterruptibleMask_, but this risks making the program non-responsive to Control-C, or timeouts. Another option is to run the release action asynchronously in its own thread:

void $ uninterruptibleMask_ $ forkIO $ do { ... }

The resource will be released as soon as possible, but the thread that invoked bracket will not block in an uninterruptible state.

throwTo :: Exception e => ThreadId -> e -> IO () #

throwTo raises an arbitrary exception in the target thread (GHC only).

Exception delivery synchronizes between the source and target thread: throwTo does not return until the exception has been raised in the target thread. The calling thread can thus be certain that the target thread has received the exception. Exception delivery is also atomic with respect to other exceptions. Atomicity is a useful property to have when dealing with race conditions: e.g. if there are two threads that can kill each other, it is guaranteed that only one of the threads will get to kill the other.

Whatever work the target thread was doing when the exception was raised is not lost: the computation is suspended until required by another thread.

If the target thread is currently making a foreign call, then the exception will not be raised (and hence throwTo will not return) until the call has completed. This is the case regardless of whether the call is inside a mask or not. However, in GHC a foreign call can be annotated as interruptible, in which case a throwTo will cause the RTS to attempt to cause the call to return; see the GHC documentation for more details.

Important note: the behaviour of throwTo differs from that described in the paper "Asynchronous exceptions in Haskell" (http://research.microsoft.com/~simonpj/Papers/asynch-exns.htm). In the paper, throwTo is non-blocking; but the library implementation adopts a more synchronous design in which throwTo does not return until the exception is received by the target thread. The trade-off is discussed in Section 9 of the paper. Like any blocking operation, throwTo is therefore interruptible (see Section 5.3 of the paper). Unlike other interruptible operations, however, throwTo is always interruptible, even if it does not actually block.

There is no guarantee that the exception will be delivered promptly, although the runtime will endeavour to ensure that arbitrary delays don't occur. In GHC, an exception can only be raised when a thread reaches a safe point, where a safe point is where memory allocation occurs. Some loops do not perform any memory allocation inside the loop and therefore cannot be interrupted by a throwTo.

If the target of throwTo is the calling thread, then the behaviour is the same as throwIO, except that the exception is thrown as an asynchronous exception. This means that if there is an enclosing pure computation, which would be the case if the current IO operation is inside unsafePerformIO or unsafeInterleaveIO, that computation is not permanently replaced by the exception, but is suspended as if it had received an asynchronous exception.

Note that if throwTo is called with the current thread as the target, the exception will be thrown even if the thread is currently inside mask or uninterruptibleMask.

data SomeAsyncException #

Superclass for asynchronous exceptions.

Since: base-4.7.0.0

Constructors

Exception e => SomeAsyncException e

Instances

Instances details

Exception SomeAsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: SomeAsyncException -> SomeException # fromException :: SomeException -> Maybe SomeAsyncException # displayException :: SomeAsyncException -> String #
Show SomeAsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> SomeAsyncException -> ShowS # show :: SomeAsyncException -> String # showList :: [SomeAsyncException] -> ShowS #

data Deadlock #

There are no runnable threads, so the program is deadlocked. The Deadlock exception is raised in the main thread only.

Constructors

Deadlock

Instances

Instances details

Exception Deadlock	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: Deadlock -> SomeException # fromException :: SomeException -> Maybe Deadlock # displayException :: Deadlock -> String #
Show Deadlock	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> Deadlock -> ShowS # show :: Deadlock -> String # showList :: [Deadlock] -> ShowS #

newtype CompactionFailed #

Compaction found an object that cannot be compacted. Functions cannot be compacted, nor can mutable objects or pinned objects. See compact.

Since: base-4.10.0.0

Constructors

CompactionFailed String

Instances

Instances details

Exception CompactionFailed	Since: base-4.10.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: CompactionFailed -> SomeException # fromException :: SomeException -> Maybe CompactionFailed # displayException :: CompactionFailed -> String #
Show CompactionFailed	Since: base-4.10.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> CompactionFailed -> ShowS # show :: CompactionFailed -> String # showList :: [CompactionFailed] -> ShowS #

data BlockedIndefinitelyOnSTM #

The thread is waiting to retry an STM transaction, but there are no other references to any TVars involved, so it can't ever continue.

Constructors

BlockedIndefinitelyOnSTM

Instances

Instances details

Exception BlockedIndefinitelyOnSTM	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnSTM -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM # displayException :: BlockedIndefinitelyOnSTM -> String #
Show BlockedIndefinitelyOnSTM	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> BlockedIndefinitelyOnSTM -> ShowS # show :: BlockedIndefinitelyOnSTM -> String # showList :: [BlockedIndefinitelyOnSTM] -> ShowS #

data BlockedIndefinitelyOnMVar #

The thread is blocked on an MVar, but there are no other references to the MVar so it can't ever continue.

Constructors

BlockedIndefinitelyOnMVar

Instances

Instances details

Exception BlockedIndefinitelyOnMVar	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnMVar -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar # displayException :: BlockedIndefinitelyOnMVar -> String #
Show BlockedIndefinitelyOnMVar	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> BlockedIndefinitelyOnMVar -> ShowS # show :: BlockedIndefinitelyOnMVar -> String # showList :: [BlockedIndefinitelyOnMVar] -> ShowS #

data AsyncException #

Asynchronous exceptions.

Constructors

StackOverflow	The current thread's stack exceeded its limit. Since an exception has been raised, the thread's stack will certainly be below its limit again, but the programmer should take remedial action immediately.
HeapOverflow	The program's heap is reaching its limit, and the program should take action to reduce the amount of live data it has. Notes: It is undefined which thread receives this exception. GHC currently throws this to the same thread that receives `UserInterrupt`, but this may change in the future. The GHC RTS currently can only recover from heap overflow if it detects that an explicit memory limit (set via RTS flags). has been exceeded. Currently, failure to allocate memory from the operating system results in immediate termination of the program.
ThreadKilled	This exception is raised by another thread calling `killThread`, or by the system if it needs to terminate the thread for some reason.
UserInterrupt	This exception is raised by default in the main thread of the program when the user requests to terminate the program via the usual mechanism(s) (e.g. Control-C in the console).

Instances

Instances details

Exception AsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AsyncException -> SomeException # fromException :: SomeException -> Maybe AsyncException # displayException :: AsyncException -> String #
Show AsyncException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AsyncException -> ShowS # show :: AsyncException -> String # showList :: [AsyncException] -> ShowS #
Eq AsyncException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: AsyncException -> AsyncException -> Bool # (/=) :: AsyncException -> AsyncException -> Bool #
Ord AsyncException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods compare :: AsyncException -> AsyncException -> Ordering # (<) :: AsyncException -> AsyncException -> Bool # (<=) :: AsyncException -> AsyncException -> Bool # (>) :: AsyncException -> AsyncException -> Bool # (>=) :: AsyncException -> AsyncException -> Bool # max :: AsyncException -> AsyncException -> AsyncException # min :: AsyncException -> AsyncException -> AsyncException #

newtype AssertionFailed #

assert was applied to False.

Constructors

AssertionFailed String

Instances

Instances details

Exception AssertionFailed	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AssertionFailed -> SomeException # fromException :: SomeException -> Maybe AssertionFailed # displayException :: AssertionFailed -> String #
Show AssertionFailed	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AssertionFailed -> ShowS # show :: AssertionFailed -> String # showList :: [AssertionFailed] -> ShowS #

data AllocationLimitExceeded #

This thread has exceeded its allocation limit. See setAllocationCounter and enableAllocationLimit.

Since: base-4.8.0.0

Constructors

AllocationLimitExceeded

Instances

Instances details

Exception AllocationLimitExceeded	Since: base-4.8.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AllocationLimitExceeded -> SomeException # fromException :: SomeException -> Maybe AllocationLimitExceeded # displayException :: AllocationLimitExceeded -> String #
Show AllocationLimitExceeded	Since: base-4.7.1.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AllocationLimitExceeded -> ShowS # show :: AllocationLimitExceeded -> String # showList :: [AllocationLimitExceeded] -> ShowS #

ioError :: IOError -> IO a #

Raise an IOException in the IO monad.

asyncExceptionToException :: Exception e => e -> SomeException #

Since: base-4.7.0.0

asyncExceptionFromException :: Exception e => SomeException -> Maybe e #

Since: base-4.7.0.0

data MaskingState #

Describes the behaviour of a thread when an asynchronous exception is received.

Constructors

Unmasked	asynchronous exceptions are unmasked (the normal state)
MaskedInterruptible	the state during `mask`: asynchronous exceptions are masked, but blocking operations may still be interrupted
MaskedUninterruptible	the state during `uninterruptibleMask`: asynchronous exceptions are masked, and blocking operations may not be interrupted

Instances

Instances details

Show MaskingState	Since: base-4.3.0.0
Instance details Defined in GHC.IO Methods showsPrec :: Int -> MaskingState -> ShowS # show :: MaskingState -> String # showList :: [MaskingState] -> ShowS #
Eq MaskingState	Since: base-4.3.0.0
Instance details Defined in GHC.IO Methods (==) :: MaskingState -> MaskingState -> Bool # (/=) :: MaskingState -> MaskingState -> Bool #

uninterruptibleMask_ :: IO a -> IO a #

Like uninterruptibleMask, but does not pass a restore action to the argument.

uninterruptibleMask :: ((forall a. IO a -> IO a) -> IO b) -> IO b #

Like mask, but the masked computation is not interruptible (see Control.Exception). THIS SHOULD BE USED WITH GREAT CARE, because if a thread executing in uninterruptibleMask blocks for any reason, then the thread (and possibly the program, if this is the main thread) will be unresponsive and unkillable. This function should only be necessary if you need to mask exceptions around an interruptible operation, and you can guarantee that the interruptible operation will only block for a short period of time.

throwIO :: Exception e => e -> IO a #

A variant of throw that can only be used within the IO monad.

Although throwIO has a type that is an instance of the type of throw, the two functions are subtly different:

throw e   `seq` x  ===> throw e
throwIO e `seq` x  ===> x

The first example will cause the exception e to be raised, whereas the second one won't. In fact, throwIO will only cause an exception to be raised when it is used within the IO monad. The throwIO variant should be used in preference to throw to raise an exception within the IO monad because it guarantees ordering with respect to other IO operations, whereas throw does not.

mask_ :: IO a -> IO a #

Like mask, but does not pass a restore action to the argument.

mask :: ((forall a. IO a -> IO a) -> IO b) -> IO b #

Executes an IO computation with asynchronous exceptions masked. That is, any thread which attempts to raise an exception in the current thread with throwTo will be blocked until asynchronous exceptions are unmasked again.

The argument passed to mask is a function that takes as its argument another function, which can be used to restore the prevailing masking state within the context of the masked computation. For example, a common way to use mask is to protect the acquisition of a resource:

mask $ \restore -> do
    x <- acquire
    restore (do_something_with x) `onException` release
    release

This code guarantees that acquire is paired with release, by masking asynchronous exceptions for the critical parts. (Rather than write this code yourself, it would be better to use bracket which abstracts the general pattern).

Note that the restore action passed to the argument to mask does not necessarily unmask asynchronous exceptions, it just restores the masking state to that of the enclosing context. Thus if asynchronous exceptions are already masked, mask cannot be used to unmask exceptions again. This is so that if you call a library function with exceptions masked, you can be sure that the library call will not be able to unmask exceptions again. If you are writing library code and need to use asynchronous exceptions, the only way is to create a new thread; see forkIOWithUnmask.

Asynchronous exceptions may still be received while in the masked state if the masked thread blocks in certain ways; see Control.Exception.

Threads created by forkIO inherit the MaskingState from the parent; that is, to start a thread in the MaskedInterruptible state, use mask_ $ forkIO .... This is particularly useful if you need to establish an exception handler in the forked thread before any asynchronous exceptions are received. To create a new thread in an unmasked state use forkIOWithUnmask.

interruptible :: IO a -> IO a #

Allow asynchronous exceptions to be raised even inside mask, making the operation interruptible (see the discussion of "Interruptible operations" in Exception).

When called outside mask, or inside uninterruptibleMask, this function has no effect.

Since: base-4.9.0.0

getMaskingState :: IO MaskingState #

Returns the MaskingState for the current thread.

evaluate :: a -> IO a #

Evaluate the argument to weak head normal form.

evaluate is typically used to uncover any exceptions that a lazy value may contain, and possibly handle them.

evaluate only evaluates to weak head normal form. If deeper evaluation is needed, the force function from Control.DeepSeq may be handy:

evaluate $ force x

There is a subtle difference between evaluate x and return $! x, analogous to the difference between throwIO and throw. If the lazy value x throws an exception, return $! x will fail to return an IO action and will throw an exception instead. evaluate x, on the other hand, always produces an IO action; that action will throw an exception upon execution iff x throws an exception upon evaluation.

The practical implication of this difference is that due to the imprecise exceptions semantics,

(return $! error "foo") >> error "bar"

may throw either "foo" or "bar", depending on the optimizations performed by the compiler. On the other hand,

evaluate (error "foo") >> error "bar"

is guaranteed to throw "foo".

The rule of thumb is to use evaluate to force or handle exceptions in lazy values. If, on the other hand, you are forcing a lazy value for efficiency reasons only and do not care about exceptions, you may use return $! x.

catch #

Arguments

:: Exception e
=> IO a	The computation to run
-> (e -> IO a)	Handler to invoke if an exception is raised
-> IO a

This is the simplest of the exception-catching functions. It takes a single argument, runs it, and if an exception is raised the "handler" is executed, with the value of the exception passed as an argument. Otherwise, the result is returned as normal. For example:

  catch (readFile f)
        (\e -> do let err = show (e :: IOException)
                  hPutStr stderr ("Warning: Couldn't open " ++ f ++ ": " ++ err)
                  return "")

Note that we have to give a type signature to e, or the program will not typecheck as the type is ambiguous. While it is possible to catch exceptions of any type, see the section "Catching all exceptions" (in Control.Exception) for an explanation of the problems with doing so.

For catching exceptions in pure (non-IO) expressions, see the function evaluate.

Note that due to Haskell's unspecified evaluation order, an expression may throw one of several possible exceptions: consider the expression (error "urk") + (1 `div` 0). Does the expression throw ErrorCall "urk", or DivideByZero?

The answer is "it might throw either"; the choice is non-deterministic. If you are catching any type of exception then you might catch either. If you are calling catch with type IO Int -> (ArithException -> IO Int) -> IO Int then the handler may get run with DivideByZero as an argument, or an ErrorCall "urk" exception may be propagated further up. If you call it again, you might get the opposite behaviour. This is ok, because catch is an IO computation.

data ErrorCall #

This is thrown when the user calls error. The first String is the argument given to error, second String is the location.

Constructors

ErrorCallWithLocation String String

Bundled Patterns

pattern ErrorCall :: String -> ErrorCall

Instances

Instances details

Exception ErrorCall	Since: base-4.0.0.0
Instance details Defined in GHC.Exception Methods toException :: ErrorCall -> SomeException # fromException :: SomeException -> Maybe ErrorCall # displayException :: ErrorCall -> String #
Show ErrorCall	Since: base-4.0.0.0
Instance details Defined in GHC.Exception Methods showsPrec :: Int -> ErrorCall -> ShowS # show :: ErrorCall -> String # showList :: [ErrorCall] -> ShowS #
Eq ErrorCall	Since: base-4.7.0.0
Instance details Defined in GHC.Exception Methods (==) :: ErrorCall -> ErrorCall -> Bool # (/=) :: ErrorCall -> ErrorCall -> Bool #
Ord ErrorCall	Since: base-4.7.0.0
Instance details Defined in GHC.Exception Methods compare :: ErrorCall -> ErrorCall -> Ordering # (<) :: ErrorCall -> ErrorCall -> Bool # (<=) :: ErrorCall -> ErrorCall -> Bool # (>) :: ErrorCall -> ErrorCall -> Bool # (>=) :: ErrorCall -> ErrorCall -> Bool # max :: ErrorCall -> ErrorCall -> ErrorCall # min :: ErrorCall -> ErrorCall -> ErrorCall #

throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a #

Throw an exception. Exceptions may be thrown from purely functional code, but may only be caught within the IO monad.

class (Typeable e, Show e) => Exception e where #

Any type that you wish to throw or catch as an exception must be an instance of the Exception class. The simplest case is a new exception type directly below the root:

data MyException = ThisException | ThatException
    deriving Show

instance Exception MyException

The default method definitions in the Exception class do what we need in 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 hierarchy of 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 = frontendExceptionFromException

We 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

Minimal complete definition

Nothing

Methods

toException :: e -> SomeException #

fromException :: SomeException -> Maybe e #

displayException :: e -> String #

Render this exception value in a human-friendly manner.

Default implementation: show.

Since: base-4.8.0.0

Instances

Instances details

Exception TextException
Instance details Defined in Z.Data.Text.Base Methods toException :: TextException -> SomeException # fromException :: SomeException -> Maybe TextException # displayException :: TextException -> String #
Exception VectorException
Instance details Defined in Z.Data.Vector.Base Methods toException :: VectorException -> SomeException # fromException :: SomeException -> Maybe VectorException # displayException :: VectorException -> String #
Exception Base64DecodeException
Instance details Defined in Z.Data.Vector.Base64 Methods toException :: Base64DecodeException -> SomeException # fromException :: SomeException -> Maybe Base64DecodeException # displayException :: Base64DecodeException -> String #
Exception HexDecodeException
Instance details Defined in Z.Data.Vector.Hex Methods toException :: HexDecodeException -> SomeException # fromException :: SomeException -> Maybe HexDecodeException # displayException :: HexDecodeException -> String #
Exception AlreadyExists Source #
Instance details Defined in Z.IO.Exception Methods toException :: AlreadyExists -> SomeException # fromException :: SomeException -> Maybe AlreadyExists # displayException :: AlreadyExists -> String #
Exception HardwareFault Source #
Instance details Defined in Z.IO.Exception Methods toException :: HardwareFault -> SomeException # fromException :: SomeException -> Maybe HardwareFault # displayException :: HardwareFault -> String #
Exception IllegalOperation Source #
Instance details Defined in Z.IO.Exception Methods toException :: IllegalOperation -> SomeException # fromException :: SomeException -> Maybe IllegalOperation # displayException :: IllegalOperation -> String #
Exception InappropriateType Source #
Instance details Defined in Z.IO.Exception Methods toException :: InappropriateType -> SomeException # fromException :: SomeException -> Maybe InappropriateType # displayException :: InappropriateType -> String #
Exception Interrupted Source #
Instance details Defined in Z.IO.Exception Methods toException :: Interrupted -> SomeException # fromException :: SomeException -> Maybe Interrupted # displayException :: Interrupted -> String #
Exception InvalidArgument Source #
Instance details Defined in Z.IO.Exception Methods toException :: InvalidArgument -> SomeException # fromException :: SomeException -> Maybe InvalidArgument # displayException :: InvalidArgument -> String #
Exception NoSuchThing Source #
Instance details Defined in Z.IO.Exception Methods toException :: NoSuchThing -> SomeException # fromException :: SomeException -> Maybe NoSuchThing # displayException :: NoSuchThing -> String #
Exception OtherError Source #
Instance details Defined in Z.IO.Exception Methods toException :: OtherError -> SomeException # fromException :: SomeException -> Maybe OtherError # displayException :: OtherError -> String #
Exception PermissionDenied Source #
Instance details Defined in Z.IO.Exception Methods toException :: PermissionDenied -> SomeException # fromException :: SomeException -> Maybe PermissionDenied # displayException :: PermissionDenied -> String #
Exception ProtocolError Source #
Instance details Defined in Z.IO.Exception Methods toException :: ProtocolError -> SomeException # fromException :: SomeException -> Maybe ProtocolError # displayException :: ProtocolError -> String #
Exception ResourceBusy Source #
Instance details Defined in Z.IO.Exception Methods toException :: ResourceBusy -> SomeException # fromException :: SomeException -> Maybe ResourceBusy # displayException :: ResourceBusy -> String #
Exception ResourceExhausted Source #
Instance details Defined in Z.IO.Exception Methods toException :: ResourceExhausted -> SomeException # fromException :: SomeException -> Maybe ResourceExhausted # displayException :: ResourceExhausted -> String #
Exception ResourceVanished Source #
Instance details Defined in Z.IO.Exception Methods toException :: ResourceVanished -> SomeException # fromException :: SomeException -> Maybe ResourceVanished # displayException :: ResourceVanished -> String #
Exception SomeIOException Source #
Instance details Defined in Z.IO.Exception Methods toException :: SomeIOException -> SomeException # fromException :: SomeException -> Maybe SomeIOException # displayException :: SomeIOException -> String #
Exception SystemError Source #
Instance details Defined in Z.IO.Exception Methods toException :: SystemError -> SomeException # fromException :: SomeException -> Maybe SystemError # displayException :: SystemError -> String #
Exception TimeExpired Source #
Instance details Defined in Z.IO.Exception Methods toException :: TimeExpired -> SomeException # fromException :: SomeException -> Maybe TimeExpired # displayException :: TimeExpired -> String #
Exception UnexpectedEOF Source #
Instance details Defined in Z.IO.Exception Methods toException :: UnexpectedEOF -> SomeException # fromException :: SomeException -> Maybe UnexpectedEOF # displayException :: UnexpectedEOF -> String #
Exception UnsatisfiedConstraints Source #
Instance details Defined in Z.IO.Exception Methods toException :: UnsatisfiedConstraints -> SomeException # fromException :: SomeException -> Maybe UnsatisfiedConstraints # displayException :: UnsatisfiedConstraints -> String #
Exception UnsupportedOperation Source #
Instance details Defined in Z.IO.Exception Methods toException :: UnsupportedOperation -> SomeException # fromException :: SomeException -> Maybe UnsupportedOperation # displayException :: UnsupportedOperation -> String #
Exception NestedAtomically	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NestedAtomically -> SomeException # fromException :: SomeException -> Maybe NestedAtomically # displayException :: NestedAtomically -> String #
Exception NoMethodError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NoMethodError -> SomeException # fromException :: SomeException -> Maybe NoMethodError # displayException :: NoMethodError -> String #
Exception NonTermination	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NonTermination -> SomeException # fromException :: SomeException -> Maybe NonTermination # displayException :: NonTermination -> String #
Exception PatternMatchFail	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: PatternMatchFail -> SomeException # fromException :: SomeException -> Maybe PatternMatchFail # displayException :: PatternMatchFail -> String #
Exception RecConError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecConError -> SomeException # fromException :: SomeException -> Maybe RecConError # displayException :: RecConError -> String #
Exception RecSelError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecSelError -> SomeException # fromException :: SomeException -> Maybe RecSelError # displayException :: RecSelError -> String #
Exception RecUpdError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecUpdError -> SomeException # fromException :: SomeException -> Maybe RecUpdError # displayException :: RecUpdError -> String #
Exception TypeError	Since: base-4.9.0.0
Instance details Defined in Control.Exception.Base Methods toException :: TypeError -> SomeException # fromException :: SomeException -> Maybe TypeError # displayException :: TypeError -> String #
Exception Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods toException :: Void -> SomeException # fromException :: SomeException -> Maybe Void # displayException :: Void -> String #
Exception ErrorCall	Since: base-4.0.0.0
Instance details Defined in GHC.Exception Methods toException :: ErrorCall -> SomeException # fromException :: SomeException -> Maybe ErrorCall # displayException :: ErrorCall -> String #
Exception ArithException	Since: base-4.0.0.0
Instance details Defined in GHC.Exception.Type Methods toException :: ArithException -> SomeException # fromException :: SomeException -> Maybe ArithException # displayException :: ArithException -> String #
Exception SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String #
Exception AllocationLimitExceeded	Since: base-4.8.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AllocationLimitExceeded -> SomeException # fromException :: SomeException -> Maybe AllocationLimitExceeded # displayException :: AllocationLimitExceeded -> String #
Exception ArrayException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: ArrayException -> SomeException # fromException :: SomeException -> Maybe ArrayException # displayException :: ArrayException -> String #
Exception AssertionFailed	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AssertionFailed -> SomeException # fromException :: SomeException -> Maybe AssertionFailed # displayException :: AssertionFailed -> String #
Exception AsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AsyncException -> SomeException # fromException :: SomeException -> Maybe AsyncException # displayException :: AsyncException -> String #
Exception BlockedIndefinitelyOnMVar	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnMVar -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar # displayException :: BlockedIndefinitelyOnMVar -> String #
Exception BlockedIndefinitelyOnSTM	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnSTM -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM # displayException :: BlockedIndefinitelyOnSTM -> String #
Exception CompactionFailed	Since: base-4.10.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: CompactionFailed -> SomeException # fromException :: SomeException -> Maybe CompactionFailed # displayException :: CompactionFailed -> String #
Exception Deadlock	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: Deadlock -> SomeException # fromException :: SomeException -> Maybe Deadlock # displayException :: Deadlock -> String #
Exception ExitCode	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: ExitCode -> SomeException # fromException :: SomeException -> Maybe ExitCode # displayException :: ExitCode -> String #
Exception FixIOException	Since: base-4.11.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: FixIOException -> SomeException # fromException :: SomeException -> Maybe FixIOException # displayException :: FixIOException -> String #
Exception IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: IOException -> SomeException # fromException :: SomeException -> Maybe IOException # displayException :: IOException -> String #
Exception SomeAsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: SomeAsyncException -> SomeException # fromException :: SomeException -> Maybe SomeAsyncException # displayException :: SomeAsyncException -> String #

data ArithException #

Arithmetic exceptions.

Constructors

Overflow
Underflow
LossOfPrecision
DivideByZero
Denormal
RatioZeroDenominator	Since: base-4.6.0.0

Instances

Instances details

Exception ArithException	Since: base-4.0.0.0
Instance details Defined in GHC.Exception.Type Methods toException :: ArithException -> SomeException # fromException :: SomeException -> Maybe ArithException # displayException :: ArithException -> String #
Show ArithException	Since: base-4.0.0.0
Instance details Defined in GHC.Exception.Type Methods showsPrec :: Int -> ArithException -> ShowS # show :: ArithException -> String # showList :: [ArithException] -> ShowS #
Eq ArithException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods (==) :: ArithException -> ArithException -> Bool # (/=) :: ArithException -> ArithException -> Bool #
Ord ArithException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods compare :: ArithException -> ArithException -> Ordering # (<) :: ArithException -> ArithException -> Bool # (<=) :: ArithException -> ArithException -> Bool # (>) :: ArithException -> ArithException -> Bool # (>=) :: ArithException -> ArithException -> Bool # max :: ArithException -> ArithException -> ArithException # min :: ArithException -> ArithException -> ArithException #

data SomeException #

The SomeException type is the root of the exception type hierarchy. When an exception of type e is thrown, behind the scenes it is encapsulated in a SomeException.

Constructors

Exception e => SomeException e

Instances

Instances details

Print SomeException
Instance details Defined in Z.Data.Text.Print Methods toUTF8BuilderP :: Int -> SomeException -> Builder () #
Exception SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String #
Show SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods showsPrec :: Int -> SomeException -> ShowS # show :: SomeException -> String # showList :: [SomeException] -> ShowS #

type HasCallStack = ?callStack :: CallStack #

Request a CallStack.

NOTE: The implicit parameter ?callStack :: CallStack is an implementation detail and should not be considered part of the CallStack API, we may decide to change the implementation in the future.

Since: base-4.9.0.0

data CallStack #

CallStacks are a lightweight method of obtaining a partial call-stack at any point in the program.

A function can request its call-site with the HasCallStack constraint. For example, we can define

putStrLnWithCallStack :: HasCallStack => String -> IO ()

as a variant of putStrLn that will get its call-site and print it, along with the string given as argument. We can access the call-stack inside putStrLnWithCallStack with callStack.

>>> :{
putStrLnWithCallStack :: HasCallStack => String -> IO ()
putStrLnWithCallStack msg = do
  putStrLn msg
  putStrLn (prettyCallStack callStack)
:}

Thus, if we call putStrLnWithCallStack we will get a formatted call-stack alongside our string.

>>> putStrLnWithCallStack "hello"
hello
CallStack (from HasCallStack):
  putStrLnWithCallStack, called at <interactive>:... in interactive:Ghci...

GHC solves HasCallStack constraints in three steps:

If there is a CallStack in scope -- i.e. the enclosing function has a HasCallStack constraint -- GHC will append the new call-site to the existing CallStack.
If there is no CallStack in scope -- e.g. in the GHCi session above -- and the enclosing definition does not have an explicit type signature, GHC will infer a HasCallStack constraint for the enclosing definition (subject to the monomorphism restriction).
If there is no CallStack in scope and the enclosing definition has an explicit type signature, GHC will solve the HasCallStack constraint for the singleton CallStack containing just the current call-site.

CallStacks do not interact with the RTS and do not require compilation with -prof. On the other hand, as they are built up explicitly via the HasCallStack constraints, they will generally not contain as much information as the simulated call-stacks maintained by the RTS.

A CallStack is a [(String, SrcLoc)]. The String is the name of function that was called, the SrcLoc is the call-site. The list is ordered with the most recently called function at the head.

NOTE: The intrepid user may notice that HasCallStack is just an alias for an implicit parameter ?callStack :: CallStack. This is an implementation detail and should not be considered part of the CallStack API, we may decide to change the implementation in the future.

Since: base-4.8.1.0

Instances

Instances details

Print CallStack
Instance details Defined in Z.Data.Text.Print Methods toUTF8BuilderP :: Int -> CallStack -> Builder () #
IsList CallStack	Be aware that 'fromList . toList = id' only for unfrozen `CallStack`s, since `toList` removes frozenness information. Since: base-4.9.0.0
Instance details Defined in GHC.Exts Associated Types type Item CallStack # Methods fromList :: [Item CallStack] -> CallStack # fromListN :: Int -> [Item CallStack] -> CallStack # toList :: CallStack -> [Item CallStack] #
Show CallStack	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> CallStack -> ShowS # show :: CallStack -> String # showList :: [CallStack] -> ShowS #
type Item CallStack
Instance details Defined in GHC.Exts type Item CallStack = (String, SrcLoc)

callStack :: HasCallStack => CallStack #

Return the current CallStack.

Does *not* include the call-site of callStack.

Since: base-4.9.0.0

module Z.IO.UV.Errno

The SomeIOException type

Instances

Builtin io exception types

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Throw io exceptions

Sync exception tools

Re-exports

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

The `SomeIOException` type