如何在F＃中为绘图卡建模

Question

I'm working on modeling how to draw a playing card from the deck and I came up with the following solution:

type Card = { Value:int }
type Deck = Card list
type Player = { Hand : Card list }

type CardDrawer(deck) =
     let mutable deck = deck
     member this.drawCard () =
          match deck with
          | h::t ->
               deck <- t
               h
     member this.getDeck () = deck

//Example Usage
let createPlayers deck numPlayers =
     let cardDrawer = new CardDrawer(deck)
     let drawCard = cardDrawer.drawCard
     let createPlayer drawCard =
         let hand = [drawCard(); drawCard()]
         {Hand=hand}

     ([1 .. numPlayers] |> List.map(fun _ -> createPlayer drawCard)),cardDrawer.getDeck()

The main problem with this solution is that I'm using a mutable field for the CardDrawer to get the modified deck back. I feel like using a computational expression would work here, but I'm not sure on how to implement it.

Any thoughts/suggestions?

EDIT: Here's an alternative setup, but how would I have createPlayer know how to take the mutated output and turn it back into input?

// Create a function that draws a card
let drawCard deck ()= 
     match deck with
     | h::t -> (h,t)

// Function given a deck and number of players, will return all the players and the deck
let createPlayers deck numPlayers =

     // Function given a deck, will return the player and the new deck
    let createPlayer deck =
        let card, deck = drawCard deck ()
        let card', deck = drawCard deck ()
        { Hand = [card; card'] }, deck

     // But what would this look like now? 
     // How can I get the deck coming back from createPlayer 
     // used for the input to the next time createPlayer is called?
     ([1 .. numPlayers] |> List.map(fun _ -> createPlayer deck)

Answer 1

You can do it as a fold :

// Function given a deck and number of players, will return all the players and the deck
let createPlayers deck numPlayers =

    // Function given a deck, will return the player and the new deck
    let createPlayer deck =
        let card, deck = drawCard deck ()
        let card', deck = drawCard deck ()
        { Hand = [card; card'] }, deck

    let dealToNewPlayer (players, deck) _ =
        let player, deck = createPlayer deck
        player :: players, deck

    [1..numPlayers] |> List.fold dealToNewPlayer ([], deck)

List.fold has the type ('State -> 'T -> 'State) -> 'State -> 'T list -> 'State . In this case, because we kick off the fold with [1..numPlayers] , which has the type int list , the generic type argument 'T is int . Therefore, you need to define a folder function with the type 'State -> 'int -> 'State .

Each time this function is called, you want to accumulate the state, which means that you want to use the previous value of deck to calculate the new value of deck . You also want to take the generated Player and add to a list of already generated Player values. This means that the state you need to keep track of must contain both a list of Player values, and the deck. The simplest way to keep track of both is via a tuple - for example Player list * Card list . This means that your folder function must have the type Player list * Card list -> int -> Player list * Card list .

The above dealToNewPlayer function has the type Player list * Card list -> 'a -> Player list * Card list , because it ignores the second argument. Because it's generic, it also fits the type Player list * Card list -> int -> Player list * Card list .

The other argument to List.fold you need is the initial state: ([], deck) . This value is a tuple where the first element is an empty list of Player values, and the second element is the full deck. It fits the state type of Player list * Card list .

The return value of this particular List.fold is the accumulated state, that is Player list * Card list . Thus, the entire type of createPlayers is Card list -> int -> Player list * Card list .

Here's an example of an FSI session that uses this function:

> let deck = List.init 10 (fun i -> { Value = i });;

val deck : Card list =
  [{Value = 0;}; {Value = 1;}; {Value = 2;}; {Value = 3;}; {Value = 4;};
   {Value = 5;}; {Value = 6;}; {Value = 7;}; {Value = 8;}; {Value = 9;}]

> createPlayers deck 3;;
val it : Player list * Card list =
  ([{Hand = [{Value = 4;}; {Value = 5;}];};
    {Hand = [{Value = 2;}; {Value = 3;}];};
    {Hand = [{Value = 0;}; {Value = 1;}];}],
   [{Value = 6;}; {Value = 7;}; {Value = 8;}; {Value = 9;}])

As you can see, it deals from the input deck to 3 players, so the first element returned is a list of Player values, with the cards dealt to each player. The second element of the tuple contains the remaining deck.