Repeating an action without control structures - haskell

Question

I'm dipping my toe into the Haskell pool, and I'm starting to get the hang of it. For the most part, the lack of traditional control structures doesn't bother me too much. (I'm coming from a C/C++ background.) But I'm a little confused about how you'd repeat an action. For example, if you have a turn-based game, in an imperative language, you might do something like this:
while (not somePlayerWon())
{
getNextMove();
updateGameState();
}
It's not clear to me how you'd do this in Haskell. You could do something recursive like:
playARound gameState = do
nextMove <- getNextMove gameState
newGameState <- updateGameState gameState nextMove
if (not somePlayerWon newGameState)
playARound newGameState
else gameOver -- I realize this probably has to return something
But if you do that, don't you run the risk of a stack overflow? Or will the compiler take the tail-recursive definition and convert it into the equivalent of a for loop? If so, is this the accepted way of doing this sort of thing?

Answer 1

In Haskell we try not to do use explicit recursion. Recursion is a really big hammer, and for most problems, higher order functions provide a slightly more controlled solution. You're code is perfectly fine, it's tail recursive, but it's often easier to read the combinator based approach
For loops in monads the monad-loops package is nice. You're example would be written as
whileM_ (getState >>= somePlayerWon) $ do
state <- getState
move <- getNextMove
putState $ getNewState state move
Where getState and putState behave like get and put from the State monad.
Or if you're avoiding a monad and just passing state manually
until somePlayerWon
(\gameState -> nextGameState gameState (getNextMove gameState))
gameState
or
flip (until somePlayerWon) gameState $ \gameState ->
nextGameState gameState $ getNextMove gameState
See Avoid Explicit Recursion for more on why explicit recursion should be treated with cation.

Answer 2

You are correct, if the function is tail-recursive, it will be transformed into a loop by the compiler. And this way of writing the main loop is indeed how people usually do it.
As a further reading, you may find interesting a couple of short posts on games in functional languages by James Hague (he uses Erlang for illustrations, but the ideas are general), and the description of the Component-Entity-State approach to game programming by Chris Granger (illustrated in Clojure).