GHC/IOBase.lhs

   1 \begin{code}
   2 {-# OPTIONS -fno-implicit-prelude #-}
   3 -----------------------------------------------------------------------------
   4 -- |
   5 -- Module      :  GHC.IOBase
   6 -- Copyright   :  (c) The University of Glasgow 1994-2002
   7 -- License     :  see libraries/base/LICENSE
   8 --
   9 -- Maintainer  :  cvs-ghc@haskell.org
  10 -- Stability   :  internal
  11 -- Portability :  non-portable (GHC Extensions)
  12 --
  13 -- Definitions for the 'IO' monad and its friends.
  14 --
  15 -----------------------------------------------------------------------------
  16
  17 module GHC.IOBase where
  18
  19 import GHC.ST
  20 import GHC.STRef
  21 import GHC.Base
  22 import GHC.Num  -- To get fromInteger etc, needed because of -fno-implicit-prelude
  23 import Data.Maybe  ( Maybe(..) )
  24 import GHC.Show
  25 import GHC.List
  26 import GHC.Read
  27
  28 #ifndef __HADDOCK__
  29 import {-# SOURCE #-} Data.Dynamic
  30 #endif
  31
  32 -- ---------------------------------------------------------------------------
  33 -- The IO Monad
  34
  35 {-
  36 The IO Monad is just an instance of the ST monad, where the state is
  37 the real world.  We use the exception mechanism (in GHC.Exception) to
  38 implement IO exceptions.
  39
  40 NOTE: The IO representation is deeply wired in to various parts of the
  41 system.  The following list may or may not be exhaustive:
  42
  43 Compiler  - types of various primitives in PrimOp.lhs
  44
  45 RTS       - forceIO (StgMiscClosures.hc)
  46           - catchzh_fast, (un)?blockAsyncExceptionszh_fast, raisezh_fast
  47             (Exceptions.hc)
  48           - raiseAsync (Schedule.c)
  49
  50 Prelude   - GHC.IOBase.lhs, and several other places including
  51             GHC.Exception.lhs.
  52
  53 Libraries - parts of hslibs/lang.
  54
  55 --SDM
  56 -}
  57
  58 newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #))
  59
  60 unIO :: IO a -> (State# RealWorld -> (# State# RealWorld, a #))
  61 unIO (IO a) = a
  62
  63 instance  Functor IO where
  64    fmap f x = x >>= (return . f)
  65
  66 instance  Monad IO  where
  67     {-# INLINE return #-}
  68     {-# INLINE (>>)   #-}
  69     {-# INLINE (>>=)  #-}
  70     m >> k      =  m >>= \ _ -> k
  71     return x    = returnIO x
  72
  73     m >>= k     = bindIO m k
  74     fail s      = failIO s
  75
  76 failIO :: String -> IO a
  77 failIO s = ioError (userError s)
  78
  79 liftIO :: IO a -> State# RealWorld -> STret RealWorld a
  80 liftIO (IO m) = \s -> case m s of (# s', r #) -> STret s' r
  81
  82 bindIO :: IO a -> (a -> IO b) -> IO b
  83 bindIO (IO m) k = IO ( \ s ->
  84   case m s of
  85     (# new_s, a #) -> unIO (k a) new_s
  86   )
  87
  88 thenIO :: IO a -> IO b -> IO b
  89 thenIO (IO m) k = IO ( \ s ->
  90   case m s of
  91     (# new_s, a #) -> unIO k new_s
  92   )
  93
  94 returnIO :: a -> IO a
  95 returnIO x = IO (\ s -> (# s, x #))
  96
  97 -- ---------------------------------------------------------------------------
  98 -- Coercions between IO and ST
  99
 100 --stToIO        :: (forall s. ST s a) -> IO a
 101 stToIO        :: ST RealWorld a -> IO a
 102 stToIO (ST m) = IO m
 103
 104 ioToST        :: IO a -> ST RealWorld a
 105 ioToST (IO m) = (ST m)
 106
 107 -- ---------------------------------------------------------------------------
 108 -- Unsafe IO operations
 109
 110 {-# NOINLINE unsafePerformIO #-}
 111 unsafePerformIO :: IO a -> a
 112 unsafePerformIO (IO m) = case m realWorld# of (# _, r #)   -> r
 113
 114 {-# NOINLINE unsafeInterleaveIO #-}
 115 unsafeInterleaveIO :: IO a -> IO a
 116 unsafeInterleaveIO (IO m)
 117   = IO ( \ s -> let
 118                    r = case m s of (# _, res #) -> res
 119                 in
 120                 (# s, r #))
 121
 122 -- ---------------------------------------------------------------------------
 123 -- Handle type
 124
 125 data MVar a = MVar (MVar# RealWorld a)
 126 {- ^
 127 An 'MVar' (pronounced \"em-var\") is a synchronising variable, used
 128 for communication between concurrent threads.  It can be thought of
 129 as a a box, which may be empty or full.
 130 -}
 131
 132 -- pull in Eq (Mvar a) too, to avoid GHC.Conc being an orphan-instance module
 133 instance Eq (MVar a) where
 134         (MVar mvar1#) == (MVar mvar2#) = sameMVar# mvar1# mvar2#
 135
 136 --  A Handle is represented by (a reference to) a record
 137 --  containing the state of the I/O port/device. We record
 138 --  the following pieces of info:
 139
 140 --    * type (read,write,closed etc.)
 141 --    * the underlying file descriptor
 142 --    * buffering mode
 143 --    * buffer, and spare buffers
 144 --    * user-friendly name (usually the
 145 --      FilePath used when IO.openFile was called)
 146
 147 -- Note: when a Handle is garbage collected, we want to flush its buffer
 148 -- and close the OS file handle, so as to free up a (precious) resource.
 149
 150 data Handle
 151   = FileHandle                          -- A normal handle to a file
 152         !(MVar Handle__)
 153
 154   | DuplexHandle                        -- A handle to a read/write stream
 155         !(MVar Handle__)                -- The read side
 156         !(MVar Handle__)                -- The write side
 157
 158 -- NOTES:
 159 --    * A 'FileHandle' is seekable.  A 'DuplexHandle' may or may not be
 160 --      seekable.
 161
 162 instance Eq Handle where
 163  (FileHandle h1)     == (FileHandle h2)     = h1 == h2
 164  (DuplexHandle h1 _) == (DuplexHandle h2 _) = h1 == h2
 165  _ == _ = False
 166
 167 type FD = Int -- XXX ToDo: should be CInt
 168
 169 data Handle__
 170   = Handle__ {
 171       haFD          :: !FD,                  -- file descriptor
 172       haType        :: HandleType,           -- type (read/write/append etc.)
 173       haIsBin       :: Bool,                 -- binary mode?
 174       haIsStream    :: Bool,                 -- is this a stream handle?
 175       haBufferMode  :: BufferMode,           -- buffer contains read/write data?
 176       haFilePath    :: FilePath,             -- file name, possibly
 177       haBuffer      :: !(IORef Buffer),      -- the current buffer
 178       haBuffers     :: !(IORef BufferList),  -- spare buffers
 179       haOtherSide   :: Maybe (MVar Handle__) -- ptr to the write side of a
 180                                              -- duplex handle.
 181     }
 182
 183 -- ---------------------------------------------------------------------------
 184 -- Buffers
 185
 186 -- The buffer is represented by a mutable variable containing a
 187 -- record, where the record contains the raw buffer and the start/end
 188 -- points of the filled portion.  We use a mutable variable so that
 189 -- the common operation of writing (or reading) some data from (to)
 190 -- the buffer doesn't need to modify, and hence copy, the handle
 191 -- itself, it just updates the buffer.
 192
 193 -- There will be some allocation involved in a simple hPutChar in
 194 -- order to create the new Buffer structure (below), but this is
 195 -- relatively small, and this only has to be done once per write
 196 -- operation.
 197
 198 -- The buffer contains its size - we could also get the size by
 199 -- calling sizeOfMutableByteArray# on the raw buffer, but that tends
 200 -- to be rounded up to the nearest Word.
 201
 202 type RawBuffer = MutableByteArray# RealWorld
 203
 204 -- INVARIANTS on a Buffer:
 205 --
 206 --   * A handle *always* has a buffer, even if it is only 1 character long
 207 --     (an unbuffered handle needs a 1 character buffer in order to support
 208 --      hLookAhead and hIsEOF).
 209 --   * r <= w
 210 --   * if r == w, then r == 0 && w == 0
 211 --   * if state == WriteBuffer, then r == 0
 212 --   * a write buffer is never full.  If an operation
 213 --     fills up the buffer, it will always flush it before
 214 --     returning.
 215 --   * a read buffer may be full as a result of hLookAhead.  In normal
 216 --     operation, a read buffer always has at least one character of space.
 217
 218 data Buffer
 219   = Buffer {
 220         bufBuf   :: RawBuffer,
 221         bufRPtr  :: !Int,
 222         bufWPtr  :: !Int,
 223         bufSize  :: !Int,
 224         bufState :: BufferState
 225   }
 226
 227 data BufferState = ReadBuffer | WriteBuffer deriving (Eq)
 228
 229 -- we keep a few spare buffers around in a handle to avoid allocating
 230 -- a new one for each hPutStr.  These buffers are *guaranteed* to be the
 231 -- same size as the main buffer.
 232 data BufferList
 233   = BufferListNil
 234   | BufferListCons RawBuffer BufferList
 235
 236
 237 bufferIsWritable :: Buffer -> Bool
 238 bufferIsWritable Buffer{ bufState=WriteBuffer } = True
 239 bufferIsWritable _other = False
 240
 241 bufferEmpty :: Buffer -> Bool
 242 bufferEmpty Buffer{ bufRPtr=r, bufWPtr=w } = r == w
 243
 244 -- only makes sense for a write buffer
 245 bufferFull :: Buffer -> Bool
 246 bufferFull b@Buffer{ bufWPtr=w } = w >= bufSize b
 247
 248 --  Internally, we classify handles as being one
 249 --  of the following:
 250
 251 data HandleType
 252  = ClosedHandle
 253  | SemiClosedHandle
 254  | ReadHandle
 255  | WriteHandle
 256  | AppendHandle
 257  | ReadWriteHandle
 258
 259 isReadableHandleType ReadHandle         = True
 260 isReadableHandleType ReadWriteHandle    = True
 261 isReadableHandleType _                  = False
 262
 263 isWritableHandleType AppendHandle    = True
 264 isWritableHandleType WriteHandle     = True
 265 isWritableHandleType ReadWriteHandle = True
 266 isWritableHandleType _               = False
 267
 268 -- File names are specified using @FilePath@, a OS-dependent
 269 -- string that (hopefully, I guess) maps to an accessible file/object.
 270
 271 type FilePath = String
 272
 273 -- ---------------------------------------------------------------------------
 274 -- Buffering modes
 275
 276 -- Three kinds of buffering are supported: line-buffering,
 277 -- block-buffering or no-buffering.  These modes have the following
 278 -- effects. For output, items are written out from the internal
 279 -- buffer according to the buffer mode:
 280 --
 281 -- o line-buffering  the entire output buffer is written
 282 --   out whenever a newline is output, the output buffer overflows,
 283 --   a flush is issued, or the handle is closed.
 284 --
 285 -- o block-buffering the entire output buffer is written out whenever
 286 --   it overflows, a flush is issued, or the handle
 287 --   is closed.
 288 --
 289 -- o no-buffering output is written immediately, and never stored
 290 --   in the output buffer.
 291 --
 292 -- The output buffer is emptied as soon as it has been written out.
 293
 294 -- Similarly, input occurs according to the buffer mode for handle {\em hdl}.
 295
 296 -- o line-buffering when the input buffer for the handle is not empty,
 297 --   the next item is obtained from the buffer;
 298 --   otherwise, when the input buffer is empty,
 299 --   characters up to and including the next newline
 300 --   character are read into the buffer.  No characters
 301 --   are available until the newline character is
 302 --   available.
 303 --
 304 -- o block-buffering when the input buffer for the handle becomes empty,
 305 --   the next block of data is read into this buffer.
 306 --
 307 -- o no-buffering the next input item is read and returned.
 308
 309 -- For most implementations, physical files will normally be block-buffered
 310 -- and terminals will normally be line-buffered. (the IO interface provides
 311 -- operations for changing the default buffering of a handle tho.)
 312
 313 data BufferMode
 314  = NoBuffering | LineBuffering | BlockBuffering (Maybe Int)
 315    deriving (Eq, Ord, Read, Show)
 316
 317 -- ---------------------------------------------------------------------------
 318 -- IORefs
 319
 320 newtype IORef a = IORef (STRef RealWorld a) deriving Eq
 321
 322 newIORef    :: a -> IO (IORef a)
 323 newIORef v = stToIO (newSTRef v) >>= \ var -> return (IORef var)
 324
 325 readIORef   :: IORef a -> IO a
 326 readIORef  (IORef var) = stToIO (readSTRef var)
 327
 328 writeIORef  :: IORef a -> a -> IO ()
 329 writeIORef (IORef var) v = stToIO (writeSTRef var v)
 330
 331 -- ---------------------------------------------------------------------------
 332 -- Show instance for Handles
 333
 334 -- handle types are 'show'n when printing error msgs, so
 335 -- we provide a more user-friendly Show instance for it
 336 -- than the derived one.
 337
 338 instance Show HandleType where
 339   showsPrec p t =
 340     case t of
 341       ClosedHandle      -> showString "closed"
 342       SemiClosedHandle  -> showString "semi-closed"
 343       ReadHandle        -> showString "readable"
 344       WriteHandle       -> showString "writable"
 345       AppendHandle      -> showString "writable (append)"
 346       ReadWriteHandle   -> showString "read-writable"
 347
 348 instance Show Handle where
 349   showsPrec p (FileHandle   h)   = showHandle p h False
 350   showsPrec p (DuplexHandle _ h) = showHandle p h True
 351
 352 showHandle p h duplex =
 353     let
 354      -- (Big) SIGH: unfolded defn of takeMVar to avoid
 355      -- an (oh-so) unfortunate module loop with GHC.Conc.
 356      hdl_ = unsafePerformIO (IO $ \ s# ->
 357              case h                 of { MVar h# ->
 358              case takeMVar# h# s#   of { (# s2# , r #) ->
 359              case putMVar# h# r s2# of { s3# ->
 360              (# s3#, r #) }}})
 361
 362      showType | duplex = showString "duplex (read-write)"
 363               | otherwise = showsPrec p (haType hdl_)
 364     in
 365     showChar '{' .
 366     showHdl (haType hdl_)
 367             (showString "loc=" . showString (haFilePath hdl_) . showChar ',' .
 368              showString "type=" . showType . showChar ',' .
 369              showString "binary=" . showsPrec p (haIsBin hdl_) . showChar ',' .
 370              showString "buffering=" . showBufMode (unsafePerformIO (readIORef (haBuffer hdl_))) (haBufferMode hdl_) . showString "}" )
 371    where
 372
 373     showHdl :: HandleType -> ShowS -> ShowS
 374     showHdl ht cont =
 375        case ht of
 376         ClosedHandle  -> showsPrec p ht . showString "}"
 377         _ -> cont
 378
 379     showBufMode :: Buffer -> BufferMode -> ShowS
 380     showBufMode buf bmo =
 381       case bmo of
 382         NoBuffering   -> showString "none"
 383         LineBuffering -> showString "line"
 384         BlockBuffering (Just n) -> showString "block " . showParen True (showsPrec p n)
 385         BlockBuffering Nothing  -> showString "block " . showParen True (showsPrec p def)
 386       where
 387        def :: Int
 388        def = bufSize buf
 389
 390 -- ------------------------------------------------------------------------
 391 -- Exception datatype and operations
 392
 393 data Exception
 394   = IOException         IOException     -- IO exceptions
 395   | ArithException      ArithException  -- Arithmetic exceptions
 396   | ArrayException      ArrayException  -- Array-related exceptions
 397   | ErrorCall           String          -- Calls to 'error'
 398   | ExitException       ExitCode        -- Call to System.exitWith
 399   | NoMethodError       String          -- A non-existent method was invoked
 400   | PatternMatchFail    String          -- A pattern match / guard failure
 401   | RecSelError         String          -- Selecting a non-existent field
 402   | RecConError         String          -- Field missing in record construction
 403   | RecUpdError         String          -- Record doesn't contain updated field
 404   | AssertionFailed     String          -- Assertions
 405   | DynException        Dynamic         -- Dynamic exceptions
 406   | AsyncException      AsyncException  -- Externally generated errors
 407   | BlockedOnDeadMVar                   -- Blocking on a dead MVar
 408   | Deadlock                            -- no threads can run (raised in main thread)
 409   | NonTermination
 410
 411 data ArithException
 412   = Overflow
 413   | Underflow
 414   | LossOfPrecision
 415   | DivideByZero
 416   | Denormal
 417   deriving (Eq, Ord)
 418
 419 data AsyncException
 420   = StackOverflow
 421   | HeapOverflow
 422   | ThreadKilled
 423   deriving (Eq, Ord)
 424
 425 data ArrayException
 426   = IndexOutOfBounds    String          -- out-of-range array access
 427   | UndefinedElement    String          -- evaluating an undefined element
 428   deriving (Eq, Ord)
 429
 430 stackOverflow, heapOverflow :: Exception -- for the RTS
 431 stackOverflow = AsyncException StackOverflow
 432 heapOverflow  = AsyncException HeapOverflow
 433
 434 instance Show ArithException where
 435   showsPrec _ Overflow        = showString "arithmetic overflow"
 436   showsPrec _ Underflow       = showString "arithmetic underflow"
 437   showsPrec _ LossOfPrecision = showString "loss of precision"
 438   showsPrec _ DivideByZero    = showString "divide by zero"
 439   showsPrec _ Denormal        = showString "denormal"
 440
 441 instance Show AsyncException where
 442   showsPrec _ StackOverflow   = showString "stack overflow"
 443   showsPrec _ HeapOverflow    = showString "heap overflow"
 444   showsPrec _ ThreadKilled    = showString "thread killed"
 445
 446 instance Show ArrayException where
 447   showsPrec _ (IndexOutOfBounds s)
 448         = showString "array index out of range"
 449         . (if not (null s) then showString ": " . showString s
 450                            else id)
 451   showsPrec _ (UndefinedElement s)
 452         = showString "undefined array element"
 453         . (if not (null s) then showString ": " . showString s
 454                            else id)
 455
 456 instance Show Exception where
 457   showsPrec _ (IOException err)          = shows err
 458   showsPrec _ (ArithException err)       = shows err
 459   showsPrec _ (ArrayException err)       = shows err
 460   showsPrec _ (ErrorCall err)            = showString err
 461   showsPrec _ (ExitException err)        = showString "exit: " . shows err
 462   showsPrec _ (NoMethodError err)        = showString err
 463   showsPrec _ (PatternMatchFail err)     = showString err
 464   showsPrec _ (RecSelError err)          = showString err
 465   showsPrec _ (RecConError err)          = showString err
 466   showsPrec _ (RecUpdError err)          = showString err
 467   showsPrec _ (AssertionFailed err)      = showString err
 468   showsPrec _ (DynException _err)        = showString "unknown exception"
 469   showsPrec _ (AsyncException e)         = shows e
 470   showsPrec _ (BlockedOnDeadMVar)        = showString "thread blocked indefinitely"
 471   showsPrec _ (NonTermination)           = showString "<<loop>>"
 472   showsPrec _ (Deadlock)                 = showString "<<deadlock>>"
 473
 474 instance Eq Exception where
 475   IOException e1      == IOException e2      = e1 == e2
 476   ArithException e1   == ArithException e2   = e1 == e2
 477   ArrayException e1   == ArrayException e2   = e1 == e2
 478   ErrorCall e1        == ErrorCall e2        = e1 == e2
 479   ExitException e1    == ExitException e2    = e1 == e2
 480   NoMethodError e1    == NoMethodError e2    = e1 == e2
 481   PatternMatchFail e1 == PatternMatchFail e2 = e1 == e2
 482   RecSelError e1      == RecSelError e2      = e1 == e2
 483   RecConError e1      == RecConError e2      = e1 == e2
 484   RecUpdError e1      == RecUpdError e2      = e1 == e2
 485   AssertionFailed e1  == AssertionFailed e2  = e1 == e2
 486   DynException _      == DynException _      = False -- incomparable
 487   AsyncException e1   == AsyncException e2   = e1 == e2
 488   BlockedOnDeadMVar   == BlockedOnDeadMVar   = True
 489   NonTermination      == NonTermination      = True
 490   Deadlock            == Deadlock            = True
 491
 492 -- -----------------------------------------------------------------------------
 493 -- The ExitCode type
 494
 495 -- The `ExitCode' type defines the exit codes that a program
 496 -- can return.  `ExitSuccess' indicates successful termination;
 497 -- and `ExitFailure code' indicates program failure
 498 -- with value `code'.  The exact interpretation of `code'
 499 -- is operating-system dependent.  In particular, some values of
 500 -- `code' may be prohibited (e.g. 0 on a POSIX-compliant system).
 501
 502 -- We need it here because it is used in ExitException in the
 503 -- Exception datatype (above).
 504
 505 data ExitCode = ExitSuccess | ExitFailure Int
 506                 deriving (Eq, Ord, Read, Show)
 507
 508 -- --------------------------------------------------------------------------
 509 -- Primitive throw
 510
 511 throw :: Exception -> a
 512 throw exception = raise# exception
 513
 514 ioError         :: Exception -> IO a
 515 ioError err     =  IO $ \s -> throw err s
 516
 517 ioException     :: IOException -> IO a
 518 ioException err =  IO $ \s -> throw (IOException err) s
 519
 520 -- ---------------------------------------------------------------------------
 521 -- IOError type
 522
 523 -- A value @IOError@ encode errors occurred in the @IO@ monad.
 524 -- An @IOError@ records a more specific error type, a descriptive
 525 -- string and maybe the handle that was used when the error was
 526 -- flagged.
 527
 528 type IOError = Exception
 529
 530 data IOException
 531  = IOError {
 532      ioe_handle   :: Maybe Handle,   -- the handle used by the action flagging
 533                                      -- the error.
 534      ioe_type     :: IOErrorType,    -- what it was.
 535      ioe_location :: String,         -- location.
 536      ioe_descr    :: String,         -- error type specific information.
 537      ioe_filename :: Maybe FilePath  -- filename the error is related to.
 538    }
 539
 540 instance Eq IOException where
 541   (IOError h1 e1 loc1 str1 fn1) == (IOError h2 e2 loc2 str2 fn2) =
 542     e1==e2 && str1==str2 && h1==h2 && loc1==loc2 && fn1==fn2
 543
 544 data IOErrorType
 545   -- Haskell 98:
 546   = AlreadyExists
 547   | NoSuchThing
 548   | ResourceBusy
 549   | ResourceExhausted
 550   | EOF
 551   | IllegalOperation
 552   | PermissionDenied
 553   | UserError
 554   -- GHC only:
 555   | UnsatisfiedConstraints
 556   | SystemError
 557   | ProtocolError
 558   | OtherError
 559   | InvalidArgument
 560   | InappropriateType
 561   | HardwareFault
 562   | UnsupportedOperation
 563   | TimeExpired
 564   | ResourceVanished
 565   | Interrupted
 566   | DynIOError Dynamic -- cheap&cheerful extensible IO error type.
 567
 568 instance Eq IOErrorType where
 569    x == y =
 570      case x of
 571        DynIOError{} -> False -- from a strictness POV, compatible with a derived Eq inst?
 572        _ -> getTag# x ==# getTag# y
 573
 574 instance Show IOErrorType where
 575   showsPrec _ e =
 576     showString $
 577     case e of
 578       AlreadyExists     -> "already exists"
 579       NoSuchThing       -> "does not exist"
 580       ResourceBusy      -> "resource busy"
 581       ResourceExhausted -> "resource exhausted"
 582       EOF               -> "end of file"
 583       IllegalOperation  -> "illegal operation"
 584       PermissionDenied  -> "permission denied"
 585       UserError         -> "user error"
 586       HardwareFault     -> "hardware fault"
 587       InappropriateType -> "inappropriate type"
 588       Interrupted       -> "interrupted"
 589       InvalidArgument   -> "invalid argument"
 590       OtherError        -> "failed"
 591       ProtocolError     -> "protocol error"
 592       ResourceVanished  -> "resource vanished"
 593       SystemError       -> "system error"
 594       TimeExpired       -> "timeout"
 595       UnsatisfiedConstraints -> "unsatisified constraints" -- ultra-precise!
 596       UnsupportedOperation -> "unsupported operation"
 597       DynIOError{}      -> "unknown IO error"
 598
 599 userError       :: String  -> IOError
 600 userError str   =  IOException (IOError Nothing UserError "" str Nothing)
 601
 602 -- ---------------------------------------------------------------------------
 603 -- Showing IOErrors
 604
 605 instance Show IOException where
 606     showsPrec p (IOError hdl iot loc s fn) =
 607       showsPrec p iot .
 608       (case loc of
 609          "" -> id
 610          _  -> showString "\nAction: " . showString loc) .
 611       (case hdl of
 612         Nothing -> id
 613         Just h  -> showString "\nHandle: " . showsPrec p h) .
 614       (case s of
 615          "" -> id
 616          _  -> showString "\nReason: " . showString s) .
 617       (case fn of
 618          Nothing -> id
 619          Just name -> showString "\nFile: " . showString name)
 620 \end{code}