content: module PreludeIO {-(
      FilePath, IOError(..), ioError, userError, catch,
      putChar, putStr, putStrLn, print,
      getChar, getLine, getContents, interact,
      readFile, writeFile, appendFile, readIO, readLn
    )-} where
  
  import PreludeBuiltin
  
  type  FilePath = String
  
  data IOErrorKind
    = EOFError          
    | OtherError
    | UserError
    | AlreadyExistsError 
    | DoesNotExistError 
    | AlreadyInUseError 
    | FullError         
    | IllegalOperation  
    | PermissionError   
    deriving (Eq)
  --instance Eq IOErrorKind
  
  -- The internals of this type are system dependent:
  data IOError = IOE IOErrorKind String --deriving (Eq)
  
  instance  Show IOError  --where ...
  instance  Eq IOError  --where ...
  
  ioError          ::  IOError -> IO a
  ioError          =   undefined--primIOError
  
  userError        ::  String -> IOError
  userError        =   IOE UserError
  
  catch            ::  IO a -> (IOError -> IO a) -> IO a
  catch            =   undefined--primCatch
  
  putChar          :: Char -> IO ()
  putChar          =  undefined--primPutChar
  
  putStr           :: String -> IO ()
  putStr s         =  mapM_ putChar s
  
  putStrLn         :: String -> IO ()
  putStrLn s       =  do putStr s
                         putStr "\n"
  
  print            :: Show a => a -> IO ()
  print x          =  putStrLn (show x)
  
  getChar          :: IO Char
  getChar          =  undefined--primGetChar
  
  getLine          :: IO String
  getLine          =  do c <- getChar
                         if c == '\n' then return "" else
                            do s <- getLine
                               return (c:s)
  
  
  foreign import getContents      :: IO String
  foreign import readFile         :: FilePath -> IO String
  foreign import writeFile        :: FilePath -> String -> IO ()
  foreign import appendFile       :: FilePath -> String -> IO ()
  
  interact         ::  (String -> String) -> IO ()
  interact f       =  do s <- getContents
                         putStr (f s)
  
  
    -- raises an exception instead of an error
  
  readIO   :: Read a => String -> IO a
  readIO s =  case [x | (x,t) <- reads s, ("","") <- lex t] of
                [x] -> return x
                []  -> ioError (userError "Prelude.readIO: no parse")
                _   -> ioError (userError "Prelude.readIO: ambiguous parse")
  
  readLn           :: Read a => IO a
  readLn           =  do l <- getLine
                         r <- readIO l
                         return r
  