chess_ 3.3.3

This is a fast chess move generator. It has a very good set of documentation, so you should take advantage of that. It (now) generates all lookup tables with a build.rs file, which means that very little pseudo-legal move generation requires branching. There are some convenience functions that are exposed to, for example, find all the squares between two squares. This uses a copy-on-make style structure, and the Board structure is as slimmed down as possible to reduce the cost of copying the board. There are places to improve perft-test performance further, but I instead opt to be more feature-complete to make it useful in real applications. For example, I generate both a hash of the board and a pawn-hash of the board for use in evaluation lookup tables (using Zobrist hashing). There are two ways to generate moves, one is faster, the other has more features that will be useful if making a chess engine. See the documentation for more details.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

#[derive(Copy, Clone, PartialEq, PartialOrd)]
struct CacheTableEntry<T: Copy + Clone + PartialEq + PartialOrd> {
	hash: u64,
	entry: T,
}

/// Store a cache of entries, each with an associated hash.
pub struct CacheTable<T: Copy + Clone + PartialEq + PartialOrd> {
	table: Box<[CacheTableEntry<T>]>,
	mask: usize,
}

impl<T: Copy + Clone + PartialEq + PartialOrd> CacheTable<T> {
	/// Create a new `CacheTable` with each associated entry initialized with a hash of '0'
	/// Note: You must pass in a size where only 1 bit is set. (AKA: 2, 4, 8, 16, 1024, 65536,
	/// etc.)
	/// Panics when size is invalid.
	#[inline]
	pub fn new(size: usize, default: T) -> CacheTable<T> {
		if size.count_ones() != 1 {
			panic!("You cannot create a CacheTable with a non-binary number.");
		}
		let values = vec![CacheTableEntry { hash: 0, entry: default }; size];
		CacheTable { table: values.into_boxed_slice(), mask: size - 1 }
	}

	/// Get a particular entry with the hash specified
	#[inline]
	pub fn get(&self, hash: u64) -> Option<T> {
		let entry = unsafe { *self.table.get_unchecked((hash as usize) & self.mask) };
		if entry.hash == hash { Some(entry.entry) } else { None }
	}

	/// Add (or overwrite) an entry with the associated hash
	#[inline]
	pub fn add(&mut self, hash: u64, entry: T) {
		let e = unsafe { self.table.get_unchecked_mut((hash as usize) & self.mask) };
		*e = CacheTableEntry { hash, entry };
	}

	/// Replace an entry in the hash table with a user-specified replacement policy specified by
	/// `replace`. The `replace` closure is called with the previous entry occupying the hash table
	/// slot, and returns true or false to specify whether the entry should be replaced. Note that
	/// the previous entry may not have the same hash, but merely be the default initialization or
	/// a hash collision with `hash`.
	///
	/// ```
	/// use chess::CacheTable;
	///
	/// # fn main() {
	///
	/// let mut table: CacheTable<char> = CacheTable::new(256, 'a');
	///
	/// assert_eq!(table.get(5), None);
	/// // Note that 'a' is the default initialization value.
	/// table.replace_if(5, 'b', |old_entry| old_entry != 'a');
	/// assert_eq!(table.get(5), None);
	/// table.replace_if(5, 'c', |old_entry| old_entry == 'a');
	/// assert_eq!(table.get(5), Some('c'));
	/// table.replace_if(5, 'd', |old_entry| old_entry == 'c');
	/// assert_eq!(table.get(5), Some('d'));
	///
	/// # }
	/// ```
	#[inline(always)]
	pub fn replace_if<F: Fn(T) -> bool>(&mut self, hash: u64, entry: T, replace: F) {
		let e = unsafe { self.table.get_unchecked_mut((hash as usize) & self.mask) };
		if replace(e.entry) {
			*e = CacheTableEntry { hash, entry };
		}
	}
}