Struct BitBoard 

pub struct BitBoard(pub u64);

A BitBoard represents a 64-bit chessboard where each bit corresponds to a square. It is useful for efficiently representing and manipulating chess positions.

The bitboard follows the Little-Endian Rank-File (LERF) notation. In this system, the least significant bit (LSB) represents the bottom-left corner of the chessboard, while the most significant bit (MSB) represents the top-right corner.

8 | 56 57 58 59 60 61 62 63
7 | 48 49 50 51 52 53 54 55
6 | 40 41 42 43 44 45 46 47
5 | 32 33 34 35 36 37 38 39
4 | 24 25 26 27 28 29 30 31
3 | 16 17 18 19 20 21 22 23
2 | 8  9  10 11 12 13 14 15
1 | 0  1  2  3  4  5  6  7
  -------------------------
    A  B  C  D  E  F  G  H

Tuple Fields

0: u64

Implementations

impl BitBoard

Methods for the BitBoard struct, including utilities for manipulating bits and interacting with squares.

pub const WHITE_SIDE: BitBoard

BitBoard representing WHITE_SIDE.

pub const BLACK_SIDE: BitBoard

BitBoard representing BLACK_SIDE.

pub const FILE_A: BitBoard

BitBoard representing FILE_A.

pub const FILE_B: BitBoard

BitBoard representing FILE_B.

pub const FILE_C: BitBoard

BitBoard representing FILE_C.

pub const FILE_D: BitBoard

BitBoard representing FILE_D.

pub const FILE_E: BitBoard

BitBoard representing FILE_E.

pub const FILE_F: BitBoard

BitBoard representing FILE_F.

pub const FILE_G: BitBoard

BitBoard representing FILE_G.

pub const FILE_H: BitBoard

BitBoard representing FILE_H.

pub const RANK_1: BitBoard

BitBoard representing RANK_1.

pub const RANK_2: BitBoard

BitBoard representing RANK_2.

pub const RANK_3: BitBoard

BitBoard representing RANK_3.

pub const RANK_4: BitBoard

BitBoard representing RANK_4.

pub const RANK_5: BitBoard

BitBoard representing RANK_5.

pub const RANK_6: BitBoard

BitBoard representing RANK_6.

pub const RANK_7: BitBoard

BitBoard representing RANK_7.

pub const RANK_8: BitBoard

BitBoard representing RANK_8.

pub const DARK_SQUARES: BitBoard

BitBoard representing DARK_SQUARES.

pub const LIGHT_SQUARES: BitBoard

BitBoard representing LIGHT_SQUARES.

pub const EMPTY: BitBoard

BitBoard representing EMPTY.

pub const FULL: BitBoard

BitBoard representing FULL.

pub const fn to_square(self) -> Option<Square>

Converts the BitBoard to a Square by returning the square corresponding to the least significant set bit (LSB), or None if the bitboard is empty.

Examples

// BitBoard with a single bit set at B2
let bitboard = BitBoard(1 << Square::B2 as u64);
assert_eq!(bitboard.to_square(), Some(Square::B2));

// BitBoard with multiple bits set; returns the least significant one (D1)
let bitboard = BitBoard((1 << Square::D1 as u64) | (1 << Square::E1 as u64));
assert_eq!(bitboard.to_square(), Some(Square::D1));

// Empty BitBoard returns None
let bitboard = BitBoard::EMPTY;
assert_eq!(bitboard.to_square(), None);

pub const fn to_square_nearest<const COLOR: usize>(self) -> Option<Square>

Returns the nearest Square set in the bitboard, based on the specified color’s perspective.

This method returns the square corresponding to the most relevant bit set in the bitboard:

• For White, the nearest square is the least significant bit (LSB), i.e., the lowest square index.
• For Black, the nearest square is the most significant bit (MSB), i.e., the highest square index.

This is particularly useful when evaluating move generation or determining priority based on color direction.

Examples

// Bitboard with multiple squares set
let bitboard = BitBoard((1 << Square::C3 as u64) | (1 << Square::E5 as u64));

// From White's perspective, C3 is the closest (LSB)
assert_eq!(bitboard.to_square_nearest::<{Color::White as usize}>(), Some(Square::C3));

