Can distribute game

src/card.rs

 use std::fmt;
+use std::cmp::Ordering;
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord)]
 pub enum Suit {
     Clubs,
     Diamonds,
     }
 }
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord)]
 pub enum Symbol {
     Ace,
     Two,
     }
 }
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Eq, PartialEq, PartialOrd)]
 pub struct Face {
     pub suit: Suit,
     pub symbol: Symbol,
 }
 
-#[derive(Copy, Clone)]
+impl Ord for Face {
+    fn cmp(&self, face: &Face) -> Ordering {
+        self.symbol.cmp(&face.symbol)
+    }
+}
+
+#[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord)]
 pub enum Trump {
     One,
     Two,
     }
 }
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Eq, PartialEq, PartialOrd)]
 pub enum Card {
     Face(Face),
     Trump(Trump),
         }
     }
 }
+
+impl Ord for Card {
+    fn cmp(&self, card: &Card) -> Ordering {
+        match (self, card) {
+            (&Card::Fool, _) => Ordering::Less,
+            (_, &Card::Fool) => Ordering::Greater,
+            (&Card::Trump(_), &Card::Face(_)) => Ordering::Greater,
+            (&Card::Face(_), &Card::Trump(_)) => Ordering::Less,
+            (&Card::Trump(trump1), &Card::Trump(trump2)) => trump1.cmp(&trump2),
+            (&Card::Face(face1), &Card::Face(face2)) => face1.cmp(&face2),
+        }
+    }
+}

src/deck.rs

 use card;
 use rand::{thread_rng, Rng};
+use std::collections::BTreeSet;
 
-pub fn new_deck() -> Vec<card::Card> {
-    let mut deck: Vec<card::Card> = Vec::new();
+pub const DECK_SIZE: usize = 78;
+pub const NUMBER_OF_PLAYERS: usize = 4;
+pub const CARDS_PER_DISTRIBUTION: usize = 3;
+pub type Deck = [card::Card; DECK_SIZE];
+pub type Hand = BTreeSet<card::Card>;
+
+
+// Creates a deck_size cards tarot deck, shuffled
+pub fn new_deck() -> Deck {
+    let mut deck: [card::Card; DECK_SIZE] = [card::Card::Fool; DECK_SIZE];
+    let mut counter = 0;
     for suit in card::Suit::values() {
         for symbol in card::Symbol::values() {
-            deck.push(card::Card::Face(card::Face {
+            deck[counter] = card::Card::Face(card::Face {
                 suit: suit,
                 symbol: symbol,
-            }))
+            });
+            counter += 1
         }
     }
     for trump in card::Trump::values() {
-        deck.push(card::Card::Trump(trump))
+        deck[counter] = card::Card::Trump(trump);
+        counter += 1
     }
-    deck.push(card::Card::Fool);
+    deck[counter] = 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; 4]) {
+    let mut dog: Hand = BTreeSet::new();
+    let mut hands: [Hand; NUMBER_OF_PLAYERS] =
+        [BTreeSet::new(), BTreeSet::new(), BTreeSet::new(), BTreeSet::new()];
+    for i in 0..(DECK_SIZE - 1) {
+        if i <= 5 {
+            dog.insert(deck[i]);
+        } else {
+            hands[(i / CARDS_PER_DISTRIBUTION) % NUMBER_OF_PLAYERS].insert(deck[i]);
+        }
+    }
+    (dog, hands)
+}

src/main.rs

 extern crate rand;
 
 fn main() {
-    let mut deck = deck::new_deck();
-    for card in deck {
-        println!("{}", card)
+    let deck = deck::new_deck();
+    let (dog, hands) = deck::distribute_cards(deck);
+    println!("-> Cartes du chien :");
+    for card in dog.iter() {
+        println!("{}", card);
+    }
+    for i in 0..(deck::NUMBER_OF_PLAYERS) {
+        println!("-> Cartes du joueur {} :", i + 1);
+        for card in hands[i].iter() {
+            println!("{}", card);
+        }
     }
 }