IO Semantics

The printable version is no longer supported and may have rendering errors. Please update your browser bookmarks and please use the default browser print function instead.

Note:

For simplicity, the examples here only gives semantics for teletype I/O.

These are only some of the various ways to describe the semantics of IO a; your actual implementation may vary.

A free approach

(Inspired by Luke Palmer's post.)

The idea is to define IO as

data IO a = Done a
          | PutChar Char (IO a)
          | GetChar (Char -> IO a)

Think of IO a as a tree:

PutChar is a node that has one child tree and the node holds one character of data.
GetChar is a node that has many children; it has one child for every character, but GetChar holds no data itself.
Done a (a leaf) is a node that holds the result of the program.

This tree contains all the information needed to execute basic interactions. One interprets (or executes) an IO a by tracing a route from root of the tree to a leaf:

If a PutChar node is encountered, the character data contained at that node is output to the terminal and then its subtree is executed. It is at this point that Haskell code is evaluated in order to determine what character should be displayed before continuing.
If a GetChar node is encountered, a character is read from the terminal (blocking if necessary) and the subtree corresponding to the character received is executed.
If a Done node is encountered, the program ends.

Done holds the result of the computation, but in the case of Main.main :: IO () the data is of type () and thus ignored as it contains no information.

This execution is not done anywhere in a Haskell program, rather it is done by the run-time system.

The monadic operations are defined as follows:

return :: a -> IO a
return x = Done x

(>>=)  :: IO a -> (a -> IO b) -> IO b
Done x      >>= f = f x
PutChar c x >>= f = PutChar c (x >>= f)
GetChar g   >>= f = GetChar (\c -> g c >>= f)

As you can see return is just another name for Done. The bind operation (>>=) takes a tree x and a function f and replaces the Done nodes (the leaves) of x by a new tree produced by applying f to the data held in the Done nodes.

The primitive I/O commands are defined using these constructors.

putChar :: Char -> IO ()
putChar x = PutChar x (Done ())

getChar :: IO Char
getChar = GetChar (\c -> Done c)

The function putChar builds a small IO () tree that contains one PutChar node holding the character data followed by Done.
The function getChar builds a short IO Char tree that begins with a GetChar node that holds one Done node for every character.

Other commands can be defined in terms of these primitives:

putStr :: String -> IO ()
putStr = mapM_ putChar

More generally speaking, IO a will represent the desired interaction with the operating system. For every system call there will be a corresponding I/O-tree constructor of the form:

	| SysCallName p1 p2 ... pn (r -> IO a)

where:

p1 ... pn are the parameters for the system call,
and r is the result of the system call.

(Thus PutChar and GetChar will not occur as constructors for I/O trees if they don't correspond to system calls).

A more direct style

Here is the key idea:

A value of type IO a is an “action” that, when performed, may do some input/output, before delivering a value of type a.

Tackling the Awkward Squad (page 5 of 60).

It also has a simple translation:

            type IO a = (->) OI a
                  .       .  .  .
 an action that __|       |  |  |
                          |  |  |
 when performed __________|  |  |
                             |  |
 may do some input/output ___|  |
                                |
 before delivering a value _____|

Think of an IO a action as an entity which:

can be used like other Haskell functions,
but may also have effects like procedures.

This combination of denotative and imperative features is enough to provide basic interactions. An IO a action works by calling it when applied to an OI argument, subject to certain conditions:

Each OI value should be distinct from all others, to help preserve referential transparency.
Each OI value should be used at most once, to ensure actions can be used like other functions.

As for the OI type itself:

data OI  -- no constructors are visible to the user

Most OI values would then be provided by one or more specific actions:

foreign import partOI  :: OI -> (OI, OI)

partsOI                :: OI -> [OI]
partsOI u              = let !(u1, u2) = partOI u in u1 : partsOI u2

but in the case of Main.main :: IO () the initial argument is provided directly by the implementation. It is from this initial argument that all other OI values in the program are obtained.

Not being able to define OI values directly in Haskell means actions in a Haskell program cannot work until the program, applied to its initial OI argument, is called by the run-time system.

The monadic operations are defined as follows:

instance Monad ((->) OI)
  where
        return x =  \ u -> let !_ = partOI u in x 

        m >>= k  =  \ u -> let !(u1, u2) = partOI u
                               !x = m u1
                               !y = k x u2 in
                           in y

Note that both methods use their OI parameters, with return simply returning its other parameter x to the caller. The bind operation (>>=) takes an action m and a function k and uses new OI values to call m to obtain x, then call k x to obtain the result y.

Other actions can be declared:

foreign import getChar :: OI -> Char
foreign import putChar :: Char -> OI -> ()

or defined:

getLine                :: OI -> [Char]
getLine                = do c <- getChar
                            if c == ’\n’ then return ""
                                         else do cs <- getLine
                                              return (c:cs)

putStr                 :: [Char] -> OI -> ()
putStr cs              = foldr (\ !(_) -> id) () . zipWith putChar cs . partsOI

In more fully-featured implementations, each system call would have its own declaration:

primitive primSysCallName :: T1 -> T2 -> ... -> OI -> Tr

foreign import ... extnSysCallName :: T1 -> T2 -> ... -> OI -> Tr

where:

T1, T2 ... are the types of the parameters for the system call,
and Tr is the type of the system call's result.

IO Semantics

A free approach

A more direct style

Further reading

Navigation menu

Search