// From Black's perspective, E5 is the closest (MSB)
assert_eq!(bitboard.to_square_nearest::<{Color::Black as usize}>(), Some(Square::E5));

// Empty bitboard returns None
let empty = BitBoard::EMPTY;
assert_eq!(empty.to_square_nearest::<{Color::White as usize}>(), None);

pub const fn set_square(self, square: Square) -> Self

Returns a new BitBoard with the bit corresponding to the given Square set to 1.

This operation does not mutate the original BitBoard, but instead returns a new instance with the specified square set.

Examples

// Setting a bit on an empty square
let bitboard = BitBoard::EMPTY;
assert!(bitboard.is_empty());
let square = Square::C2;
let updated = bitboard.set_square(square);
assert_eq!(updated, BitBoard(1 << Square::C2 as u64));

// Setting a bit on a BitBoard that already has bits set (D1 and E1)
let bitboard = BitBoard((1 << Square::D1 as u64) | (1 << Square::E1 as u64));
let square = Square::C2;
let updated = bitboard.set_square(square);
assert_eq!(updated, BitBoard((1 << Square::D1 as u64) | (1 << Square::E1 as u64) | (1 << Square::C2 as u64)));

pub const fn get_square(self, square: Square) -> bool

Returns true if the bit corresponding to the given Square is set in the BitBoard, otherwise returns false.

This method performs a bitwise check to determine whether the specified square is active (set to 1).

Examples

let bitboard = BitBoard::EMPTY;
assert!(!bitboard.get_square(Square::C3));

// BitBoard with a single bit set at square C3
let bitboard = BitBoard(1 << Square::C3 as u64);
assert!(bitboard.get_square(Square::C3));

// BitBoard with multiple bits set (E4 and F6)
let bitboard = BitBoard((1 << Square::E4 as u64) | (1 << Square::F6 as u64));
assert!(bitboard.get_square(Square::F6));
assert!(!bitboard.get_square(Square::G1));

pub const fn pop_square(self, square: Square) -> Self

Returns a new BitBoard with the bit corresponding to the given Square cleared (set to 0).

This operation does not mutate the original BitBoard, but returns a new instance with the specified square cleared. If the square was already cleared, the result is unchanged.

Examples

// Clear a square that is set (C4)
let bitboard = BitBoard(1 << Square::C4 as u64);
let updated = bitboard.pop_square(Square::C4);
assert_eq!(updated, BitBoard::EMPTY);

// Clear a square in a multi-bit board (D5 and E6)
let bitboard = BitBoard((1 << Square::D5 as u64) | (1 << Square::E6 as u64));
let updated = bitboard.pop_square(Square::D5);
let expected = BitBoard(1 << Square::E6 as u64);
assert_eq!(updated, expected);

// Clearing a square that is already empty does nothing
let bitboard = BitBoard(1 << Square::H1 as u64);
let updated = bitboard.pop_square(Square::A2);
assert_eq!(updated, bitboard);

pub const fn count_bits(self) -> u32

Returns the number of set bits in the BitBoard, representing how many squares are currently occupied.

Examples

// Empty BitBoard has 0 bits set
let bitboard = BitBoard::EMPTY;
assert_eq!(bitboard.count_bits(), 0);

// BitBoard with a single square set (E4)
let bitboard = BitBoard(1 << Square::E4 as u64);
assert_eq!(bitboard.count_bits(), 1);

// BitBoard with multiple squares set (A1, H8 and D4)
let bitboard = BitBoard((1 << Square::A1 as u64)
                      | (1 << Square::H8 as u64)
                      | (1 << Square::D4 as u64));
assert_eq!(bitboard.count_bits(), 3);

pub const fn flip(self) -> Self

Flips the BitBoard vertically by mirroring its bits across the horizontal axis (rank 4).

This operation swaps the ranks of the board so that rank 1 becomes rank 8, rank 2 becomes rank 7, and so on.

Examples

// A piece on A1 is flipped to A8
let bitboard = BitBoard(1 << Square::A1 as u64);
let flipped = bitboard.flip();
assert_eq!(flipped, BitBoard(1 << Square::A8 as u64));

