Haskell语言学习笔记（33）Exception, Except, ExceptT

Exception

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

    toException   :: e -> SomeException

    fromException :: SomeException -> Maybe e

    toException = SomeException

    fromException (SomeException e) = cast e

    displayException :: e -> String

    displayException = show

instance Exception SomeException where

    toException se = se

    fromException = Just

    displayException (SomeException e) = displayException e

ExceptT Monad转换器

newtype ExceptT e m a = ExceptT (m (Either e a))

instance (Monad m) => Monad (ExceptT e m) where

    return a = ExceptT $ return (Right a)

    m >>= k = ExceptT $ do

        a <- runExceptT m

        case a of

            Left e -> return (Left e)

            Right x -> runExceptT (k x)

runExceptT :: ExceptT e m a -> m (Either e a)

runExceptT (ExceptT m) = m

newtype ExceptT e m a = ExceptT (m (Either e a))

ExceptT 类型是个 newtype，也就是对现有类型的封装。该类型有两个类型参数：内部 Monad 类型 m 以及基础 Monad Either 的参数类型 e 和 a。

ExceptT e m a 封装了一个 m (Either e a) 类型的值，通过 runExceptT 函数可以取出这个值。
instance (Monad m) => Monad (ExceptT e m) where

如果 m 是个 Monad，那么 ExceptT e m 也是一个 Monad。

对比 Monad 类型类的定义，可知 return 函数的类型签名为：

return :: a -> ExceptT e m a

大致相当于 a -> m (Either e a)

而 bind 操作符的类型签名为：

(>>=) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b

大致相当于 m (Either e a) -> (a -> m (Either e b)) -> m (Either e b)
return a = ExceptT $ return (Right a)

return 函数首先将 Right a 封装进内部 Monad m 中，然后再把它封装进 ExceptT 这个 Monad 转换器之中。

这里左侧的 return 是 ExceptT 这个 Monad 的 return，而右侧的 return 是内部 Monad m 的 return。
m >>= k = ExceptT $ do

对比函数签名，可知 m 的类型是 ExceptT e m a，大致相当于 m (Either e a)

而 k 的类型是 a -> ExceptT e m b，大致相当于 a -> m (Either e b)
a <- runExceptT m

对比 m 的类型，可知 a 的类型是 Either e a

这是因为 runMaybeT 函数让 m 脱离了 ExceptT Monad，而 <- 运算符又让 runExceptT m 脱离了内部 Monad m。
case a of
Left e -> return (Left e)

这里 return 是内部 Monad m 的 return，所以 return (Left e) 的类型是 m (Either e a)。
Right x -> runExceptT (k x)

k 的类型是 a -> ExceptT e m b

所以 k x 的类型是 ExceptT e m b

而 runExceptT (k x) 的类型是 m (Either e b)

证明 ExceptT e m 符合 Monad 法则。

1. return a >>= f ≡ f a

return a >>= f

≡ (ExceptT $ return (Right a)) >>= f

≡ ExceptT (m (Right a)) >>= f

≡ ExceptT $ runExceptT (f a)

≡ f a

2. m >>= return ≡ m

ExceptT (m (Right x)) >>= return

≡ ExceptT $ runExceptT (return x)

≡ ExceptT (m (Right x))

ExceptT (m (Left e)) >>= return

≡ ExceptT $ runExceptT (return (Left e))

≡ ExceptT (m (Left e))

3. (m >>= f) >>= g ≡ m >>= (\x -> f x >>= g)

(ExceptT (m (Right x)) >>= f) >>= g ≡ f x >>= g

(ExceptT (m (Left e)) >>= f) >>= g ≡ ExceptT (m (Left e)) >>= g ≡ ExceptT (m (Left e))

ExceptT (m (Right x) >>= (\x -> f x >>= g) ≡ (\x -> f x >>= g) x ≡ f x >>= g

ExceptT (m (Left e)) >>= (\x -> f x >>= g) ≡ ExceptT (m (Left e))

lift, liftIO 函数

instance MonadTrans (ExceptT e) where

    lift = ExceptT . liftM Right

instance (MonadIO m) => MonadIO (ExceptT e m) where

    liftIO = lift . liftIO

证明 MaybeT 中 lift 函数的定义符合 lift 的法则。

1. lift . return ≡ return

lift . return $ a

≡ ExceptT . liftM Right . return $ a

≡ ExceptT (m (Right a))

≡ return a

2. lift (m >>= f) ≡ lift m >>= (lift . f)

假设 m = n a 并且 f a = n b

于是 m >>= f = n b

lift (m >>= f)

≡ ExceptT . liftM Right $ m >>= f

≡ ExceptT . liftM Right $ n b

≡ ExceptT (n (Right b))

lift m >>= (lift . f)

≡ (ExceptT . liftM Right $ m) >>= (ExceptT . liftM Right . f)

≡ (ExceptT (n (Right a))) >>= (\x -> ExceptT . liftM Right . f $ x)

≡ ExceptT $ runExceptT $ ExceptT . liftM Right . f $ a

≡ ExceptT $ runExceptT $ ExceptT . liftM Right $ n b

≡ ExceptT $ runExceptT $ ExceptT (n (Right b))

≡ ExceptT (n (Right b))

Except Monad

type Except e = ExceptT e Identity

Except Monad 是 ExceptT Monad（转换器）的一个特例。

应用实例

-- https://stackoverflow.com/questions/26385809/catch-someexception-with-exceptt

-- cabal install lifted-base

import Control.Exception.Lifted

import Control.Monad.Trans.Except

badFunction :: ExceptT SomeException IO ()

badFunction = throw DivideByZero

intercept

  :: ExceptT SomeException IO a

  -> ExceptT SomeException IO a

intercept a = do

  r <- try $ a

  case r of

    Right x -> return x

    Left e -> throwE e

intercept'

  :: ExceptT SomeException IO a

  -> ExceptT SomeException IO a

intercept' = handle throwE

main :: IO ()

main = do

    r <- runExceptT $ intercept badFunction

    case r of Left _ -> putStrLn "caught error"

              Right _ -> putStrLn "nope, didn't catch no error"

巴特西

Haskell语言学习笔记（33）Exception, Except, ExceptT

Exception

ExceptT Monad转换器

lift, liftIO 函数

Except Monad

应用实例

最新文章

热门文章