perf: iterate over CardPlay without allocation

strategies/src/input_strategy.rs

@@ -214,23 +214,21 @@ fn play_action_from_captures(caps: &Captures, actions: &[Action]) -> Result<Acti
     let &card_play = actions
         .iter()
         .find_map(|act| {
-            if let Action::PlayCards { card_play } = act {
-                // correct # of cards?
-                if card_play.size() != cards.len() {
-                    return None;
-                }
-                // rank matches and all suits are accounted for?
-                let cp_cards = card_play.to_vec();
-                let suits: Vec<Suit> = cards.iter().filter_map(|c| c.1).collect();
-                if card_play.rank() == rank
-                    && suits
-                        .iter()
-                        .all(|suit| cp_cards.iter().any(|c| c.suit() == *suit))
-                {
-                    Some(card_play)
-                } else {
-                    None
-                }
+            let Action::PlayCards { card_play } = act else {
+                return None;
+            };
+            // correct # of cards?
+            if card_play.size() != cards.len() {
+                return None;
+            }
+            // rank matches and all suits are accounted for?
+            let suits: Vec<Suit> = cards.iter().filter_map(|c| c.1).collect();
+            if card_play.rank() == rank
+                && suits
+                    .iter()
+                    .all(|suit| card_play.cards().any(|c| c.suit() == *suit))
+            {
+                Some(card_play)
             } else {
                 None
             }

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(", ")
         )
     }
 }
@@ -66,15 +63,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,
@@ -102,3 +101,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

@@ -117,7 +117,9 @@ impl GameState {
         if is_first_cardplay {
             let (_, starting_card) = self.starting_player_and_card();
             actions.retain(|action| match action {
-                Action::PlayCards { card_play } => card_play.to_vec().contains(&starting_card),
+                Action::PlayCards { card_play } => {
+                    card_play.cards().any(|card| card == starting_card)
+                }
                 _ => false,
             });
         }
@@ -138,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!",