// Multiple pieces on the first and second ranks flipped to eighth and seventh
let bitboard = BitBoard((1 << Square::B1 as u64) | (1 << Square::C2 as u64));
let flipped = bitboard.flip();
let expected = BitBoard((1 << Square::B8 as u64) | (1 << Square::C7 as u64));
assert_eq!(flipped, expected);

// Flipping twice returns the original position
let original = bitboard;
let flipped_twice = bitboard.flip().flip();
assert_eq!(flipped_twice, original);

pub const fn forward(self, side: Color) -> Self

Shifts the BitBoard one rank forward relative to the side to move.

For White, this shifts all bits one rank up (towards rank 8).
For Black, this shifts all bits one rank down (towards rank 1).

This function is commonly used to generate forward moves, such as pawn pushes, and respects the perspective of the side to move.

Examples

// A White pawn on D2 moves forward to D3
let white_pawn = BitBoard(1 << Square::D2 as u64);
let advanced = white_pawn.forward(Color::White);
assert_eq!(advanced, BitBoard(1 << Square::D3 as u64));

// A Black pawn on E7 moves forward to E6 (i.e., shifted down the board)
let black_pawn = BitBoard(1 << Square::E7 as u64);
let advanced = black_pawn.forward(Color::Black);
assert_eq!(advanced, BitBoard(1 << Square::E6 as u64));

Expected behavior

A square on rank 8 remains off-board after shifting forward, and cannot be shifted back by the same operation

let offboard = BitBoard(1 << Square::H8 as u64).forward(Color::White);
assert_eq!(offboard, BitBoard(0));

pub const fn left(self, side: Color) -> Self

Returns a new BitBoard representing the squares to the "left" of the current positions, from the perspective of the given Color.

From White’s perspective, "left" means west (toward file A), and bits are shifted right.

From Black’s perspective, "left" means east (toward file H), and bits are shifted left.

Examples

// A White piece on D4 moves left to C4
let bitboard = BitBoard(1 << Square::D4 as u64);
let result = bitboard.left(Color::White);
assert_eq!(result, BitBoard(1 << Square::C4 as u64));

// A Black piece on D4 moves left to E4 (inverted perspective)
let bitboard = BitBoard(1 << Square::D4 as u64);
let result = bitboard.left(Color::Black);
assert_eq!(result, BitBoard(1 << Square::E4 as u64));

Note

This operation does not wrap around the board. Any square on the edge (file A for White, file H for Black) will be cleared in the result.

// A White piece on file A cannot move left
let bitboard = BitBoard(1 << Square::A2 as u64);
assert_eq!(bitboard.left(Color::White), BitBoard::EMPTY);

// A Black piece on file H cannot move left
let bitboard = BitBoard(1 << Square::H7 as u64);
assert_eq!(bitboard.left(Color::Black), BitBoard::EMPTY);

pub const fn left_for<const COLOR: usize>(self) -> Self

Returns a new BitBoard representing the squares to the "left" of the current positions, from the perspective of a specific color known at compile time.

For White, "left" refers to west (toward file A), and bits are shifted right.
For Black, "left" refers to east (toward file H), and bits are shifted left.

Examples

// A White piece on D4 moves left to C4
let bitboard = BitBoard(1 << Square::D4 as u64);
let result = bitboard.left_for::<{ Color::White as usize }>();
assert_eq!(result, BitBoard(1 << Square::C4 as u64));

// A Black piece on D4 moves left to E4 (inverted perspective)
let bitboard = BitBoard(1 << Square::D4 as u64);
let result = bitboard.left_for::<{ Color::Black as usize }>();
assert_eq!(result, BitBoard(1 << Square::E4 as u64));

Note

This operation does not wrap around the board. Any square on the edge (file A for White, file H for Black) will be cleared in the result.

// A White piece on file A cannot move left
let bitboard = BitBoard(1 << Square::A2 as u64);
let result = bitboard.left_for::<{ Color::White as usize }>();
assert_eq!(result, BitBoard::EMPTY);

