Can I be sure of order of IO actions in this example?

Question

At the moment, I have this code in and around main:

import Control.Monad
import Control.Applicative

binSearch :: Ord a => [a] -> a -> Maybe Int

main = do
    xs <- lines <$> readFile "Cars1.txt"
    x <- getLine <* putStr "Registration: "  -- Right?
    putStrLn $ case binSearch xs x of
                    Just n -> "Found at position " ++ show n
                    Nothing -> "Not found"

My hope is for “Registration: ” to be printed, then for the program to wait for the input to x. Does what I've written imply that that will be the case? Do I need the <*, or will putting the putStr expression on the line above make things work as well?

PS: I know I have to convert binSearch to work with arrays rather than lists (otherwise it's probably not worth doing a binary search), but that's a problem for another day.

The only place laziness comes into play here is `readFile`, which is kind of a sneaky function -- the file will be read incrementally as `xs` is demanded. Everything else -- and in general, all actions in the `IO` monad (except `readFile`, `getContents`, which are explicitly written to be lazy) will execute in order as you would expect from an imperative language. — luqui, May 12 '14 at 22:35

chi · Accepted Answer · 2014-05-12T22:53:34.180

7

The line

x <- getLine <* putStr "Registration: "

orders the IO actions left-to-right: first a line is taken as input, then the message is printed, and finally variable x is bound to the result of getLine.

Do I need the <*, or will putting the putStr expression on the line above make things work as well?

If you want the message to precede the input, you have to put the putStr on the line above, as follows:

main :: IO ()
main = do
    xs <- lines <$> readFile "Cars1.txt"
    putStr "Registration: "
    x <- getLine
    putStrLn $ case binSearch xs x of
                    Just n  -> "Found at position " ++ show n
                    Nothing -> "Not found"

Alternatively,

    x <- putStr "Registration: " *> getLine

or

    x <- putStr "Registration: " >> getLine

would work, but they are less readable.

Finally, since you added the lazy-evaluation tag, let me add that your question is actually not about laziness, but about how the operator <* is defined, and in particular about the order in which it sequences the IO actions.

edited May 12 '14 at 22:53

answered May 12 '14 at 22:31

chi

111,837
3
133
218

Yeah I boggled at `<*` a bit, I would find a separate line easier to read. – luqui May 12 '14 at 22:33
So order of statements does matter? I remember doing a similar thing before, and it just acted randomly. – mudri May 13 '14 at 07:41
2

@JamesWood Yes, all the Applicative operators `<$>,<*>,<*,...` sequence IO actions left-to-right. The same holds for `liftM,liftM2,...`. Actions inside a `do` also follow this order. The only operators I can recall sequencing actions right-to-left are `<<` and `=<<`, which are the `flip`ped variants of `>>,>>=`. – chi May 13 '14 at 08:21

Can I be sure of order of IO actions in this example?

1 Answers1