System.Console.Haskeline.MonadException

Safe Haskell	None
Язык	Haskell98

Класс MonadException

class MonadIO m => MonadException m where Источник

Экземпляр MonadException обычно состоит из слоёв монадических трансформаторов поверх монады IO.

Метод controlIO позволяет «поднять» функцию, управляющую действиями IO (например, bracket или catch) в функцию, которая оборачивает произвольные монадические действия.

Обобщения Control.Exception

catch :: (MonadException m, Exception e) => m a -> (e -> m a) -> m a Источник

handle :: (MonadException m, Exception e) => (e -> m a) -> m a -> m a Источник

catches :: MonadException m => m a -> [Handler m a] -> m a Источник

data Handler m a Источник

finally :: MonadException m => m a -> m b -> m a Источник

throwIO :: (MonadIO m, Exception e) => e -> m a Источник

throwTo :: (MonadIO m, Exception e) => ThreadId -> e -> m () Источник

bracket :: MonadException m => m a -> (a -> m b) -> (a -> m c) -> m c Источник

Справочные функции для определения функций-оберток

liftIOOp :: MonadException m => ((a -> IO (m b)) -> IO (m c)) -> (a -> m b) -> m c Источник

Поднять операцию IO

wrap :: (a -> IO b) -> IO b

к более общей монадической операции

liftIOOp wrap :: MonadException m => (a -> m b) -> m b

Например:

 liftIOOp (withFile f m) :: MonadException m => (Handle -> m r) -> m r
 liftIOOp alloca :: (MonadException m, Storable a) => (Ptr a -> m b) -> m b
 liftIOOp (withForeignPtr fp) :: MonadException m => (Ptr a -> m b) -> m b

liftIOOp_ :: MonadException m => (IO (m a) -> IO (m a)) -> m a -> m a Источник

Поднять операцию IO

wrap :: IO a -> IO a

к более общей монадической операции

liftIOOp_ wrap :: MonadException m => m a -> m a

Внутренняя реализация

newtype RunIO m Источник

Функция RunIO принимает монадическое действие m в качестве входного значения и возвращает действие IO, которое выполняет базовую нечистую часть m и возвращает «pure' часть» m.

Обратите внимание, что (RunIO return) — это неправильная реализация, так как она не разделяет чистую и нечистую части монадического действия. В этом модуле определены реализации для нескольких распространённых трансформаторов монад.

Расширяемые исключения

class (Typeable * e, Show e) => Exception e Источник

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

data MyException = ThisException | ThatException
    deriving (Show, Typeable)

instance Exception MyException

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

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

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

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

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

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
    deriving Typeable

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 (Typeable, Show)

instance Exception MismatchedParentheses where
    toException   = frontendExceptionToException
    fromException = frontendExceptionFromException

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

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

data SomeException :: * where Source

Тип SomeException является корнем иерархии типов исключений. Когда генерируется исключение типа e, за кулисами оно инкапсулируется в SomeException.

data IOException :: * Source

Исключения, возникающие в монаде IO. IOException записывает более специфический тип ошибки, описательную строку и, возможно, дескриптор, который использовался, когда ошибка была отмечена.