// A Black piece on file H cannot move left
let bitboard = BitBoard(1 << Square::H7 as u64);
let result = bitboard.left_for::<{ Color::Black as usize }>();
assert_eq!(result, BitBoard::EMPTY);

pub const fn right(self, side: Color) -> Self

Returns a new BitBoard representing the squares to the "right" of the current positions, from the perspective of the given Color.

From the perspective of White, "right" means east (toward file H), and bits are shifted left.
From the perspective of Black, "right" means west (toward file A), and bits are shifted right.

Examples

// A White piece on D4 moves right to E4
let bitboard = BitBoard(1 << Square::D4 as u64);
let result = bitboard.right(Color::White);
assert_eq!(result, BitBoard(1 << Square::E4 as u64));

// A Black piece on D4 moves right to C4 (inverted perspective)
let bitboard = BitBoard(1 << Square::D4 as u64);
let result = bitboard.right(Color::Black);
assert_eq!(result, BitBoard(1 << Square::C4 as u64));

Expected behavior

Squares on the edge files are cleared to avoid horizontal wrap-around:

// A White piece on file H cannot move right
let bitboard = BitBoard(1 << Square::H2 as u64);
assert_eq!(bitboard.right(Color::White), BitBoard::EMPTY);

// A Black piece on file A cannot move right
let bitboard = BitBoard(1 << Square::A7 as u64);
assert_eq!(bitboard.right(Color::Black), BitBoard::EMPTY);

pub const fn right_for<const COLOR: usize>(self) -> Self

Returns a new BitBoard representing the squares to the "right" of the current positions, from the perspective of a specific color known at compile time.

For White, "right" means east (toward file H), and bits are shifted left.
For Black, "right" means west (toward file A), and bits are shifted right.

Examples

// A White piece on D4 moves right to E4
let bitboard = BitBoard(1 << Square::D4 as u64);
let result = bitboard.right_for::<{ Color::White as usize }>();
assert_eq!(result, BitBoard(1 << Square::E4 as u64));

// A Black piece on D4 moves right to C4 (inverted perspective)
let bitboard = BitBoard(1 << Square::D4 as u64);
let result = bitboard.right_for::<{ Color::Black as usize }>();
assert_eq!(result, BitBoard(1 << Square::C4 as u64));

Expected behavior

Squares on the edge files are cleared to avoid horizontal wrap-around:

// A White piece on file H cannot move right
let bitboard = BitBoard(1 << Square::H2 as u64);
let result = bitboard.right_for::<{ Color::White as usize }>();
assert_eq!(result, BitBoard::EMPTY);

// A Black piece on file A cannot move right
let bitboard = BitBoard(1 << Square::A7 as u64);
let result = bitboard.right_for::<{ Color::Black as usize }>();
assert_eq!(result, BitBoard::EMPTY);

pub const fn up_left(self, side: Color) -> Self

Returns a new BitBoard representing the squares diagonally "up-left" from the current positions, from the perspective of the given Color.

For White, this corresponds to a shift one rank forward and one file to the left.
For Black, this corresponds to a shift one rank backward and one file to the right.

Examples

// A White pawn on E4 attacks diagonally up-left to D5
let bitboard = BitBoard(1 << Square::E4 as u64);
let result = bitboard.up_left(Color::White);
assert_eq!(result, BitBoard(1 << Square::D5 as u64));

// A Black pawn on D5 attacks diagonally up-left to E4 (from Black's perspective)
let bitboard = BitBoard(1 << Square::D5 as u64);
let result = bitboard.up_left(Color::Black);
assert_eq!(result, BitBoard(1 << Square::E4 as u64));

Expected behavior

Movement from edge files is masked out to prevent wrap-around:

// A White piece on file A cannot move diagonally up-left
let bitboard = BitBoard(1 << Square::A2 as u64);
let result = bitboard.up_left(Color::White);
assert_eq!(result, BitBoard::EMPTY);

// A Black piece on file H cannot move diagonally up-left
let bitboard = BitBoard(1 << Square::H7 as u64);
let result = bitboard.up_left(Color::Black);
assert_eq!(result, BitBoard::EMPTY);

pub const fn up_left_for<const COLOR: usize>(self) -> Self

