perf: iterate over CardPlay without allocation

Author: Matt Goldberg

strategies/src/input_strategy.rs

@@ -227,12 +227,11 @@ fn play_action_from_captures(caps: &Captures, actions: &[Action]) -> Result<Acti
         .filter(|cp| cp.size() == cards.len())
         // rank matches and all suits are accounted for?
         .filter(|cp| {
-            let cp_cards = cp.to_vec();
             let suits: Vec<Suit> = cards.iter().filter_map(|c| c.1).collect();
             cp.rank() == rank
                 && suits
                     .iter()
-                    .all(|suit| cp_cards.iter().any(|c| c.suit() == *suit))
+                    .all(|suit| cp.cards().any(|c| c.suit() == *suit))
         })
         .next()
         .ok_or_else(|| format!("Unable to find a permitted action matching the input string"))?;

types/src/action.rs

@@ -18,7 +18,8 @@ impl Display for Action {
             Action::SendCard { card, .. } => format!("Send {card}"),
             Action::Pass => "Pass".to_string(),
             Action::PlayCards { card_play } => {
-                format!("Play {}", card_play.to_vec().iter().join(","))
+                let cards = card_play.cards().map(|card| format!("{card}")).join(",");
+                format!("Play {cards}")
             }
         };
         write!(f, "{}", string)

types/src/card_play.rs

@@ -1,4 +1,4 @@
-use std::{cmp::Ordering, fmt::Display};
+use std::{cmp::Ordering, fmt::Display, iter::FusedIterator};
 
 use deckofcards::Rank;
 use itertools::Itertools;
@@ -18,10 +18,7 @@ impl Display for CardPlay {
         write!(
             f,
             "({})",
-            self.to_vec()
-                .iter()
-                .map(|card| format!("{}", card))
-                .join(", ")
+            self.cards().map(|card| format!("{}", card)).join(", ")
         )
     }
 }
@@ -60,15 +57,17 @@ impl CardPlay {
             ),
         }
     }
-    pub fn to_vec(self: &CardPlay) -> Vec<Card> {
-        match self {
-            CardPlay::Single(card) => vec![*card],
-            CardPlay::Pair(card1, card2) => vec![*card1, *card2],
-            CardPlay::Triple(card1, card2, card3) => vec![*card1, *card2, *card3],
-            CardPlay::Quad(card1, card2, card3, card4) => vec![*card1, *card2, *card3, *card4],
+    pub fn cards(&self) -> CardPlayCards<'_> {
+        CardPlayCards {
+            card_play: self,
+            idx: 0,
         }
     }
 
+    pub fn to_vec(&self) -> Vec<Card> {
+        self.cards().collect()
+    }
+
     pub fn size(&self) -> usize {
         match self {
             CardPlay::Single(_) => 1,
@@ -96,3 +95,48 @@ impl CardPlay {
         }
     }
 }
+
+pub struct CardPlayCards<'a> {
+    card_play: &'a CardPlay,
+    idx: usize,
+}
+
+impl<'a> Iterator for CardPlayCards<'a> {
+    type Item = Card;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let card = match (self.card_play, self.idx) {
+            (CardPlay::Single(card), 0) => Some(*card),
+            (CardPlay::Pair(card1, card2), idx) => match idx {
+                0 => Some(*card1),
+                1 => Some(*card2),
+                _ => None,
+            },
+            (CardPlay::Triple(card1, card2, card3), idx) => match idx {
+                0 => Some(*card1),
+                1 => Some(*card2),
+                2 => Some(*card3),
+                _ => None,
+            },
+            (CardPlay::Quad(card1, card2, card3, card4), idx) => match idx {
+                0 => Some(*card1),
+                1 => Some(*card2),
+                2 => Some(*card3),
+                3 => Some(*card4),
+                _ => None,
+            },
+            _ => None,
+        }?;
+        self.idx += 1;
+        Some(card)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let remaining = self.card_play.size().saturating_sub(self.idx);
+        (remaining, Some(remaining))
+    }
+}
+
+impl<'a> ExactSizeIterator for CardPlayCards<'a> {}
+
+impl<'a> FusedIterator for CardPlayCards<'a> {}

types/src/game_state.rs

@@ -118,7 +118,7 @@ impl GameState {
             let (_, starting_card) = self.starting_player_and_card();
             actions.retain(|action| match action {
                 Action::PlayCards { card_play } => {
-                    card_play.to_vec().iter().any(|&card| card == starting_card)
+                    card_play.cards().any(|card| card == starting_card)
                 }
                 _ => false,
             });
@@ -140,8 +140,8 @@ impl GameState {
             }
             Action::Pass => {}
             Action::PlayCards { card_play } => {
-                for card in &card_play.to_vec() {
-                    let removed = player.state.current_hand.remove_card(card);
+                for card in card_play.cards() {
+                    let removed = player.state.current_hand.remove_card(&card);
                     assert!(
                         removed,
                         "Attempted to play a card {:?} that wasn't in the hand!",