ooh at 99% cap

card_game/src/lib.rs

@@ -321,6 +321,9 @@ impl<S> SessionStats<S> {
 	}
 }
 
+#[derive(Debug)]
+pub struct Oom;
+
 #[derive(Clone, Debug)]
 pub struct Session<G: Game> {
 	stats: SessionStats<G::Stats>,
@@ -402,11 +405,16 @@ where
 	pub fn is_win(&self) -> bool {
 		self.state.is_win()
 	}
-	pub fn is_winnable(&self) -> Option<Vec<StateSnapshot<G>>> {
+	pub fn is_winnable(&self) -> Result<Option<Vec<StateSnapshot<G>>>, Oom> {
-		let mut state_moves = std::collections::HashMap::new();
+		const HUGE_CAP: usize = 1 << 25;
+		let mut state_moves = std::collections::HashMap::with_capacity(HUGE_CAP);
 		let mut state = self.clone();
-		let mut i: u64 = 0;
 		while !state.is_win() {
+			// don't look for empty hash map buckets when the hash map is 99% full!
+			if HUGE_CAP * 127 <= state_moves.len() * 128 {
+				return Err(Oom);
+			}
+
 			// Continue existing iterator if it exists
 			let it = state_moves
 				.entry(state.state().clone())
@@ -420,7 +428,7 @@ where
 
 			// No more moves. If we can't undo we're done
 			if state.history().is_empty() {
-				return None;
+				return Ok(None);
 			} else {
 				state.undo();
 			}
@@ -452,7 +460,7 @@ where
 			}
 		}
 
-		Some(state.state.history)
+		Ok(Some(state.state.history))
 	}
 }
 impl<G: Game> Game for SessionState<G>

klondike-cli/src/test.rs

@@ -3,7 +3,7 @@ use klondike::Klondike;
 #[test]
 fn test_is_winnable() {
 	// is winnable
-	let is_winnable = Session::new_default(Klondike::with_seed(124)).is_winnable();
+	let is_winnable = Session::new_default(Klondike::with_seed(0)).is_winnable().unwrap();
 	if let Some(win_moves) = is_winnable {
 		// for (i, ins) in win_moves.into_iter().enumerate() {
 		// 	println!("{i} = {:?}", ins.instruction());

klondike/src/lib.rs

@@ -629,19 +629,18 @@ impl Klondike {
 			KlondikeInstruction::RotateStock => 4,
 		}
 	}
-	pub fn iter(&self) -> impl Iterator<Item = KlondikeInstruction> + use<> {
-		let state = self.state.clone();
-		KlondikeIter::new().filter(move |&instruction| state.is_instruction_valid(instruction))
-	}
 	/// A single move that usually makes progress towards a winning game
 	pub fn get_auto_move(&self) -> Option<KlondikeInstruction> {
-		self.iter()
+		self.possible_instructions()
 			.filter(|ins| !ins.is_useless())
 			.min_by_key(|ins| self.instruction_priority(ins))
 	}
 	/// A list of possible moves with useless moves filtered out and sorted by a simple priority function
 	pub fn get_sorted_moves(&self) -> Vec<KlondikeInstruction> {
-		let mut useful_moves: Vec<_> = self.iter().filter(|ins| !ins.is_useless()).collect();
+		let mut useful_moves: Vec<_> = self
+			.possible_instructions()
+			.filter(|ins| !ins.is_useless())
+			.collect();
 		useful_moves.sort_by_key(|ins| self.instruction_priority(ins));
 		useful_moves
 	}
@@ -652,7 +651,8 @@ impl Game for Klondike {
 	type Config = KlondikeConfig;
 	type Instruction = KlondikeInstruction;
 	fn possible_instructions(&self) -> impl Iterator<Item = Self::Instruction> + use<> {
-		self.get_sorted_moves().into_iter()
+		let state = self.state.clone();
+		KlondikeIter::new().filter(move |&instruction| state.is_instruction_valid(instruction))
 	}
 	fn is_instruction_valid(&self, _config: &Self::Config, instruction: Self::Instruction) -> bool {
 		self.state.is_instruction_valid(instruction)