Curry: An Integrated Functional Logic Language

take a character (string) and produces an action which, when applied to a world, puts this character
(string) to the standard output (and a line-feed in case of putStrLn.
Since an interactive program consists of a sequence of I/O operations, where the order in the
sequence is important, there are two operations to compose actions in a particular order. The
function
(>>) :: IO a -> IO b -> IO b
takes two actions as input and yields an action as output. The output action consists of performing
the first action followed by the second action, where the produced value of the first action is ignored.
If the value of the first action should be taken into account before performing the second action,
the actions can be composed by the function
(>>=) :: IO a -> (a -> IO b) -> IO b
where the second argument is a function taking the value produced by the first action as input and
performs another action. For instance, the action
getLine >>= putStrLn
is of type IO () and copies, when executed, a line from standard input to standard output.
The return function
return :: a -> IO a
is sometimes useful to terminate a sequence of actions and return a result of an I/O operation.
Thus, return v is an action which does not change the world and returns the value v.
To execute an action, it must be the main expression in a program, i.e., interactive programs
have type IO (). Since the world cannot be copied (note that the world contains at least the
complete file system), non-determinism in relation with I/O operations must be avoided. Thus,
the applied action must always be known, i.e., >> and >>= are rigid in their arguments. Moreover,
it is a runtime error if a disjunctive expression (cf. Section 3) σ1 e1 |· · ·| σn en, where the ei’s
are of type IO () and n > 1, occurs as the top-level expression of a program, since it is unclear in
this case which of the disjunctive actions should be applied to the current world. Thus, all possible
search must be encapsulated between I/O operations (see Section 8).
Using the evaluation annotations, a compiler is able to detect functions where search is definitely
avoided (e.g., if all evaluated positions are declared as rigid). Thus, the compiler may warn the
user about non-deterministic computations which may occur in I/O actions so that the programmer
can encapsulate them.
7.2 Do Notation
To provide a more conventional notation for programming sequences of I/O operations, Curry has
a special piece of syntax for writing such sequences. For instance, consider the following expression
to read a line form the standard input and to print them together with the string "Your input: "
on the standard output:
getLine >>= \line -> putStr "Your input: " >> putStrLn line
Using the do notation, this expression can be written in a more traditional style:
28