Why program flow control executes randomly - haskell

Question

I'm trying to learn math and Haskell at the same time by programming a simple math learning program.
It starts by:
Generating random numbers.
Filters those numbers to create an easy problem to work with.
Display the question then take my answer
Lastly, it hands both my answer and the correct answer to another function to give me feedback (a "Congratulations" --or-- "Sorry, the correct answer is BLANK).
For some reason, after the congratulations function ends, it seems to randomly choose where it goes next, either:
It returns to main (which is what I expect it to do).
Or at random loops it'll go immediately to the math testing function. When this happens, step 2 from above doesn't occur and I start getting fractional numbers in the question. Then it may repeat this step or go back to main.
When trying to debug the problem I would just keep hitting RETURN and it would occur at different times. I've also added some debug 'print' statements.
Here's 3 functions from the program. Note that main calls funPercentOfNumberToAnother:
funPercentOfNumberToAnother :: IO ()
funPercentOfNumberToAnother = do
(percentDec, percentStr) <- getPercent
ofNum <- getDecimal (200 :: Decimal)
let isNum = percentDec * ofNum
if uglyAnswers ([ofNum, isNum], [percentDec])
then do
putStrLn ("ofNum: " ++ show ofNum)
putStrLn ("isNum: " ++ show isNum)
putStrLn "___________________________"
funPercentOfNumberToAnother
else do
putStrLn ("ofNum: " ++ show ofNum)
putStrLn ("isNum: " ++ show isNum)
putStrLn "Percents"
-- putStrLn "\n\n"
putStrLn (show isNum ++ " is what percent of " ++ show ofNum ++ "?\n" )
putStr "> "
ans <- getLine
submitStringAnswer (ans, percentStr ++ "%")
submitStringAnswer :: (String, String) -> IO ()
submitStringAnswer (myAns, correctAns) = do
if myAns == correctAns
then putStrLn "Congratz!"
else do
putStrLn ("Sorry the correct answer is: " ++ show correctAns)
pause
pause :: IO ()
pause = do
x <- getLine
putStrLn ""
Here's my debug output. Notice that The only time it gives fractional numbers is after it doesn't return to main immediately after pause ends.
__ __ _ _ _ _
| \/ | __ _| |_| |__ ___ _ __ ___ __ _| |_(_) ___ ___
| |\/| |/ _` | __| '_ \ / _ \ '_ ` _ \ / _` | __| |/ __/ __|
| | | | (_| | |_| | | | __/ | | | | | (_| | |_| | (__\__
|_| |_|\__,_|\__|_| |_|\___|_| |_| |_|\__,_|\__|_|\___|___/
1.) Learn Math
2.) Math Lookup
3.) Quit Excolo
1
ofNum: 35
isNum: 15.75
___________________________
ofNum: 120
isNum: 102
Percents
102 is what percent of 120?
>
Sorry the correct answer is: "85%"
15.75 is what percent of 35?
>
Sorry the correct answer is: "45%"
__ __ _ _ _ _
| \/ | __ _| |_| |__ ___ _ __ ___ __ _| |_(_) ___ ___
| |\/| |/ _` | __| '_ \ / _ \ '_ ` _ \ / _` | __| |/ __/ __|
| | | | (_| | |_| | | | __/ | | | | | (_| | |_| | (__\__
|_| |_|\__,_|\__|_| |_|\___|_| |_| |_|\__,_|\__|_|\___|___/
1.) Learn Math
2.) Math Lookup
3.) Quit Excolo
1
ofNum: 80
isNum: 44
Percents
44 is what percent of 80?
>
Sorry the correct answer is: "55%"
__ __ _ _ _ _
| \/ | __ _| |_| |__ ___ _ __ ___ __ _| |_(_) ___ ___
| |\/| |/ _` | __| '_ \ / _ \ '_ ` _ \ / _` | __| |/ __/ __|
| | | | (_| | |_| | | | __/ | | | | | (_| | |_| | (__\__
|_| |_|\__,_|\__|_| |_|\___|_| |_| |_|\__,_|\__|_|\___|___/
1.) Learn Math
2.) Math Lookup
3.) Quit Excolo
1
ofNum: 15
isNum: 2.25
___________________________
ofNum: 60
isNum: 0.6
___________________________
ofNum: 40
isNum: 30
Percents
30 is what percent of 40?
>
Sorry the correct answer is: "75%"
0.6 is what percent of 60?
>
Sorry the correct answer is: "1%"
2.25 is what percent of 15?
>
Sorry the correct answer is: "15%"
If it helps, the only thing that is remotely relevant that I've found so far is: Second of several forked processes does not run in Haskell
.
Lastly, I'm right at the entry level of Monads if that helps formulate your answer.
I would appreciate any help anyone can give as to what's happening, id est, why it's not returning straight to main after pause ends, and why would it skip the fractional number filter.
Thanks ^^

Answer 1

In funPercentOfNumberToAnother, you have this clause:
if uglyAnswers ([ofNum, isNum], [percentDec])
then do
putStrLn ("ofNum: " ++ show ofNum)
putStrLn ("isNum: " ++ show isNum)
putStrLn "___________________________"
funPercentOfNumberToAnother
else do
putStrLn ("ofNum: " ++ show ofNum)
putStrLn ("isNum: " ++ show isNum)
putStrLn "Percents"
Your intent is to go back to the beginning of the function and start over, if the numbers are ugly; or otherwise continue with showing the numbers to the user. That works as far as it goes, but ask yourself...what happens at the end of this if clause? The stuff that is not in either the then or else branch is executed regardless, once either the then or else is done executing.
So, when you get some ugly numbers, you start a recursive call that looks for better numbers and displays them. Then when that recursive call is finished, you go on to show the user the original, ugly numbers anyway!
You will need a different control flow here, such as writing a function that always returns a non-ugly number, and then just using that in your (now non-recursive) funPercentOfNumberToAnother function. Or you could pull the rest of the function's body, the part that shows the numbers to the user, into the else part of the if, so that you don't do it for numbers that are ugly.

Answer 2

As per amalloy's great explanation I understood what was happening and fixed, then tested the issue. Having code outside the if statement of:
if uglyAnswers
then funPercentOfNumberToAnother
else ...
caused the bad answers to later make their way down when the recursion stopped. So essentially I was stocking up on them.
Maybe this can explain it better. See that I got a clean answer on the first try so it didn't have to go through the recursion. For the second go there were two calls because the first call found a fractional answer:
__ __ _ _ _ _
| \/ | __ _| |_| |__ ___ _ __ ___ __ _| |_(_) ___ ___
| |\/| |/ _` | __| '_ \ / _ \ '_ ` _ \ / _` | __| |/ __/ __|
| | | | (_| | |_| | | | __/ | | | | | (_| | |_| | (__\__
|_| |_|\__,_|\__|_| |_|\___|_| |_| |_|\__,_|\__|_|\___|___/
1.) Learn Math
2.) Math Lookup
3.) Quit Excolo
1
In the else statement
===================================
Finally outside the else statement
ofNum: 10
isNum: 4
__ __ _ _ _ _
| \/ | __ _| |_| |__ ___ _ __ ___ __ _| |_(_) ___ ___
| |\/| |/ _` | __| '_ \ / _ \ '_ ` _ \ / _` | __| |/ __/ __|
| | | | (_| | |_| | | | __/ | | | | | (_| | |_| | (__\__
|_| |_|\__,_|\__|_| |_|\___|_| |_| |_|\__,_|\__|_|\___|___/
1.) Learn Math
2.) Math Lookup
3.) Quit Excolo
1
Bad answer alert!
===================================
In the else statement
===================================
Finally outside the else statement
ofNum: 160
isNum: 80
===================================
Finally outside the else statement
ofNum: 55
isNum: 0.55
Here's the workable code snippets from the original question:
funPercentOfNumberToAnother :: IO ()
funPercentOfNumberToAnother = do
(percentDec, percentStr) <- getPercent
ofNum <- getDecimal (200 :: Decimal)
let isNum = percentDec * ofNum
if uglyAnswers ([ofNum, isNum], [percentDec])
then funPercentOfNumberToAnother
else do
let message = show isNum ++ " is what percent of " ++ show ofNum ++ "?\n"
testProblem (percentStr ++ "%", message)
testProblem :: (String, String) -> IO ()
testProblem (correctAns, message) = do
putStrLn message
putStrLn "\n\n"
putStr "> "
myAns <- getLine
if myAns == correctAns
then putStrLn "Congratz!"
else do
putStrLn ("Sorry the correct answer is: " ++ show correctAns)
pause