Returns a new BitBoard representing the squares diagonally "up-left" from the current positions, from the perspective of a specific color known at compile time.

For White, this corresponds to a shift one rank forward and one file to the left.
For Black, this corresponds to a shift one rank backward and one file to the right.

Examples

// A White pawn on E4 attacks diagonally up-left to D5
let bitboard = BitBoard(1 << Square::E4 as u64);
let result = bitboard.up_left_for::<{ Color::White as usize }>();
assert_eq!(result, BitBoard(1 << Square::D5 as u64));

// A Black pawn on D5 attacks diagonally up-left to E4 (from Black's perspective)
let bitboard = BitBoard(1 << Square::D5 as u64);
let result = bitboard.up_left_for::<{ Color::Black as usize }>();
assert_eq!(result, BitBoard(1 << Square::E4 as u64));

Expected behavior

Movement from edge files is masked out to prevent wrap-around:

// A White piece on file A cannot move diagonally up-left
let bitboard = BitBoard(1 << Square::A2 as u64);
let result = bitboard.up_left_for::<{ Color::White as usize }>();
assert_eq!(result, BitBoard::EMPTY);

// A Black piece on file H cannot move diagonally up-left
let bitboard = BitBoard(1 << Square::H7 as u64);
let result = bitboard.up_left_for::<{ Color::Black as usize }>();
assert_eq!(result, BitBoard::EMPTY);

pub const fn up_right(self, side: Color) -> Self

Returns a new BitBoard representing the squares diagonally "up-right" from the current positions, from the perspective of the given Color.

For White, this corresponds to a shift one rank forward and one file to the right.
For Black, this corresponds to a shift one rank backward and one file to the left.

Examples

// A White pawn on E4 attacks diagonally up-right to F5
let bitboard = BitBoard(1 << Square::E4 as u64);
let result = bitboard.up_right(Color::White);
assert_eq!(result, BitBoard(1 << Square::F5 as u64));

// A Black pawn on D5 attacks diagonally up-right to C4 (from Black's perspective)
let bitboard = BitBoard(1 << Square::D5 as u64);
let result = bitboard.up_right(Color::Black);
assert_eq!(result, BitBoard(1 << Square::C4 as u64));

Expected behavior

Movement from edge files is masked out to prevent wrap-around:

// A White piece on file H cannot move diagonally up-right
let bitboard = BitBoard(1 << Square::H2 as u64);
let result = bitboard.up_right(Color::White);
assert_eq!(result, BitBoard::EMPTY);

// A Black piece on file A cannot move diagonally up-right
let bitboard = BitBoard(1 << Square::A7 as u64);
let result = bitboard.up_right(Color::Black);
assert_eq!(result, BitBoard::EMPTY);

pub const fn up_right_for<const COLOR: usize>(self) -> Self

Returns a new BitBoard representing the squares diagonally "up-right" from the current positions, from the perspective of a specific color known at compile time.

For White, this corresponds to a shift one rank forward and one file to the right.
For Black, this corresponds to a shift one rank backward and one file to the left.

Examples

// A White pawn on E4 attacks diagonally up-right to F5
let bitboard = BitBoard(1 << Square::E4 as u64);
let result = bitboard.up_right_for::<{ Color::White as usize }>();
assert_eq!(result, BitBoard(1 << Square::F5 as u64));

// A Black pawn on D5 attacks diagonally up-right to C4 (from Black's perspective)
let bitboard = BitBoard(1 << Square::D5 as u64);
let result = bitboard.up_right_for::<{ Color::Black as usize }>();
assert_eq!(result, BitBoard(1 << Square::C4 as u64));

Expected behavior

Squares on the edge files are cleared to avoid horizontal wrap-around:

// A White piece on file H cannot move diagonally up-right
let bitboard = BitBoard(1 << Square::H4 as u64);
let result = bitboard.up_right_for::<{ Color::White as usize }>();
assert_eq!(result, BitBoard::EMPTY);

// A Black piece on file A cannot move diagonally up-right
let bitboard = BitBoard(1 << Square::A6 as u64);
let result = bitboard.up_right_for::<{ Color::Black as usize }>();
assert_eq!(result, BitBoard::EMPTY);

