Trying to understand Rust's borrowing, lifetimes and ownership

src/deck.rs

 use rand::{thread_rng, Rng};
 use std::collections::BTreeSet;
 
-pub type Deck = [card::Card; params::DECK_SIZE];
-pub type Hand = (i32, BTreeSet<card::Card>);
+pub type Deck = Vec<card::Card>;
+pub type Hand = BTreeSet<card::Card>;
 
-// Creates a deck_size cards tarot deck, shuffled
+// Creates a tarot deck, shuffled
 pub fn new_deck() -> Deck {
-    let mut deck: [card::Card; params::DECK_SIZE] = [card::Card::Fool; params::DECK_SIZE];
-    let mut counter = 0;
+    let mut deck: Vec<card::Card> = Vec::new();
     for suit in card::Suit::values() {
         for symbol in card::Symbol::values() {
-            deck[counter] = card::Card::Face(card::Face {
+            deck.push(card::Card::Face(card::Face {
                 suit: suit,
                 symbol: symbol,
-            });
-            counter += 1
+            }));
         }
     }
     for trump in card::Trump::values() {
-        deck[counter] = card::Card::Trump(trump);
-        counter += 1
+        deck.push(card::Card::Trump(trump));
     }
-    deck[counter] = card::Card::Fool;
+    deck.push(card::Card::Fool);
     let mut rng = thread_rng();
     rng.shuffle(&mut deck);
     deck
 }
 
 // Distributes the deck between the four players and the dog
