Haskell/Simple input and output
So far this tutorial has discussed functions that return values, which is well and good. But how do we write "Hello world"? To give you a first taste of it, here is a small variant of the "Hello world" program:
Example: Hello! What is your name?
main = do putStrLn "Please enter your name: " name <- getLine putStrLn ("Hello, " ++ name ++ ", how are you?")
At the very least, what should be clear is that dealing with input and output (IO) in Haskell is not a lost cause! Pure functional languages have always had a problem with input and output because IO requires side effects. Pure functions always have to return the same results for the same arguments. But how can such a function "getLine" return the same value every time it is called?
Before we give the solution, let's take a step back and think about the difficulties inherent in such a task.
Any IO library should provide a host of functions, containing (at a minimum) operations like:
- print a string to the screen
- read a string from a keyboard
- write data to a file
- read data from a file
There are two issues here. Let's first consider the initial two examples and think about what their types should be. Certainly the first procedure should take a
String argument and produce something, but what should it produce? It could produce a unit
(), since there is essentially no return value from printing a string. The second operation, similarly, should return a
String, but it doesn't seem to require an argument.
We want both of these operations to be pure functions, but they are, by definition, not pure. The item that reads a string from the keyboard cannot be a function, as it will not return the same
String every time. If the first function simply returns
() every time, then referential transparency tells us we should have no problem replacing it with a function
f _ = (), but clearly this does not have the desired result because the function has a side effect: it prints the argument.
The breakthrough for solving this problem came when Philip Wadler realized that monads would be a good way to think about IO computations. In fact, monads are able to express much more than just the simple operations described above; we can use them to express a variety of constructions like concurrence, exceptions, IO, non-determinism and much more. Moreover, there is nothing special about them; they can be defined within Haskell with no special handling from the compiler (though compilers often choose to optimize monadic operations). Monads also have a somewhat undeserved reputation of being difficult to understand. So we're going to leave things at that – knowing simply that IO somehow makes use of monads without necessarily understanding the gory details behind them (they really aren't so gory). So for now, we can forget that monads even exist.
As pointed out before, we cannot think of things like "print a string to the screen" or "read data from a file" as functions, since they are not (in the pure mathematical sense). Therefore, we give them another name: actions. Not only do we give them a special name; we give them a special type to complement it. One particularly useful action is
putStrLn, which prints a string to the screen. This action has type:
putStrLn :: String -> IO ()
putStrLn takes a string argument. What it returns is of type
IO (). This means that this function is actually an action (that is what the
IO means). Furthermore, when this action is evaluated (or "run") , the result will have type
You can probably already guess the type of
getLine :: IO String
This means that
getLine is an IO action that, when run, will have type
The question immediately arises: "how do you 'run' an action?". This is something that is left up to the compiler. You cannot actually run an action yourself; instead, a program is, itself, a single action that is run when the compiled program is executed. Thus, the compiler requires that the
main function have type
IO (), which means that it is an IO action that returns nothing. The compiled code then executes this action.
However, while you are not allowed to run actions yourself, you are allowed to
combine actions. There are two ways to go about this. The one we will focus on in this chapter is the do notation, which provides a convenient means of putting actions together, and allows us to get useful things done in Haskell without having to understand what really happens. Lurking behind the do notation is the more explicit approach using the (>>=) operator, but we will not be ready to cover this until the chapter Understanding monads.
Let's consider the following name program:
Example: What is your name?
main = do putStrLn "Please enter your name: " name <- getLine putStrLn ("Hello, " ++ name ++ ", how are you?")
We can consider the do notation as a way to combine a sequence of actions. Moreover, the
<- notation is a way to get the value out of an action. So, in this program, we're sequencing three actions: a
getLine and another
putStrLn action has type
String -> IO (), so we provide it a
String, and the fully applied action has type
IO (). This is something that we are allowed to run as a program.
Write a program which asks the user for the base and height of a right angled triangle, calculates its area and prints it to the screen. The interaction should look something like:
The base? 3.3 The height? 5.4 The area of that triangle is 8.91Hint: you can use the function
Left arrow clarifications
<- is optional
While we are allowed to get a value out of certain actions like
getLine, we certainly are not obliged to do so. For example, we could very well have written something like this:
main = do putStrLn "Please enter your name: " getLine putStrLn ("Hello, how are you?")
Clearly, that isn't very useful: the whole point of prompting the user for his or her name was so that we could do something with the result. That being said, it is conceivable that one might wish to read a line and completely ignore the result. Omitting the
<- will allow for that; the action will happen, but the data won't be stored anywhere.
In order to get the value out of the action, we write
name <- getLine, which basically means "run
getLine, and put the results in the variable called
<- can be used with any action but the last
On the flip side, there are also very few restrictions on which actions can have values obtained from them. Consider the following example, where we put the results of each action into a variable (except the last... more on that later):
Example: putting all results into a variable
main = do x <- putStrLn "Please enter your name: " name <- getLine putStrLn ("Hello, " ++ name ++ ", how are you?")
x gets the value out of its action, but that isn't very interesting because the action returns the unit value
(). So while we could technically get the value out of any action, it isn't always worth it. But wait, what about that last action? Why can't we get a value out of that? Let's see what happens when we try:
Example: getting the value out of the last action
main = do x <- putStrLn "Please enter your name: " name <- getLine y <- putStrLn ("Hello, " ++ name ++ ", how are you?")
YourName.hs:5:2: The last statement in a 'do' construct must be an expression
This is a much more interesting example, but it requires a somewhat deeper understanding of Haskell than we currently have. Suffice it to say, whenever you use
<- to get the value of an action, Haskell is always expecting another action to follow it. So the very last action better not have any
Normal Haskell constructions like if/then/else can be used within the do notation, but you need to be somewhat careful. For instance, in a simple "guess the number" program, we have:
doGuessing num = do putStrLn "Enter your guess:" guess <- getLine if (read guess) < num then do putStrLn "Too low!" doGuessing num else if (read guess) > num then do putStrLn "Too high!" doGuessing num else do putStrLn "You Win!"
If we think about how the if/then/else construction works, it essentially takes three arguments: the condition, the "then" branch, and the "else" branch. The condition needs to have type
Bool, and the two branches can have any type, provided that they have the same type. The type of the entire if/then/else construction is then the type of the two branches.
In the outermost comparison, we have
(read guess) < num as the condition. This clearly has the correct type. Let's just consider the "then" branch. The code here is:
do putStrLn "Too low!" doGuessing num
Here, we are sequencing two actions:
doGuessing. The first has type
IO (), which is fine. The second also has type
IO (), which is fine. The type result of the entire computation is precisely the type of the final computation. Thus, the type of the "then" branch is also
IO (). A similar argument shows that the type of the "else" branch is also
IO (). This means the type of the entire if/then/else construction is
IO (), which is just what we want.
It is incorrect to think to yourself "Well, I already started a do block; I don't need another one," and hence write something like:
do if (read guess) < num then putStrLn "Too low!" doGuessing num else ...
Here, since we didn't repeat the do, the compiler doesn't know that the
doGuessing calls are supposed to be sequenced, and the compiler will think you're trying to call
putStrLn with three arguments: the string, the function
doGuessing and the integer
num. It will certainly complain (though the error may be somewhat difficult to comprehend at this point).
Write a program that asks the user for his or her name. If the name is one of Simon, John or Phil, tell the user that you think Haskell is a great programming language. If the name is Koen, tell them that you think debugging Haskell is fun (Koen Classen is one of the people who works on Haskell debugging); otherwise, tell the user that you don't know who he or she is.(As far as syntax goes there are a few different ways to do it; write at least a version using
Actions under the microscope
Actions may look easy up to now, but they are actually a common stumbling block for new Haskellers. If you have run into trouble working with actions, you might consider looking to see if one of your problems or questions matches the cases below. It might be worth skimming this section now, and coming back to it when you actually experience trouble.
Mind your action types
One temptation might be to simplify our program for getting a name and printing it back out. Here is one unsuccessful attempt:
Example: Why doesn't this work?
main = do putStrLn "What is your name? " putStrLn ("Hello " ++ getLine)
YourName.hs:3:26: Couldn't match expected type `[Char]' against inferred type `IO String'
Let us boil the example above down to its simplest form. Would you expect this program to compile?
Example: This still does not work
main = do putStrLn getLine
For the most part, this is the same (attempted) program, except that we've stripped off the superfluous "What is your name" prompt as well as the polite "Hello". One trick to understanding this is to reason about it in terms of types. Let us compare:
putStrLn :: String -> IO () getLine :: IO String
We can use the same mental machinery we learned in Type basics to figure how everything went wrong. Simply put, putStrLn is expecting a
String as input. We do not have a
String, but something tantalisingly close, an
IO String. This represents an action that will give us a
String when it's run. To obtain the
putStrLn wants, we need to run the action, and we do that with the ever-handy left arrow,
Example: This time it works
main = do name <- getLine putStrLn name
Working our way back up to the fancy example:
main = do putStrLn "What is your name? " name <- getLine putStrLn ("Hello " ++ name)
Now the name is the String we are looking for and everything is rolling again.
Mind your expression types too
Fine, so we've made a big deal out of the idea that you can't use actions in situations that don't call for them. The converse of this is that you can't use non-actions in situations that DO expect actions. Say we want to greet the user, but this time we're so excited to meet them, we just have to SHOUT their name out:
Example: Exciting but incorrect. Why?
import Data.Char (toUpper) main = do name <- getLine loudName <- makeLoud name putStrLn ("Hello " ++ loudName ++ "!") putStrLn ("Oh boy! Am I excited to meet you, " ++ loudName) -- Don't worry too much about this function; it just capitalises a String makeLoud :: String -> String makeLoud s = map toUpper s
This goes wrong...
Couldn't match expected type `IO' against inferred type `' Expected type: IO t Inferred type: String In a 'do' expression: loudName <- makeLoud name
This is quite similar to the problem we ran into above: we've got a mismatch between something that is expecting an IO type, and something which does not produce one. This time, the cause is our use of the left arrow
<-; we're trying to left arrow a value of
makeLoud name, which really isn't left arrow material. It's basically the same mismatch we saw in the previous section, except now we're trying to use regular old String (the loud name) as an IO String, when those clearly are not the same thing. The latter is an action, something to be run, whereas the former is just an expression minding its own business. Note that we cannot simply use
loudName = makeLoud name because a
do sequences actions, and
loudName = makeLoud name is not an action.
So how do we extricate ourselves from this mess? We have a number of options:
- We could find a way to turn
makeLoudinto an action, to make it return
IO String. But this is not desirable, because the whole point of functional programming is to cleanly separate our side-effecting stuff (actions) from the pure and simple stuff. For example, what if we wanted to use makeLoud from some other, non-IO, function? An IO
makeLoudis certainly possible (how?), but missing the point entirely.
- We could use
returnto promote the loud name into an action, writing something like
loudName <- return (makeLoud name). This is slightly better, in that we are at least leaving the
makeLoudfunction itself nice and IO-free, whilst using it in an IO-compatible fashion. But it's still moderately clunky, because by virtue of left arrow, we're implying that there's action to be had -- how exciting! -- only to let our reader down with a somewhat anticlimactic
- Or we could use a let binding...
It turns out that Haskell has a special extra-convenient syntax for let bindings in actions. It looks a little like this:
let bindings in
main = do name <- getLine let loudName = makeLoud name putStrLn ("Hello " ++ loudName ++ "!") putStrLn ("Oh boy! Am I excited to meet you, " ++ loudName)
If you're paying attention, you might notice that the let binding above is missing an
in. This is because
let bindings in
do blocks do not require the
in keyword. You could very well use it, but then you'd have to make a mess of your do blocks. For what it's worth, the following two blocks of code are equivalent.
do name <- getLine let loudName = makeLoud name putStrLn ("Hello " ++ loudName ++ "!") putStrLn ( "Oh boy! Am I excited to meet you, " ++ loudName)
do name <- getLine let loudName = makeLoud name in do putStrLn ("Hello " ++ loudName ++ "!") putStrLn ( "Oh boy! Am I excited to meet you, " ++ loudName)
At this point, you should have the fundamentals needed to do some fancier input/output. Here are some IO-related topics you may want to check in parallel with the main track of the course.