pub const fn is_empty(self) -> bool

Returns true if the BitBoard is empty (i.e., no bits are set), otherwise returns false.

An empty BitBoard means that no squares are occupied — all 64 bits are zero.

Examples

// An explicitly empty BitBoard
let empty = BitBoard::EMPTY;
assert!(empty.is_empty());

// A BitBoard with a single square set is not empty
let bitboard = BitBoard(1 << Square::E4 as u64);
assert!(!bitboard.is_empty());

// BitBoard cleared by an operation becomes empty
let occupied = BitBoard(1 << Square::D2 as u64);
let cleared = occupied.pop_square(Square::D2);
assert!(cleared.is_empty());

Trait Implementations

impl BitAnd for BitBoard

type Output = BitBoard

The resulting type after applying the & operator.

fn bitand(self, other: Self) -> BitBoard

Performs the & operation.

impl BitAndAssign for BitBoard

fn bitand_assign(&mut self, other: Self)

Performs the &= operation.

impl BitOr for BitBoard

type Output = BitBoard

The resulting type after applying the | operator.

fn bitor(self, other: Self) -> BitBoard

Performs the | operation.

impl BitOrAssign for BitBoard

fn bitor_assign(&mut self, other: Self)

Performs the |= operation.

impl BitXor for BitBoard

type Output = BitBoard

The resulting type after applying the ^ operator.

fn bitxor(self, other: Self) -> BitBoard

Performs the ^ operation.

impl BitXorAssign for BitBoard

fn bitxor_assign(&mut self, other: Self)

Performs the ^= operation.

impl Clone for BitBoard

fn clone(&self) -> BitBoard

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BitBoard

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for BitBoard

fn default() -> BitBoard

Returns the “default value” for a type.

impl Display for BitBoard

Implements display formatting for the BitBoard struct. This allows for the BitBoard to be printed in a human-readable format, where filled squares are shown as ‘★’ and empty squares as ‘·’.

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for BitBoard

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Iterator for BitBoard

Implements Iterator for BitBoard, allowing iteration over the set squares. Each call to next returns the next Square that is set (i.e., the next ‘1’ bit)

type Item = Square

The type of the elements being iterated over.

fn next(&mut self) -> Option<Square>

Advances the iterator and returns the next value.

fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>

where Self: Sized,

🔬This is a nightly-only experimental API. (iter_next_chunk)

Advances the iterator and returns an array containing the next N values.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn count(self) -> usize

where Self: Sized,

Consumes the iterator, counting the number of iterations and returning it.

fn last(self) -> Option<Self::Item>

where Self: Sized,

Consumes the iterator, returning the last element.

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator by n elements.

fn nth(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element of the iterator.

fn step_by(self, step: usize) -> StepBy<Self>

where Self: Sized,

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence.

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs.

fn intersperse(self, separator: Self::Item) -> Intersperse<Self>

where Self: Sized, Self::Item: Clone,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places a copy of separator between adjacent items of the original iterator.

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>

where Self: Sized, G: FnMut() -> Self::Item,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places an item generated by separator between adjacent items of the original iterator.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates an iterator which calls that closure on each element.

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(Self::Item),

Calls a closure on each element of an iterator.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both filters and maps.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates an iterator which gives the current iteration count as well as the next value.

fn peekable(self) -> Peekable<Self>

where Self: Sized,

Creates an iterator which can use the peek and peek_mut methods to look at the next element of the iterator without consuming it. See their documentation for more information.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that skips elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that yields elements based on a predicate.

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>

where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both yields elements based on a predicate and maps.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates an iterator that skips the first n elements.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

An iterator adapter which, like fold, holds internal state, but unlike fold, produces a new iterator.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>

where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,

Creates an iterator that works like map, but flattens nested structure.

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,

🔬This is a nightly-only experimental API. (iter_map_windows)

Calls the given function f for each contiguous window of size N over self and returns an iterator over the outputs of f. Like slice::windows(), the windows during mapping overlap as well.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Creates an iterator which ends after the first None.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Iterator.

fn collect<B>(self) -> B

where B: FromIterator<Self::Item>, Self: Sized,

Transforms an iterator into a collection.

fn collect_into<E>(self, collection: &mut E) -> &mut E

where E: Extend<Self::Item>, Self: Sized,

🔬This is a nightly-only experimental API. (iter_collect_into)

Collects all the items from an iterator into a collection.

fn partition<B, F>(self, f: F) -> (B, B)

where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,

Consumes an iterator, creating two collections from it.

fn is_partitioned<P>(self, predicate: P) -> bool

where Self: Sized, P: FnMut(Self::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_is_partitioned)

Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return true precede all those that return false.

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

An iterator method that applies a function as long as it returns successfully, producing a single, final value.

fn try_for_each<F, R>(&mut self, f: F) -> R

where Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,

An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error.

fn fold<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, Self::Item) -> B,

