Haskell not executing all external shell commands - shell

Question

I wrote this program and I compiled with:
ghc --make shell.hs
When I run it looks like:
$./shell
enter your number:
6
6
okay... it execute 6 time...
If I remove the sleep 2 statement then it exits fast but outputs only 6.
I tried to follow the advice (which is what is in the code below) given at this answer of a similar question but it didn't work.
It seems very strange that it is not executing all the commands. How do I force it to execute all commands and in a strict order? the lazyness is a good feature but when it comes to IO it just sucks or I am not enough of an expert to understand it.
What I want to do is execute all commands from a list in a strict order and I don't want Haskell to "intelligently" remove some of the commands on my behalf (if I want to execute sleep for 2 seconds in the shell, I should be allowed to do so).
If waitForProcess has to be used to resolve this, then my problem is I don't know how to use it. I have tried google but failed to see a simple example of it.
Please note that I want a working code solution for the program code I have given below and there should be a reasonable guarantee that the program works as expected on bash running on a typical Linux (say, Debian 7) as the Python program given below it runs.
import System.Process
import System.Exit
main = do
putStrLn "enter your number:"
n <- getLine
main1 (readInt n)
putStrLn ("okay... it execute " ++ n ++" time...")
readInt:: String -> Int
readInt = read
main1 n = do
ExitSuccess <- system ("echo " ++ (show n))
ExitSuccess <- system "sleep 2"
if n == 0 then (main1 (n-1)) else return ()
Below is a Python program and it works as desired with proper sleep:
import os
for i in range(6):
os.system("echo " + str(i))
os.system("sleep 2")

Answer 1

How about writing more like the Python version using forM_:
import Control.Monad
main1 n = do
forM_ [n,n-1 .. 1] $ \n -> do
ExitSuccess <- system ("echo " ++ (show n))
ExitSuccess <- system "sleep 2"
return ()

Answer 2

The program is doing what you are telling him to do:
main1 n = do
ExitSuccess <- system ("echo " ++ (show n))
ExitSuccess <- system "sleep 2"
if n == 0 then (main1 (n-1)) else return ()
Here we have n == 6 so the condition of the if is false and then return () is executed, which terminates main1 doing nothing.
Note that if you passed n == 0 the condition would be true and it would execute main1 (-1) which then stops. In any case main1 will not repeat the commands n times it will always either execute them once (if n /= 0) or twice (if n == 0).
You could fix this by doing:
main1 n = do
ExitSuccess <- system ("echo " ++ (show n))
ExitSuccess <- system "sleep 2"
if n > 0 then main1 (n-1) else return ()
Or, equivalently:
import Control.Monad
main1 n = do
ExitSuccess <- system ("echo " ++ (show n))
ExitSuccess <- system "sleep 2"
when (n > 0) $ main1 (n-1)
The problem here is that you are using general recursion to repeat a given statement. But general recursion can do anything and so you can easily produce bugs (as in your case). To avoid this it's often useful to use some other function to build your code. For example:
main1 n = sequence_ $ map execute [1..n]
execute i = do
ExitSuccess <- system $ "echo" ++ show i
ExitSuccess <- system $ "sleep 2"
return ()
Or:
main1 n = mapM_ execute [1..n]
Here you know what mapM_ and [1..n] do and so combining them tells you that you the execute action will be executed n times.
In any case the IO monad guarantees the the actions are all executed and in order, so you should not attribute to Haskell lazyness the fact that the code wasn't executed the expected number of times.
The problem with lazyness and input/output are different.