pure-io-0.2.1: Pure IO monad.

Safe HaskellNone
LanguageHaskell98

PureIO

Contents

Description

Pure IO monad, intended for educational use.

Synopsis

The IO monad and its machinery

runIO :: Input -> IO a -> (Either Interrupt a, Output) #

Run the IO monad. This should be called in succession. Depending on the type of interrupt, this function should be re-run with the same action but with additional input.

data IO a #

A pure IO monad.

Instances

Monad IO # 

Methods

(>>=) :: IO a -> (a -> IO b) -> IO b #

(>>) :: IO a -> IO b -> IO b #

return :: a -> IO a #

fail :: String -> IO a #

Functor IO # 

Methods

fmap :: (a -> b) -> IO a -> IO b #

(<$) :: a -> IO b -> IO a #

Applicative IO # 

Methods

pure :: a -> IO a #

(<*>) :: IO (a -> b) -> IO a -> IO b #

(*>) :: IO a -> IO b -> IO b #

(<*) :: IO a -> IO b -> IO a #

data Input #

User input.

Constructors

Input 

Fields

Instances

data Output #

IO monad output.

Constructors

Output 

Fields

Instances

data Interrupt #

Something that interrupts the flow of the IO monad.

Constructors

InterruptStdin

When you receive this interrupt, you should get some standard input from somewhere and then provide it in the Input value next time you call runIO.

InterruptException !IOException

When you receive this interrupt, you should consider the computation as ended.

Instances

Library of actions

data IOException #

An IO exception.

Constructors

UserError String 
FileNotFound FilePath 
DirectoryNotFound FilePath 

Instances

putStrLn :: String -> IO () #

The same as putStr, but adds a newline character.

putStr :: String -> IO () #

Write a string to the standard output device.

getLine :: IO String #

Read a line from standard input.

readLn :: Read a => IO a #

The readLn function combines getLine and readIO.

print :: Show a => a -> IO () #

The print function outputs a value of any printable type to the standard output device. Printable types are those that are instances of class Show; print converts values to strings for output using the show operation and adds a newline.

For example, a program to print the first 20 integers and their powers of 2 could be written as:

main = print ([(n, 2^n) | n <- [0..19]])

readIO :: Read a => String -> IO a #

The readIO function is similar to read except that it signals parse failure to the IO monad instead of terminating the program.

throw :: IOException -> IO a #

Throw an IO exception.

catch :: IO a -> (IOException -> IO a) -> IO a #

Catch an IO exception.

readFile :: FilePath -> IO String #

The readFile function reads a file and returns the contents of the file as a string. The file is read lazily, on demand, as with getContents.

writeFile :: FilePath -> String -> IO () #

The computation writeFile file str function writes the string str, to the file file.

appendFile :: FilePath -> String -> IO () #

The computation appendFile file str function appends the string str, to the file file.

Note that writeFile and appendFile write a literal string to a file. To write a value of any printable type, as with print, use the show function to convert the value to a string first.

main = appendFile "squares" (show [(x,x*x) | x <- [0,0.1..2]])

doesFileExist :: FilePath -> IO Bool #

The operation doesFileExist returns True if the argument file exists, and False otherwise.

removeFile :: FilePath -> IO () #

removeFile file removes the directory entry for an existing file file.

getDirectoryContents :: FilePath -> IO [FilePath] #

Get all files in the given directory.