Упражнение про IO (игра в кости)

bind2 f x y = do
  xv <- x
  vy <- y
  f x y

bind2 f x y = join $ liftM2 f x y

import Random
import Control.Monad
 
randomInt :: (Random a, Integral a) => a -> IO a
randomInt n = randomIO >>= return . flip mod n
 
data Hod = Fst | Snd 
  deriving(Enum, Eq)
 
ifthenelse::Bool -> a -> a -> a
ifthenelse True a b = a
ifthenelse False a b = b
 
iter::IO Int -> IO Int -> IO Int -> Hod -> IO () {-iter принимает количество очков, необходимое для победы, счёт первого игрока, счёт второго игрока и текущего игрока-}
iter a b c d = getChar >> liftM3 ifthenelse
                                 (liftM2 (>=) b a)
                                 putStrLn "первый игрок выиграл"
                                 (liftM3 ifthenelse
                                         (liftM2 (>=) c a) 
                                         putStrLn "второй игрок выиграл"
                                         (iter a
                                              (if d == Fst 
                                               then (liftM2 (+)) b (randomInt 6)
                                               else b)
                                              (if d == Fst 
                                               then c 
                                               else (liftM2 (+)) c (randomInt 6))
                                              (succ d)))

import System.Random
 
data Player = Player { score :: Int, name :: String }
mkPlayer :: String -> Player
mkPlayer name = Player { score = 0, name = name }
 
game :: [Int] -> Int -> Player -> Player -> Player
game rands threshold p1 p2
     | score p1 >= threshold = p1
     | score p2 >= threshold = p2
     | otherwise            = game (tail rands) threshold p2 p1 { score = score p1 + head rands }
 
diceRoll :: Int -> Int
diceRoll x = 1 + x `mod` 6
 
main :: IO ()
main = do
  stdGen <- newStdGen
  let winner = game (map diceRoll (randoms stdGen)) 99 (mkPlayer "John") (mkPlayer "Peter")
  putStrLn $ name winner ++ " won with score " ++ show (score winner)

import System.Random
 
import Control.Monad.Identity
import Control.Monad.Writer
import Control.Monad.State
import Control.Monad.Reader
 
import Text.Printf
 
data Player = Player { score :: Int, name :: String }
 
mkPlayer :: String -> Player
mkPlayer name = Player { score = 0, name = name }
 
data GameState = GameState { currTurn :: Player, prevTurn :: Player, rolls :: [Int], turn :: Int }
 
mkGameState :: String -> String -> [Int] -> GameState
mkGameState p1 p2 rs = GameState { currTurn  = mkPlayer p1
                                 , prevTurn  = mkPlayer p2
                                 , rolls     = rs
                                 , turn      = 1
                                 }
 
type Game = ReaderT Int (StateT GameState (WriterT [String] Identity)) ()
 
execGame :: GameState -> Int -> [String]
execGame state threshold = runIdentity (execWriterT (execStateT (runReaderT game threshold) state))
 
nextTurn :: GameState -> GameState
nextTurn state = state { currTurn = prevTurn state
                       , prevTurn = currTurn' { score = newScore }
                       , rolls    = tail (rolls state)
                       , turn     = turn state + 1
                       }
    where currTurn' = currTurn state
          newScore  = score currTurn' + head (rolls state)
 
game :: Game
game = do
  threshold <- ask
  turn <- gets turn
  curr <- gets currTurn
  prev <- gets prevTurn
  tell [printf "Turn %d. %s - %d, %s - %d." turn (name curr) (score curr) (name prev) (score prev)]
  if score prev > threshold
  then tell [printf "%s wins with score %d." (name prev) (score prev)]
  else do
    modify nextTurn
    game
 
diceRoll :: Int -> Int
diceRoll x = 1 + x `mod` 6
 
main :: IO ()
main = do
  stdGen <- newStdGen
  mapM_ putStrLn $ execGame (mkGameState "John" "Peter" (map diceRoll (randoms stdGen))) 99