Folds every element into an accumulator by applying an operation, returning the final result.

fn reduce<F>(self, f: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing operation.

fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType

where Self: Sized, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (iterator_try_reduce)

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.

fn all<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if every element of the iterator matches a predicate.

fn any<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if any element of the iterator matches a predicate.

fn find<P>(&mut self, predicate: P) -> Option<Self::Item>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Searches for an element of an iterator that satisfies a predicate.

fn find_map<B, F>(&mut self, f: F) -> Option<B>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Applies function to the elements of iterator and returns the first non-none result.

fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType

where Self: Sized, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (try_find)

Applies function to the elements of iterator and returns the first true result or the first error.

fn position<P>(&mut self, predicate: P) -> Option<usize>

where Self: Sized, P: FnMut(Self::Item) -> bool,

Searches for an element in an iterator, returning its index.

fn max(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the maximum element of an iterator.

fn min(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the minimum element of an iterator.

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the maximum value from the specified function.

fn max_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the specified comparison function.

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the specified function.

fn min_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the specified comparison function.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers.

fn copied<'a, T>(self) -> Copied<Self>

where T: Copy + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: Clone + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements.

fn cycle(self) -> Cycle<Self>

where Self: Sized + Clone,

Repeats an iterator endlessly.

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>

where Self: Sized,

🔬This is a nightly-only experimental API. (iter_array_chunks)

Returns an iterator over N elements of the iterator at a time.

fn sum<S>(self) -> S

where Self: Sized, S: Sum<Self::Item>,

Sums the elements of an iterator.

fn product<P>(self) -> P

where Self: Sized, P: Product<Self::Item>,

Iterates over the entire iterator, multiplying all the elements

fn cmp<I>(self, other: I) -> Ordering

where I: IntoIterator<Item = Self::Item>, Self::Item: Ord, Self: Sized,

Lexicographically compares the elements of this Iterator with those of another.

fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn partial_cmp<I>(self, other: I) -> Option<Ordering>

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Lexicographically compares the PartialOrd elements of this Iterator with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements. As soon as an order can be determined, the evaluation stops and a result is returned.

fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn eq<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are equal to those of another.

fn eq_by<I, F>(self, other: I, eq: F) -> bool

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_order_by)

Determines if the elements of this Iterator are equal to those of another with respect to the specified equality function.

fn ne<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are not equal to those of another.

fn lt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less than those of another.

fn le<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less or equal to those of another.

fn gt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than those of another.

fn ge<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than or equal to those of another.

fn is_sorted(self) -> bool

where Self: Sized, Self::Item: PartialOrd,

Checks if the elements of this iterator are sorted.

fn is_sorted_by<F>(self, compare: F) -> bool

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> bool,

Checks if the elements of this iterator are sorted using the given comparator function.

fn is_sorted_by_key<F, K>(self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd,

Checks if the elements of this iterator are sorted using the given key extraction function.

impl Not for BitBoard

Implements the Not trait for BitBoard, allowing the bitwise NOT operation !. The bitwise NOT flips all bits in the BitBoard, effectively inverting the board state.

type Output = BitBoard

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for BitBoard

fn eq(&self, other: &BitBoard) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for BitBoard

fn partial_cmp(&self, other: &BitBoard) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for BitBoard

impl Eq for BitBoard

impl StructuralPartialEq for BitBoard