Haskell Variable Updation

Question

• I'm building a game (kind of poker) in haskell but i'm new to haskell and generally get stuck when try to think how to implement a thing in purely functional language.*

Game is of 3 players(Just to make it easy to explain). Two players will play from the table cards and one will play from the stack. Both kinds of players will take one card and use it if useful(replace one of your card in hand) or just dump it(if not). Winning is just full-house or a straight.

The Two of them have some understanding, something they agree before to help each other. Like if i took K (lets say) from table and next hand i took a 4 from the table means i'm going for a full house and hence you should help if you can in any possible way. Each of these player should help each other so that one of them should win before the player playing with the stack but not at the cost of oneself.

Table has total 5 cards and so does each player

Implement Understanding between two players :

I'm stuck how to track what other player have took from the table. I'm trying to do that by adding the cards to my hand itself (Virtually remembering the thing) and while dong calculations of my hand (real) i'm going to take only first five of cards and while doing calculation for helping him i'm going to drop five cards and then do calculations with that. Is there any better strategy to do the same?? It might be trivial but i'm amateur in world of haskell. If you want code I can just put it up.

basic set up of my Game :

data Card = Card {
    c :: (Int, Char) 
   } deriving (Eq, Ord, Show)

data Deck = Deck {
   d :: [Card]
} deriving (Show, Eq, Ord)  

data Game = Game {
  bact1Hand :: [Card],
  bact2Hand :: [Card],
  orgHand  :: [Card],
  tableCards :: [Card],
  deck :: Deck
} deriving (Show, Eq, Ord)  

type GameState a = State Game a`

Answer 1

If you want to keep it simple and are not ready for advanced Haskell things, you can use recursive transforms, as it was suggested in comments to you question.

The main idea is that you create a data type data Game that fully describes the state of the game; and then you write a function "player A makes action 1" that transforms the game (e.g. act:: Player -> Action -> Game -> Game). Such function transforms the full game state: it preserves the state from input to the output, but changes some parts of it, related to the player and the action (e.g. adding a card to hand). The last step is to bind the function to the IO actions: in the simplest setting you create a main cycle in which the Game changes, waiting for IO input on each iteration (e.g. just like OpenGL main cycle). Or you can use Control.Concurrent.MVar to pass IO actions asynchronously.

So, in short code:

-- | State of the AI
data Mind = Mind
    { overallLogic :: ???
    , perPlayerLogic :: [(PlayerID, Understanding)]
    }

-- | Undersanding of one player by another player
data Understanding = ???

newtype PlayerID = PlayerID Int

-- | Full state of the player
data Player = Player
    { id :: PlayerID
    , hand :: [Card]
    , mind :: Mind
    , ...
    }

-- | indication of the game state
data Status = PlayersTurn PlayerID | PlayerWon PlayerID

-- | Full state of the game
data Game = Game
    { status :: Status
    , players :: [Player] -- or consider (Int)Map of player-id
    , ...
    }

-- | Events in game are passed from IO: they indicate players' actions
data Event = PlayersTurn PlayerID Action ...
           | WhateverElseEvent

-- | the function to transform Game's state
react :: Event -> Game -> Game
react ev game = game'
    where game' = ... -- here is game logic 

And somewhere you put the main cycle in a separate thread:

mainLoop :: MVar Event -> Game -> IO ()
mainLoop mevent game = do
    event <- takeMVar mevent
    let game' = react event game
    if checkIfFinished game'
        then return ()
        else mainLoop mevent game'

Note the tail recursive call - the cycle goes until checkIfFinished returns True. checkIfFinished is your logic to decide whether to finish game or not, based on the Game state. takeMVar waits for another thread to put something. In other threads you add IO actions that get user input, make out of them the Event data, and put it using putMVar.

Update: thanks to comments, I put a bit off-topic part of the answer to the bottom as a "further reading".

If you want to remember states globally, GHC offers two types for you: Data.STRef and Control.Concurrent.MVar. However, this is not "purely functional" approach. You could read about statefull computations and the reader monad here http://learnyouahaskell.com/. Commentators suggest that the state monad is better than the reader monad for current purposes - thanks, I admit this. Anyway, learnyouahaskell is a great source for these kinds of information :) .

The most purely functional and useful in applications approach would be to use Functional Reactive Programming. There is a notion of behavior to represent a time-varying value. Some people would say FRP is an overkill here, and, probably, they would be right. But when you decide to add a GUI and other IO, using nice interfaces provided by e.g. reactive-banana will simplify your life significantly.