第27回　外部環境のエラーとHaskellの間の整合性を取る

Prelude> :i IOError
type IOError = GHC.IOBase.IOException   -- Defined in GHC.IOBase
Prelude> :m Control.Exception
Prelude Control.Exception> :i IOException
data IOException
  = GHC.IOBase.IOError {GHC.IOBase.ioe_handle :: Maybe
                                                   GHC.IOBase.Handle,
                        GHC.IOBase.ioe_type :: GHC.IOBase.IOErrorType,
                        GHC.IOBase.ioe_location :: String,
                        GHC.IOBase.ioe_description :: String,
                        GHC.IOBase.ioe_filename :: Maybe FilePath}
        -- Defined in GHC.IOBase
instance Eq IOException -- Defined in GHC.IOBase
instance Show IOException -- Defined in GHC.IOBase
instance Exception IOException -- Defined in GHC.IOBase

Prelude> :i catch
catch :: IO a -> (IOError -> IO a) -> IO a      -- Defined in Prelude

Prelude> :i ioError
ioError :: IOError -> IO a      -- Defined in GHC.IOBase
Prelude> :i userError
userError :: String -> IOError  -- Defined in GHC.IOBase

#ifndef __HUGS__
import qualified Control.Exception.Base as New (catch)
#endif

#ifdef __HUGS__
import Hugs.Prelude
#endif

～ 略 ～

#ifndef __HUGS__
～ 略 ～
catch :: IO a -> (IOError -> IO a) -> IO a
catch = New.catch
#endif /* !__HUGS__ */

module Hugs.Prelude (

～ 略 ～

catch :: IO a -> (IOError -> IO a) -> IO a
catch m h = catchException m $ \e -> case e of
                IOException err -> h err
                _ -> throw e

ioException     :: IOException -> IO a
ioException err = throwIO err

-- | Raise an 'IOError' in the 'IO' monad.
ioError         :: IOError -> IO a 
ioError         =  ioException

～ 略 ～

userError       :: String  -> IOError
userError str   =  IOError Nothing UserError "" str Nothing

Prelude Control.Exception> :i throwIO
throwIO :: (Exception e) => e -> IO a   -- Defined in GHC.IOBase

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

{-# LANGUAGE ScopedTypeVariables #-}
module IOError where
import Control.Exception hiding (catch)
import qualified Control.Exception as CE

causeIOError = ioError $ userError "error occur."
causeIOError' = do
    print "Before exception: this must show."
    causeIOError
    print "After exception: this must not show."

catchIOError val = catch val (\_ -> print "error caught.")
catchIOError' val = CE.catch val (\(e::IOError) -> print "error caught.")

*IOError> causeIOError
*** Exception: user error (error occur.)
*IOError> causeIOError'
"Before exception: this must show."
*** Exception: user error (error occur.)
*IOError> catchIOError causeIOError
"error caught."
*IOError> catchIOError causeIOError'
"Before exception: this must show."
"error caught."
*IOError> catchIOError' causeIOError
"error caught."
*IOError> catchIOError' causeIOError'
"Before exception: this must show."
"error caught."