--
import IO
import Concurrent
{-
openFile :: FilePath -> IOMode -> IO Handle
hClose :: Handle -> IO ()
data IOMode = ReadMode | WriteMode | AppendMode
deriving (Eq, Ord, Ix, Bounded, Enum, Read, Show)
-- When in WriteMode
hPutChar :: Handle -> Char -> IO ()
hPutStr :: Handle -> String -> IO ()
hPutStrLn :: Handle -> String -> IO ()
hPrint :: Show a => Handle -> a -> IO ()
-- When in ReadMode
hGetChar :: Handle -> IO Char
hGetLine :: Handle -> IO String
-- Entire Contents returned as String
hGetContents :: Handle -> IO String
-- Why use Handle's when we have functions like:
writeFile :: FilePath -> String -> IO ()
appendFile :: FilePath -> String -> IO ()
-- Predefined standard Channels
stdin, stdout, stderr :: Handle
-- Error Handling while doing IO
isEOFError :: IOError -> Bool
ioError :: IOError -> IO a -- Raise an IOError
catch :: IO a -> (IOError -> IO a) -> IO a
-}
getChar' :: IO Char
getChar' = catch getChar (\ e -> return '\n')
getChar2 :: IO Char
getChar2 = catch getChar (\ e -> if isEOFError e then return '\n' else ioError e)
getLine' :: IO String
getLine' = catch getLine'' (\ e -> return ("Error: " ++ show e))
where getLine'' =
do { c <- getChar2 ; if c == '\n' then return "" else do { l <- getLine' ; return (c:l) } } getAndOpenFile :: String -> IOMode -> IO Handle
getAndOpenFile prompt mode =
do { putStr prompt
; name <- getLine ; catch (openFile name mode) (\e -> do { putStrLn ("Cannot open: "++name)
; print e
; getAndOpenFile prompt mode
})
}
main =
do { fromHandle <- getAndOpenFile "Copy from: " ReadMode ; toHandle <- getAndOpenFile "Copy to: " WriteMode ; contents <- hGetContents fromHandle ; hPutStr toHandle contents ; hClose fromHandle ; hClose toHandle ; putStr "Done\n" } -- First Class Channels {- -- First Class Channel Operations newChan :: IO (Chan a) writeChan :: Chan a -> a -> IO ()
readChan :: Chan a -> IO a
getChanContents :: Chan a -> IO [a]
isEmptyChan :: Chan a -> IO Bool
-}
ex1 =
do { c <- newChan ; writeChan c 'a' ; writeChan c 'b' ; a <- readChan c ; b <- readChan c ; print [a,b] ; return [a,b] } -- forkIO :: IO () -> IO ()
ex2 :: IO()
ex2 = do { c1 <- newChan :: IO(Chan Int) ; c2 <- newChan :: IO(Chan Int) ; forkIO (client c1 c2) ; forkIO (server c2 c1) } client :: Chan Int -> Chan Int -> IO ()
client cin cout =
do { writeChan cout 1
; loop
}
where loop = do { c <- readChan cin ; print c ; writeChan cout c ; loop } server :: Chan Int -> Chan Int -> IO ()
server cin cout =
do loop
where loop = do { c <- readChan cin ; writeChan cout (c+1) ; loop } --