Hi haskell helpers, Learning haskell, I wanted to explore how to write pure code and then add some IO on top of it, keeping the main code pure. The idea was to write a very simple two-player game, then define some strategies to play it that do not involve IO, and finally use strategies involving Random or IO ("ask the user"). I failed to reuse the pure code, and the only solution I found was to rewrite most things for IO. Here is my attempt in literate haskell, it is quite short, I hope someone will be kind enough to tell me what I have missed... Thanks for any answer! The game is: each player in turn chooses a number, and wins if this number has already been chosen twice (the third occurrence wins).

import Debug.Trace import Control.Monad

Choosing a number is a "move", a game is all moves played so far.

type Move = Int type Game = [Move]

newGame :: Game newGame = []

Game updating rule, Nothing for a winning move (the game stops) else Just the ongoing game.

update :: Game -> Move -> Maybe Game update game move = if move `wins` game then Nothing else Just (move:game) where move `wins` game = length (filter (== move) game) == 2

Let's give a name to both players, mainly for tracing purposes.

data Player = Player1 | Player2 deriving Show

myTrace :: Player -> Move -> (a -> a) myTrace player move = trace ((show player) ++ " plays " ++ (show move))

A strategy looks at the game and proposes the next move, and may involve state.

class Strategy a where proposeNext :: Game -> a -> (Move, a)

The "game engine" takes two strategies and returns the winner, tracing what is going on. runGame starts from a new (empty) game, runGame' updates an ongoing game and keeps track of who is Player1 or Player2.

runGame :: (Strategy a1, Strategy a2) => a1 -> a2 -> Player runGame x y = runGame' (Player1, x) (Player2, y) newGame

runGame' :: (Strategy a1, Strategy a2) => (Player, a1) -> (Player, a2) -> Game -> Player runGame' (px, x) (py, y) game = -- x and y are strategies let (move, x') = proposeNext game x follows = case update game move of Nothing -> px -- winning move Just nextgame -> runGame' (py, y) (px, x') nextgame in myTrace px move $ follows

An example of a pure strategy that plays a fixed list of numbers, then zeroes.

data Fixed = Fixed [Move] deriving Show

instance Strategy Fixed where proposeNext game s = case s of Fixed [] -> (0, Fixed []) Fixed (x:xs) -> (x, Fixed xs)

Now you may run runGame (Fixed [1,2,3]) (Fixed [3,2,1,3]) and Player2 will win. Now I want the user to be asked for moves. This one works quite well, asking *once* the user for a list of moves.

askFixed :: String -> IO Fixed askFixed name = liftM Fixed askio where askio = putStr (name ++ ", pick a list of numbers: ") >> readLn

I could easily reuse runGame:

runGameSingleIO :: (Strategy a1, Strategy a2) => IO a1 -> IO a2 -> IO Player runGameSingleIO = liftM2 runGame

And this works: runGameSingleIO (askFixed "Joe") (askFixed "Jack") Now I want each user to be asked for moves repeatedly until there is a win. This was my first try, using an infinite list and hoping lazyness would work.

askUntil :: String -> IO Fixed askUntil name = liftM Fixed (sequence $ repeat askio) where askio = putStr (name ++ ", pick a number: ") >> readLn

However it does not work, if I evaluate: liftM2 runGame (askUntil "Joe") (askUntil "Jack") then Joe is indefinitely asked for his move... Now, I supposed that IO [Move] was maybe (when triggered) a "unitary action" returning the whole list with no lazyness, and that I would rather need to have IO attached to individual moves [IO Move], so that they could be triggered independently. Am I right, or is it still subtler? Anyway, I imagined I needed to start from

data FixedIO = FixedIO [IO Move]

And that's where I failed. I could not define any instance of Strategy that could be turned to a (IO Strategy) and reuse runGame, and use [IO Move] somewhere. I could not bring the inner IOs of [IO Move] to be syhthetised in front of IO Strategy. Was it possible? All I was able to contrive is a new definition of Strategy and runGame for the IO case. This seems very awkward. Here it is:

class StrategyIO a where proposeNextIO :: Game -> a -> IO (Move, a)

runGameIO :: (StrategyIO a1, StrategyIO a2) => a1 -> a2 -> IO Player runGameIO x y = runGameIO' (Player1, x) (Player2, y) newGame

runGameIO' :: (StrategyIO a1, StrategyIO a2) => (Player, a1) -> (Player, a2) -> Game -> IO Player runGameIO' (px, x) (py, y) game = do (move, x') <- proposeNextIO game x case update game move of Nothing -> return px Just nextgame -> runGameIO' (py, y) (px, x') nextgame

Then FixedIO could be made a strategy:

instance StrategyIO FixedIO where proposeNextIO game s = case s of FixedIO [] -> return (0, FixedIO []) FixedIO (x:xs) -> liftM2 (,) x (return $ FixedIO xs)

askFixedIO :: String -> FixedIO askFixedIO name = FixedIO (repeat askio) where askio = putStr (name ++ ", pick a number: ") >> readLn

and this works: runGameIO (askFixedIO "Joe") (askFixedIO "Jack") However, I wonder how to do it reusing the "pure" versions, runGame and Strategy? Thanks for anyone that has followed so far! Eric