what is up with serde moving the deserializer

card_game/src/lib.rs

@@ -665,13 +665,16 @@ where
 #[cfg(feature = "serde")]
 impl<'de, G: Game> serde::Deserialize<'de> for SessionState<G>
 where
-	G: serde::Serialize + for<'a> serde::Deserialize<'a>,
+	G: serde::Deserialize<'de>,
+	G::Instruction: serde::Deserialize<'de>,
 {
 	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 	where
 		D: serde::Deserializer<'de>,
 	{
-		struct SessionStateVisitor<G>(core::marker::PhantomData<G>);
+		struct SessionStateVisitor<G> {
+			state: G,
+		}
 		impl<'de, G: Game> serde::de::Visitor<'de> for SessionStateVisitor<G> {
 			type Value = SessionState<G>;
 			fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -681,27 +684,44 @@ where
 			where
 				A: serde::de::SeqAccess<'de>,
 			{
-				let mut stack = Stack::new();
-				while let Some(card) = seq.next_element()? {
-					// TODO: Error
-					stack.try_push(card).unwrap();
+				let mut state = self.state.clone();
+				let mut history = match seq.size_hint() {
+					Some(capacity) => Vec::with_capacity(capacity),
+					None => Vec::new(),
+				};
+				while let Some(instruction) = seq.next_element()? {
+					history.push(StateSnapshot {
+						state: state.clone(),
+						instruction: instruction.clone(),
+					});
+					state.process_instruction(stats, config, instruction);
 				}
-				Ok(stack)
+				Ok(SessionState { state, history })
 			}
 		}
-		deserializer.deserialize_seq(SessionStateVisitor(core::marker::PhantomData))
+		let state = G::deserialize(deserializer)?;
+		deserializer.deserialize_seq(SessionStateVisitor { state })
 	}
 }
 #[cfg(feature = "serde")]
-impl<G: Game> serde::Serialize for SessionState<G> {
+impl<G: Game> serde::Serialize for SessionState<G>
+where
+	G: serde::Serialize,
+	G::Instruction: serde::Serialize,
+{
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
+		if let Some(state) = self.history.first() {
+			state.serialize(serializer)?;
+		}else{
+			self.state.serialize(serializer)?;
+		}
 		use serde::ser::SerializeSeq;
-		let mut seq = serializer.serialize_seq(Some(self.len()))?;
-		for card in self.as_slice() {
-			seq.serialize_element(card)?;
+		let mut seq = serializer.serialize_seq(Some(self.history.len()))?;
+		for snapshot in &self.history {
+			seq.serialize_element(&snapshot.instruction)?;
 		}
 		seq.end()
 	}