decouple PV from TranspositionTable

benches/ttm.rs

@@ -26,7 +26,7 @@ fn ttm(c: &mut Criterion, edps: &[(&str, &str)]) {
             || (Searcher::with_options(options), positions.next().unwrap()),
             |(s, (pos, m))| {
                 let timer = Instant::now();
-                for d in 1..=DepthBounds::UPPER {
+                for d in 0..=DepthBounds::UPPER {
                     let pv = s.search::<1>(pos, Limits::Depth(Depth::new(d)));
                     if pv.first() == Some(m) || timer.elapsed() >= Duration::from_millis(80) {
                         break;

bin/engine.rs

@@ -17,7 +17,7 @@ trait Searcher {
 impl MockSearcher {
     fn search<const N: usize>(&mut self, pos: &Position, limits: Limits) -> Pv<N> {
         let pv = Searcher::search(self, pos, limits);
-        Pv::new(pv.depth(), pv.score(), pv.iter().copied().collect())
+        Pv::new(pv.score(), pv.depth(), pv.ply(), pv)
     }
 
     fn with_options(_: Options) -> Self {
@@ -72,7 +72,7 @@ impl Ai for Engine {
     {
         Box::pin(stream! {
             let timer = Instant::now();
-            for d in 1..=limits.depth().get() {
+            for d in 0..=limits.depth().get() {
                 let elapsed = timer.elapsed();
                 if elapsed < limits.time() / 2 {
                     let depth = Depth::new(d);
@@ -93,7 +93,7 @@ impl Ai for Engine {
 mod tests {
     use super::*;
     use futures_util::StreamExt;
-    use lib::search::{Line, Score};
+    use lib::search::{Ply, Score};
     use mockall::predicate::eq;
     use proptest::sample::size_range;
     use std::time::Duration;
@@ -110,11 +110,15 @@ mod tests {
 
     #[proptest(async = "tokio")]
     #[should_panic]
-    async fn play_panics_if_there_are_no_legal_moves(l: Limits, pos: Position, d: Depth, s: Score) {
+    async fn play_panics_if_there_are_no_legal_moves(
+        l: Limits,
+        pos: Position,
+        s: Score,
+        d: Depth,
+        p: Ply,
+    ) {
         let mut strategy = Strategy::new();
-        strategy
-            .expect_search()
-            .return_const(Pv::new(d, s, Line::default()));
+        strategy.expect_search().return_const(Pv::new(s, d, p, []));
 
         let mut engine = Engine { strategy };
         engine.play(&pos, l).await;
@@ -123,19 +127,19 @@ mod tests {
     #[proptest(async = "tokio")]
     async fn analyze_returns_sequence_of_principal_variations(
         pos: Position,
-        #[any(size_range(0..=3).lift())] pvs: Vec<Pv>,
+        #[any(size_range(1..=3).lift())] pvs: Vec<Pv>,
     ) {
         let mut strategy = Strategy::new();
 
         for (d, pv) in pvs.iter().enumerate() {
             strategy
                 .expect_search()
-                .with(eq(pos.clone()), eq(Limits::Depth(Depth::saturate(d + 1))))
+                .with(eq(pos.clone()), eq(Limits::Depth(Depth::saturate(d))))
                 .return_const(pv.clone());
         }
 
         let mut engine = Engine { strategy };
-        let l = Limits::Depth(Depth::saturate(pvs.len()));
+        let l = Limits::Depth(Depth::saturate(pvs.len() - 1));
         assert_eq!(engine.analyze(&pos, l).collect::<Vec<_>>().await, pvs);
     }
 
@@ -149,7 +153,7 @@ mod tests {
 
         assert_eq!(
             engine.analyze(&pos, l).collect::<Vec<_>>().await,
-            Vec::new()
+            Vec::<Pv>::new()
         );
     }
 }

lib/chess/bitboard.rs

@@ -106,11 +106,26 @@ mod tests {
     use super::*;
     use test_strategy::proptest;
 
+    #[proptest]
+    fn empty_constructs_board_with_no_squares() {
+        assert_eq!(Bitboard::empty().into_iter().count(), 0);
+    }
+
+    #[proptest]
+    fn full_constructs_board_with_all_squares() {
+        assert_eq!(Bitboard::full().into_iter().count(), 64);
+    }
+
     #[proptest]
     fn len_returns_number_of_squares_on_the_board(bb: Bitboard) {
         assert_eq!(bb.len(), bb.into_iter().count());
     }
 
+    #[proptest]
+    fn is_empty_returns_whether_there_are_squares_on_the_board(bb: Bitboard) {
+        assert_eq!(bb.is_empty(), bb.into_iter().count() == 0);
+    }
+
     #[proptest]
     fn contains_checks_whether_square_is_on_the_board(bb: Bitboard) {
         for s in bb {

lib/chess/position.rs

@@ -36,7 +36,7 @@ pub struct ImpossibleExchange(#[error(not(source))] pub Square);
 /// The current position on the chess board.
 ///
 /// This type guarantees that it only holds valid positions.
-#[derive(DebugCustom, Display, Default, Clone, Eq)]
+#[derive(DebugCustom, Display, Default, Clone)]
 #[debug(fmt = "Position({self})")]
 #[display(
     fmt = "{}",
@@ -50,6 +50,8 @@ impl Hash for Position {
     }
 }
 
+impl Eq for Position {}
+
 impl PartialEq for Position {
     fn eq(&self, other: &Self) -> bool {
         self.0 == other.0
@@ -577,30 +579,18 @@ mod tests {
     }
 
     #[proptest]
-    fn exchange_finds_attacker_of_least_value(pos: Position, s: Square) {
-        match pos.clone().exchange(s) {
-            Ok(m) => {
-                let attackers = pos.attackers(s, pos.turn());
-                assert!(attackers.contains(m.whence()));
-
-                assert_eq!(
-                    attackers.into_iter().filter_map(|a| pos.role_on(a)).min(),
-                    Some(m.role()),
-                );
-            }
-
-            Err(_) => {
-                if pos[s].is_some() {
-                    for a in pos.attackers(s, pos.turn()) {
-                        let m = Move(a, s, Promotion::None);
-                        assert_eq!(pos.clone().play(m), Err(IllegalMove(m)));
+    fn exchange_finds_attacker_of_least_value(
+        pos: Position,
+        #[filter(#pos.clone().exchange(#s).is_ok())] s: Square,
+    ) {
+        let m = pos.clone().exchange(s)?;
+        let attackers = pos.attackers(s, pos.turn());
+        assert!(attackers.contains(m.whence()));
 
-                        let m = Move(a, s, Promotion::Queen);
-                        assert_eq!(pos.clone().play(m), Err(IllegalMove(m)));
-                    }
-                }
-            }
-        }
+        assert_eq!(
+            attackers.into_iter().filter_map(|a| pos.role_on(a)).min(),
+            Some(m.role()),
+        );
     }
 
     #[proptest]

lib/chess/role.rs

@@ -12,13 +12,6 @@ pub enum Role {
     King,
 }
 
-impl Role {
-    /// Returns an iterator over [`Role`]s.
-    pub fn iter() -> impl DoubleEndedIterator<Item = Self> + ExactSizeIterator {
-        sm::Role::ALL.into_iter().map(Role::from)
-    }
-}
-
 #[doc(hidden)]
 impl From<Role> for sm::Role {
     fn from(r: Role) -> Self {

lib/lib.rs

@@ -1,4 +1,3 @@
-#![allow(clippy::arc_with_non_send_sync)]
 #![feature(const_maybe_uninit_write, const_mut_refs, const_transmute_copy)]
 
 /// Chess domain types.

lib/search/line.rs

@@ -21,11 +21,6 @@ pub struct Line<const N: usize>(
 );
 
 impl<const N: usize> Line<N> {
-    /// Returns an empty sequence.
-    pub fn empty() -> Self {
-        Self::default()
-    }
-
     /// The number of moves in this sequence.
     pub fn len(&self) -> usize {
         self.0.len()
@@ -42,12 +37,24 @@ impl<const N: usize> Line<N> {
     }
 }
 
+/// Extends a [`Line`] with an iterator of [`Move`]s.
+///
+/// The sequence might be truncated if the number of moves exceeds the internal capacity.
+impl<const N: usize> Extend<Move> for Line<N> {
+    fn extend<T: IntoIterator<Item = Move>>(&mut self, moves: T) {
+        let limit = N - self.len();
+        self.0.extend(moves.into_iter().take(limit));
+    }
+}
+
 /// Create a [`Line`] from an iterator of [`Move`]s.
 ///
 /// The sequence might be truncated if the number of moves exceeds the internal capacity.
 impl<const N: usize> FromIterator<Move> for Line<N> {
     fn from_iter<I: IntoIterator<Item = Move>>(moves: I) -> Self {
-        Line(moves.into_iter().take(N).collect())
+        let mut line = Line::default();
+        line.extend(moves);
+        line
     }
 }
 

lib/search/options.rs

@@ -12,11 +12,11 @@ pub struct Options {
     /// The size of the transposition table in bytes.
     ///
     /// This is an upper limit, the actual memory allocation may be smaller.
-    #[strategy(0usize..=1024)]
+    #[strategy(..=1024usize)]
     pub hash: usize,
 
     /// The number of threads to use while searching.
-    #[strategy((1usize..=4).prop_filter_map("zero", |t| NonZeroUsize::new(t)))]
+    #[strategy((1..=4usize).prop_filter_map("zero", |t| NonZeroUsize::new(t)))]
     pub threads: NonZeroUsize,
 }