better iter order

This reverts commit 5a52f2ab7a.

Cargo.lock

@@ -11,8 +11,8 @@ checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 [[package]]
 name = "arrayvec"
 version = "0.7.6"
-source = "sparse+https://git.aleshym.co/api/packages/Quaternions/cargo/"
+source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "813440870d646c57c222c1d713dc4e3ddcb2919c3801564d767d85d7bf2afee4"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "bitflags"

card_game/Cargo.toml

@@ -9,7 +9,7 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 keywords = ["card", "cards", "solitaire", "klondike"]
 
 [dependencies]
-arrayvec = { version = "0.7.6", registry = "Quaternions", features = ["len_u8"], default-features = false }
+arrayvec = "0.7.6"
 
 [lints]
 workspace = true

card_game/src/lib.rs

@@ -6,14 +6,11 @@ struct ReadmeDoctests;
 use core::ops::RangeBounds;
 
 // TODO: pub struct ValidInstruction<I>(I);
-pub trait Game {
+pub trait Game: Clone + core::fmt::Debug {
-	type Stats;
+	type Stats: Clone + core::fmt::Debug;
-	type Config;
+	type Config: Clone + core::fmt::Debug;
-	type Instruction;
+	type Instruction: Clone + core::fmt::Debug;
-	fn possible_instructions(
+	fn possible_instructions(&self) -> impl Iterator<Item = Self::Instruction> + use<Self>;
-		&self,
-		config: &Self::Config,
-	) -> impl Iterator<Item = Self::Instruction> + use<Self>;
 	fn is_instruction_valid(&self, config: &Self::Config, instruction: Self::Instruction) -> bool;
 	fn process_instruction(
 		&mut self,
@@ -324,21 +321,33 @@ impl<S> SessionStats<S> {
 	}
 }
 
+#[derive(Clone, Debug)]
 pub struct Session<G: Game> {
 	stats: SessionStats<G::Stats>,
 	config: G::Config,
 	state: SessionState<G>,
 }
-#[derive(Clone, Eq, Hash, PartialEq)]
+#[derive(Clone, Debug)]
-pub struct SessionState<G: Game> {
+pub struct StateSnapshot<G: Game> {
-	seed: G,
 	state: G,
-	history: Vec<G::Instruction>,
+	instruction: G::Instruction,
+}
+impl<G: Game> StateSnapshot<G> {
+	pub const fn state(&self) -> &G {
+		&self.state
+	}
+	pub const fn instruction(&self) -> &G::Instruction {
+		&self.instruction
+	}
+}
+#[derive(Clone, Debug)]
+pub struct SessionState<G: Game> {
+	state: G,
+	history: Vec<StateSnapshot<G>>,
 }
 impl<G: Game + Clone> SessionState<G> {
 	fn new(state: G) -> Self {
 		Self {
-			seed: state.clone(),
 			state,
 			history: Vec::new(),
 		}
@@ -348,6 +357,7 @@ impl<G: Game> Session<G>
 where
 	G: Clone + Eq + core::hash::Hash,
 	G::Stats: Clone + Default,
+	G::Config: Clone,
 	G::Instruction: Clone + Eq + core::hash::Hash,
 {
 	pub fn new(state: G, config: G::Config) -> Self {
@@ -372,7 +382,7 @@ where
 	pub const fn config(&self) -> &G::Config {
 		&self.config
 	}
-	pub fn history(&self) -> &[G::Instruction] {
+	pub fn history(&self) -> &[StateSnapshot<G>] {
 		&self.state.history
 	}
 	pub fn undo(&mut self) {
@@ -380,7 +390,7 @@ where
 			.process_instruction(&mut self.stats, &self.config, SessionInstruction::Undo)
 	}
 	pub fn possible_instructions(&self) -> impl Iterator<Item = G::Instruction> + use<G> {
-		self.state.state.possible_instructions(&self.config)
+		self.state.state.possible_instructions()
 	}
 	pub fn process_instruction(&mut self, instruction: G::Instruction) {
 		self.state.process_instruction(
@@ -392,22 +402,69 @@ where
 	pub fn is_win(&self) -> bool {
 		self.state.is_win()
 	}
+	pub fn is_winnable(&self) -> Option<Vec<StateSnapshot<G>>> {
+		let mut state_moves = std::collections::HashMap::new();
+		let mut state = self.clone();
+		let mut i: u64 = 0;
+		while !state.is_win() {
+			// Continue existing iterator if it exists
+			let it = state_moves
+				.entry(state.state().clone())
+				.or_insert_with(|| state.state().possible_instructions());
+
+			// Run one possible move
+			if let Some(instruction) = it.next() {
+				state.process_instruction(instruction);
+				continue;
+			}
+
+			// No more moves. If we can't undo we're done
+			if state.history().is_empty() {
+				return None;
+			} else {
+				state.undo();
+			}
+		}
+
+		// history includes cycles
+		let mut state_index: std::collections::HashMap<_, _> = state
+			.history()
+			.iter()
+			.enumerate()
+			.map(|(i, snapshot)| (snapshot.state().clone(), i))
+			.collect();
+
+		// find the longest range where the start and end are the same state
+		while let Some(longest_range) = state
+			.history()
+			.iter()
+			.enumerate()
+			.filter_map(|(index, snapshot)| {
+				let &last_index = state_index.get(snapshot.state())?;
+				let longness = last_index - index;
+				(longness != 0).then_some(index..last_index)
+			})
+			.max_by_key(|range| range.len())
+		{
+			state.state.history.drain(longest_range);
+			for (i, snapshot) in state.history().iter().enumerate() {
+				state_index.insert(snapshot.state().clone(), i);
+			}
+		}
+
+		Some(state.state.history)
+	}
 }
 impl<G: Game> Game for SessionState<G>
 where
-	G: Clone,
 	G::Stats: Default,
-	G::Instruction: Clone,
 {
 	type Stats = SessionStats<G::Stats>;
 	type Config = G::Config;
 	type Instruction = SessionInstruction<G::Instruction>;
-	fn possible_instructions(
+	fn possible_instructions(&self) -> impl Iterator<Item = Self::Instruction> + use<G> {
-		&self,
-		config: &Self::Config,
-	) -> impl Iterator<Item = Self::Instruction> + use<G> {
 		self.state
-			.possible_instructions(config)
+			.possible_instructions()
 			.map(SessionInstruction::InnerInstruction)
 	}
 	fn is_instruction_valid(&self, config: &Self::Config, instruction: Self::Instruction) -> bool {
@@ -426,19 +483,16 @@ where
 	) {
 		match instruction {
 			SessionInstruction::Undo => {
-				// replay the entire history of the game except one move
+				if let Some(snapshot) = self.history.pop() {
-				self.history.pop();
+					self.state = snapshot.state;
-				let mut inner_stats = G::Stats::default();
+					stats.increment_undos();
-				let mut state = self.seed.clone();
-				for instruction in &self.history {
-					state.process_instruction(&mut inner_stats, config, instruction.clone());
 				}
-				self.state = state;
-				stats.inner_stats = inner_stats;
-				stats.increment_undos();
 			}
 			SessionInstruction::InnerInstruction(instruction) => {
-				self.history.push(instruction.clone());
+				self.history.push(StateSnapshot {
+					state: self.state.clone(),
+					instruction: instruction.clone(),
+				});
 				self.state
 					.process_instruction(&mut stats.inner_stats, config, instruction);
 			}

klondike-bench/src/main.rs

@@ -9,10 +9,9 @@ fn play_to_win(rng: &mut Rng) -> Option<KlondikeStats> {
 	let mut stats = KlondikeStats::new();
 	const CONFIG: KlondikeConfig = KlondikeConfig {
 		draw_stock: klondike::DrawStockConfig::DrawOne,
-		move_from_foundation: klondike::MoveFromFoundationConfig::Allowed,
 	};
 	// play game a bit
-	while let Some(instruction) = game.get_auto_move(&CONFIG)
+	while let Some(instruction) = game.get_auto_move()
 		&& !game.is_win()
 	{
 		// quit before 250 moves

klondike-cli/src/main.rs

@@ -4,8 +4,8 @@ use klondike::{
 	KlondikePile, KlondikePileStack, KlondikeStats, SkipCards, Tableau, TableauStack,
 };
 
-// #[cfg(test)]
+#[cfg(test)]
-// mod test;
+mod test;
 
 use std::fmt::Display;
 struct Displayed<T>(T);
@@ -13,11 +13,11 @@ struct Displayed<T>(T);
 impl Display for Displayed<&Card> {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		match self.0.rank() {
-			Rank::Ace => write!(f, " A"),
+			Rank::Ace => write!(f, "A"),
-			Rank::Jack => write!(f, " J"),
+			Rank::Jack => write!(f, "J"),
-			Rank::Queen => write!(f, " Q"),
+			Rank::Queen => write!(f, "Q"),
-			Rank::King => write!(f, " K"),
+			Rank::King => write!(f, "K"),
-			other => write!(f, "{:>2}", other as u8),
+			other => write!(f, "{}", other as u8),
 		}?;
 		match self.0.suit() {
 			Suit::Spades => write!(f, "♠"),
@@ -33,7 +33,7 @@ impl Display for OptionalCard<'_> {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		match self {
 			&OptionalCard(Some(card)) => write!(f, "{}", Displayed(card)),
-			OptionalCard(None) => write!(f, " []"),
+			OptionalCard(None) => write!(f, "None"),
 		}
 	}
 }
@@ -42,17 +42,16 @@ impl Display for Displayed<&Klondike> {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		// Stock
 		let stock_count = self.0.state().stock().face_down().len();
+		writeln!(f, "Stock: {stock_count}")?;
 
 		// Hand
 		let hand = self.0.state().stock().face_up().last();
+		writeln!(f, "Hand: {}", OptionalCard(hand))?;
 
 		// Foundations
-		writeln!(f, " STOCK       F1  F2  F3  F4")?;
 		write!(
 			f,
-			" {:>2} {}     {} {} {} {}",
+			"Foundations: {} {} {} {}",
-			stock_count,
-			OptionalCard(hand),
 			OptionalCard(self.0.state().foundation1().last()),
 			OptionalCard(self.0.state().foundation2().last()),
 			OptionalCard(self.0.state().foundation3().last()),
@@ -60,49 +59,28 @@ impl Display for Displayed<&Klondike> {
 		)?;
 		writeln!(f)?;
 
-		writeln!(f, " T1  T2  T3  T4  T5  T6  T7")?;
+		fn write_pile<const DN: usize, const UP: usize>(
-
-		fn write_pile_card<const DN: usize, const UP: usize>(
 			f: &mut std::fmt::Formatter<'_>,
 			pile: &Pile<DN, UP>,
-			row: usize,
+			pile_id: usize,
 		) -> std::fmt::Result {
-			if let Some(_card) = pile.face_down().get(row) {
+			write!(f, "T{} ", pile_id)?;
-				return write!(f, " ⎾⏋"); // └┘ ⨽⨼ ⫭⫬
+			for _ in pile.face_down() {
+				write!(f, "]")?;
 			}
-			let Some(row) = row.checked_sub(pile.face_down().len()) else {
+			for card in pile.face_up() {
-				return write!(f, "   ");
+				write!(f, "{}", Displayed(card))?;
-			};
-			if let Some(card) = pile.face_up().get(row) {
-				return write!(f, "{}", Displayed(card));
 			}
-			write!(f, "   ")
+			writeln!(f)?;
-		}
+			Ok(())
-
-		fn write_row(
-			f: &mut std::fmt::Formatter<'_>,
-			game: &Klondike,
-			row: usize,
-		) -> std::fmt::Result {
-			write_pile_card(f, game.state().tableau1(), row)?;
-			write!(f, " ")?;
-			write_pile_card(f, game.state().tableau2(), row)?;
-			write!(f, " ")?;
-			write_pile_card(f, game.state().tableau3(), row)?;
-			write!(f, " ")?;
-			write_pile_card(f, game.state().tableau4(), row)?;
-			write!(f, " ")?;
-			write_pile_card(f, game.state().tableau5(), row)?;
-			write!(f, " ")?;
-			write_pile_card(f, game.state().tableau6(), row)?;
-			write!(f, " ")?;
-			write_pile_card(f, game.state().tableau7(), row)?;
-			writeln!(f)
-		}
-
-		for row in 0..7 + 13 {
-			write_row(f, self.0, row)?;
 		}
+		write_pile(f, self.0.state().tableau1(), 1)?;
+		write_pile(f, self.0.state().tableau2(), 2)?;
+		write_pile(f, self.0.state().tableau3(), 3)?;
+		write_pile(f, self.0.state().tableau4(), 4)?;
+		write_pile(f, self.0.state().tableau5(), 5)?;
+		write_pile(f, self.0.state().tableau6(), 6)?;
+		write_pile(f, self.0.state().tableau7(), 7)?;
 
 		Ok(())
 	}
@@ -274,7 +252,7 @@ fn main() -> Result<(), std::io::Error> {
 				}
 			}
 			SessionInstruction::Auto => {
-				if let Some(instruction) = session.state().get_auto_move(session.config()) {
+				if let Some(instruction) = session.state().get_auto_move() {
 					session.process_instruction(instruction);
 				} else {
 					println!("No valid moves!");

klondike-cli/src/test.rs

@@ -1,33 +1,15 @@
-use klondike::Klondike;
 use card_game::Session;
+use klondike::Klondike;
 #[test]
 fn test_is_winnable() {
 	// is winnable
-	let is_winnable = Session::new_default(Klondike::with_seed(123)).is_winnable();
+	let is_winnable = Session::new_default(Klondike::with_seed(124)).is_winnable();
-	println!("is_winnable = {is_winnable:?}");
+	if let Some(win_moves) = is_winnable {
-}
+		// for (i, ins) in win_moves.into_iter().enumerate() {
-#[test]
+		// 	println!("{i} = {:?}", ins.instruction());
-fn test_klondike() {
+		// }
-	// create game session
+		println!("Game is winnable with {} moves", win_moves.len());
-	let game = Klondike::with_seed(123);
+	} else {
-	let mut session = Session::new_default(game);
+		println!("Game is not winnable");
-
-	// is winnable
-	let is_winnable = session.is_winnable();
-	println!("is_winnable = {is_winnable:?}");
-
-	// play game
-	while let Some(instruction) = session.possible_instructions().next() {
-		session.process_instruction(instruction);
 	}
-
-	// did win
-	let is_win = session.is_win();
-
-	// print session history
-	for (i, instruction) in session.history().iter().enumerate() {
-		println!("move {i} = {instruction:?}");
-	}
-
-	println!("is_win = {is_win}");
 }

klondike/README.md

@@ -7,19 +7,18 @@ Klondike
 
 ```rust
 use card_game::Session;
-use klondike::{Klondike, KlondikeConfig};
+use klondike::Klondike;
 
 // create game session
 let game = Klondike::with_seed(123);
-let config = KlondikeConfig::default();
 let mut session = Session::new_default(game);
 
 // play game a bit
-while let Some(instruction) = session.state().get_auto_move(&config) {
+while let Some(instruction) = session.state().get_auto_move() {
 	session.process_instruction(instruction);
 
-	// quit after 200 moves or win
+	// quit after 1000 moves
-	if session.is_win() || 200 < session.stats().stats().moves() {
+	if 1000 < session.stats().stats().moves() {
 		break;
 	}
 }

klondike/src/lib.rs

@@ -14,17 +14,9 @@ pub enum DrawStockConfig {
 	DrawThree = 3,
 }
 
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
-pub enum MoveFromFoundationConfig {
-	#[default]
-	Allowed,
-	Disallowed,
-}
-
 #[derive(Clone, Debug, Default)]
 pub struct KlondikeConfig {
 	pub draw_stock: DrawStockConfig,
-	pub move_from_foundation: MoveFromFoundationConfig,
 }
 
 #[derive(Clone, Debug, Default)]
@@ -145,6 +137,7 @@ impl From<Foundation> for KlondikePile {
 	}
 }
 
+#[repr(u8)]
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum SkipCards {
 	Skip0,
@@ -373,26 +366,15 @@ impl KlondikeState {
 	pub const fn tableau7(&self) -> &Pile<6, 13> {
 		&self.tableau7
 	}
-	pub fn tableau_face_down_cards(&self, tableau: Tableau) -> &[Card] {
+	pub fn is_tableau_face_down_empty(&self, tableau: Tableau) -> bool {
 		match tableau {
-			Tableau::Tableau1 => self.tableau1.face_down(),
+			Tableau::Tableau1 => self.tableau1.face_down().is_empty(),
-			Tableau::Tableau2 => self.tableau2.face_down(),
+			Tableau::Tableau2 => self.tableau2.face_down().is_empty(),
-			Tableau::Tableau3 => self.tableau3.face_down(),
+			Tableau::Tableau3 => self.tableau3.face_down().is_empty(),
-			Tableau::Tableau4 => self.tableau4.face_down(),
+			Tableau::Tableau4 => self.tableau4.face_down().is_empty(),
-			Tableau::Tableau5 => self.tableau5.face_down(),
+			Tableau::Tableau5 => self.tableau5.face_down().is_empty(),
-			Tableau::Tableau6 => self.tableau6.face_down(),
+			Tableau::Tableau6 => self.tableau6.face_down().is_empty(),
-			Tableau::Tableau7 => self.tableau7.face_down(),
+			Tableau::Tableau7 => self.tableau7.face_down().is_empty(),
-		}
-	}
-	pub fn tableau_face_up_cards(&self, tableau: Tableau) -> &[Card] {
-		match tableau {
-			Tableau::Tableau1 => self.tableau1.face_up(),
-			Tableau::Tableau2 => self.tableau2.face_up(),
-			Tableau::Tableau3 => self.tableau3.face_up(),
-			Tableau::Tableau4 => self.tableau4.face_up(),
-			Tableau::Tableau5 => self.tableau5.face_up(),
-			Tableau::Tableau6 => self.tableau6.face_up(),
-			Tableau::Tableau7 => self.tableau7.face_up(),
 		}
 	}
 	pub fn stack_bottom_card(&self, src: KlondikePileStack) -> Option<&Card> {
@@ -400,7 +382,15 @@ impl KlondikeState {
 			KlondikePileStack::Tableau(TableauStack {
 				tableau,
 				skip_cards,
-			}) => self.tableau_face_up_cards(tableau).get(skip_cards as usize),
+			}) => match tableau {
+				Tableau::Tableau1 => self.tableau1.face_up().get(skip_cards as usize),
+				Tableau::Tableau2 => self.tableau2.face_up().get(skip_cards as usize),
+				Tableau::Tableau3 => self.tableau3.face_up().get(skip_cards as usize),
+				Tableau::Tableau4 => self.tableau4.face_up().get(skip_cards as usize),
+				Tableau::Tableau5 => self.tableau5.face_up().get(skip_cards as usize),
+				Tableau::Tableau6 => self.tableau6.face_up().get(skip_cards as usize),
+				Tableau::Tableau7 => self.tableau7.face_up().get(skip_cards as usize),
+			},
 			KlondikePileStack::Foundation(foundation) => {
 				self.foundations[foundation as usize].last()
 			}
@@ -409,7 +399,15 @@ impl KlondikeState {
 	}
 	pub fn top_card<S: Into<KlondikePile>>(&self, src: S) -> Option<&Card> {
 		match src.into() {
-			KlondikePile::Tableau(tableau) => self.tableau_face_up_cards(tableau).last(),
+			KlondikePile::Tableau(tableau) => match tableau {
+				Tableau::Tableau1 => self.tableau1.face_up().last(),
+				Tableau::Tableau2 => self.tableau2.face_up().last(),
+				Tableau::Tableau3 => self.tableau3.face_up().last(),
+				Tableau::Tableau4 => self.tableau4.face_up().last(),
+				Tableau::Tableau5 => self.tableau5.face_up().last(),
+				Tableau::Tableau6 => self.tableau6.face_up().last(),
+				Tableau::Tableau7 => self.tableau7.face_up().last(),
+			},
 			KlondikePile::Foundation(foundation) => self.foundations[foundation as usize].last(),
 			KlondikePile::Stock => self.stock.face_up().last(),
 		}
@@ -467,11 +465,7 @@ impl KlondikeState {
 			Tableau::Tableau7 => self.tableau7.extend(cards),
 		}
 	}
-	pub fn is_instruction_valid(
+	pub fn is_instruction_valid(&self, instruction: KlondikeInstruction) -> bool {
-		&self,
-		config: &KlondikeConfig,
-		instruction: KlondikeInstruction,
-	) -> bool {
 		match instruction {
 			// Stock -> Stock draws a card or resets the stock
 			KlondikeInstruction::RotateStock => {
@@ -500,11 +494,6 @@ impl KlondikeState {
 			}
 			// other = move to tableau
 			KlondikeInstruction::DstTableau(dst_tableau) => {
-				if config.move_from_foundation == MoveFromFoundationConfig::Disallowed
-					&& let KlondikePileStack::Foundation(_) = dst_tableau.src
-				{
-					return false;
-				}
 				// get the cards
 				if let Some(src_card) = self.stack_bottom_card(dst_tableau.src) {
 					match self.top_card(dst_tableau.tableau) {
@@ -544,6 +533,10 @@ impl Iterator for KlondikeIter {
 		instruction
 	}
 }
+#[test]
+fn test_klondike_iter() {
+	assert_eq!(KlondikeIter::new().count(), 721);
+}
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub struct Klondike {
@@ -599,7 +592,7 @@ impl Klondike {
 	/// Check if the game should be auto-completed
 	pub fn is_win_trivial(&self) -> bool {
 		// all face down cards empty means win
-		self.state.stock.is_empty()
+		self.state.stock.face_down().is_empty()
 			&& self.state.tableau1.face_down().is_empty()
 			&& self.state.tableau2.face_down().is_empty()
 			&& self.state.tableau3.face_down().is_empty()
@@ -621,7 +614,7 @@ impl Klondike {
 				KlondikePileStack::Tableau(TableauStack {
 					tableau,
 					skip_cards: SkipCards::Skip0,
-				}) if !self.state().tableau_face_down_cards(tableau).is_empty()
+				}) if !self.state().is_tableau_face_down_empty(tableau)
 					|| self
 						.state()
 						.stack_bottom_card(dst_tableau.src)
@@ -636,18 +629,19 @@ 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, config: &KlondikeConfig) -> Option<KlondikeInstruction> {
+	pub fn get_auto_move(&self) -> Option<KlondikeInstruction> {
-		self.possible_instructions(config)
+		self.iter()
 			.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, config: &KlondikeConfig) -> Vec<KlondikeInstruction> {
+	pub fn get_sorted_moves(&self) -> Vec<KlondikeInstruction> {
-		let mut useful_moves: Vec<_> = self
+		let mut useful_moves: Vec<_> = self.iter().filter(|ins| !ins.is_useless()).collect();
-			.possible_instructions(config)
-			.filter(|ins| !ins.is_useless())
-			.collect();
 		useful_moves.sort_by_key(|ins| self.instruction_priority(ins));
 		useful_moves
 	}
@@ -657,17 +651,11 @@ impl Game for Klondike {
 	type Stats = KlondikeStats;
 	type Config = KlondikeConfig;
 	type Instruction = KlondikeInstruction;
-	fn possible_instructions(
+	fn possible_instructions(&self) -> impl Iterator<Item = Self::Instruction> + use<> {
-		&self,
+		self.get_sorted_moves().into_iter()
-		config: &Self::Config,
-	) -> impl Iterator<Item = Self::Instruction> + use<> {
-		let state = self.state.clone();
-		let config = config.clone();
-		KlondikeIter::new()
-			.filter(move |&instruction| state.is_instruction_valid(&config, instruction))
 	}
-	fn is_instruction_valid(&self, config: &Self::Config, instruction: Self::Instruction) -> bool {
+	fn is_instruction_valid(&self, _config: &Self::Config, instruction: Self::Instruction) -> bool {
-		self.state.is_instruction_valid(config, instruction)
+		self.state.is_instruction_valid(instruction)
 	}
 	fn process_instruction(
 		&mut self,