-pub fn distribute_cards(deck: Deck) -> (Hand, [Hand; params::NUMBER_OF_PLAYERS]) {
-    let (_, mut dog): Hand = (-1, BTreeSet::new());
-    let mut hands: [Hand; params::NUMBER_OF_PLAYERS] =
-        [(0, BTreeSet::new()), (1, BTreeSet::new()), (2, BTreeSet::new()), (3, BTreeSet::new())];
-    for i in 0..params::DECK_SIZE {
+pub fn distribute_cards(deck: &Deck) -> (Hand, Vec<Hand>) {
+    let mut dog: Hand = BTreeSet::new();
+    let mut hands: Vec<Hand> = Vec::new();
+    for i in 0..deck.len() {
         if i < params::DOG_SIZE {
             dog.insert(deck[i]);
         } else {
-            hands[(i / params::CARDS_PER_DISTRIBUTION) % params::NUMBER_OF_PLAYERS]
-                .1
-                .insert(deck[i]);
+            hands[(i / params::CARDS_PER_DISTRIBUTION) % params::NUMBER_OF_PLAYERS].insert(deck[i]);
         }
     }
-    ((-1, dog), hands)
+    (dog, hands)
 }

src/game.rs

 use std::collections::BTreeSet;
 
 type Heap = Vec<card::Card>;
+pub struct Player {
+    pub id: i32,
+    pub name: String,
+    pub hand: deck::Hand,
+}
+
+pub fn initialize_players(hands: &mut Vec<deck::Hand>, names: &mut Vec<String>) -> Vec<Player> {
+    if hands.len() != names.len() {}
+    let mut counter = 0;
+    let mut players = Vec::new();
+    for i in 0..hands.len() {
+        let name = match names.pop() {
+            Some(name) => name,
+            None => panic!("the number of hands is different from the number of players"),
+        };
+        let hand = match hands.pop() {
+            Some(hand) => hand,
+            None => panic!("the number of hands is different from the number of players"),
+        };
+        players.push(Player {
+            id: counter,
+            name: name,
+            hand: hand,
+        });
+        counter += 1;
+    }
+    players
+}
 
-pub fn start_game(dog: deck::Hand, hands: [deck::Hand; params::NUMBER_OF_PLAYERS]) {
-    let cards_per_player = hands[0].1.len();
+pub fn start_game(dog: &deck::Hand, players: &mut Vec<Player>) {
+    let cards_per_player = players[0].hand.len();
     //Check if all players have same number of cards
     for i in 1..params::NUMBER_OF_PLAYERS {
-        if cards_per_player != hands[i].1.len() {
+        if cards_per_player != players[i].hand.len() {
             panic!("the players don't have the same number of cards")
         }
     }
-    //If yes start the game
-    let starting_player = 0;
-    (1..cards_per_player).fold((starting_player, hands), |(starting_player, hands), _| {
-        //For each turn
-        let mut new_hands: [deck::Hand; params::NUMBER_OF_PLAYERS] = [(0, BTreeSet::new()),
-                                                                      (1, BTreeSet::new()),
-                                                                      (2, BTreeSet::new()),
-                                                                      (3, BTreeSet::new())];
-        let end_heap = hands.into_iter().enumerate().fold(Vec::new(), |heap, (i, hand)| {
-            // For each player
-            let (new_hand, new_heap) = play_card(hand.clone(), heap);
-            new_hands[i - starting_player % params::NUMBER_OF_PLAYERS] = new_hand;
-            new_heap
-        });
-        let new_starting_player = winning_card(end_heap.clone());
-        println!("Les joueurs ont joué : {:?}", end_heap);
-        (new_starting_player, new_hands)
-    });
+    for i in 0..cards_per_player {
+        for player in players.iter_mut() {}
+    }
+    unimplemented!();
 }
 
-fn play_card((player, hand): deck::Hand, cards_played: Heap) -> (deck::Hand, Heap) {
-    let valid_cards = valid_cards((player, hand.clone()), cards_played.clone());
-    let card_to_play = select_card(valid_cards, cards_played.clone());
-    println!("Card to play: {:?}", card_to_play.clone());
-    let mut new_hand = hand.clone();
-    new_hand.take(&card_to_play);
-    let mut new_cards_played = cards_played.clone();
-    new_cards_played.push(card_to_play);
-    ((player, new_hand), new_cards_played)
+fn play_card(player: &mut Player, cards_played: &mut Heap) {
+    unimplemented!();
 }
 
-fn valid_cards(hand: deck::Hand, cards_played: Heap) -> deck::Hand {
-    hand
+fn valid_cards(hand: &deck::Hand, cards_played: &Heap) -> deck::Hand {
+    unimplemented!();
 }
 
-fn select_card((player, valid_cards): deck::Hand, cards_played: Heap) -> card::Card {
-    match valid_cards.into_iter().next() {
-        Some(card) => card,
-        None => panic!("there is no valid card to play"),
-    }
+fn select_card(player: &Player, cards_played: &Heap) -> card::Card {
+    unimplemented!();
 }
 
-fn winning_card(cards: Heap) -> usize {
-    0
+fn winning_card(cards: &Heap) -> usize {
+    unimplemented!();
 }

src/main.rs

 
 fn main() {
     let deck = deck::new_deck();
-    let ((_, dog), hands) = deck::distribute_cards(deck);
+    let (dog, mut hands) = deck::distribute_cards(&deck);
     println!("-> Cartes du chien :");
     for card in dog.iter() {
         println!("{}", card);
     }
-    for &(number, ref hand) in hands.into_iter() {
-        println!("-> Cartes du joueur {}:", number + 1);
+    for hand in hands.iter() {
+        println!("-> Cartes du joueur {}:", 0);
         for card in hand.iter() {
             println!("{}", card);
         }
     }
-    game::start_game((-1, dog), hands);
+    let mut names: Vec<String> =
+        vec!["A".to_string(), "B".to_string(), "C".to_string(), "D".to_string()];
+    let mut players = game::initialize_players(&mut hands, &mut names);
+    game::start_game(&dog, &mut players);
 }

src/params.rs

-pub const DECK_SIZE: usize = 78;
 pub const DOG_SIZE: usize = 6;
 pub const NUMBER_OF_PLAYERS: usize = 4;
 pub const CARDS_PER_DISTRIBUTION: usize = 3;