Struct Moves 

pub struct Moves<'l> { /* private fields */ }

The list of all the legal moves on a position. It is returned by Position::legal_moves.

This type lies on the stack and has a fixed capacity of 218 moves, as there exists no reachable position with more legal moves¹.

---

1. In 1964, Nenad Petrović published a composition with 218 legal moves. 60 years later, this was proven to be optimal by Tobs40. Even though the Position type can represent some unreachable positions the proof still holds, as its definition of a position is even less restrictive. ↩

Implementations

impl<'l> Moves<'l>

pub fn position(&self) -> &'l Position

Returns the position on which the moves are played.

pub fn iter(&'l self) -> MovesIter<'l>

Iterates over the moves.

pub fn len(&self) -> usize

Returns the number of moves in the list.

pub fn is_empty(&self) -> bool

Returns true if there is no legal move on the position.

pub fn is_check(&self) -> bool

Returns true if the king is in check.

pub fn en_passant_is_legal(&self) -> bool

Returns true if taking en passant is legal on the position.

pub fn get(&self, index: usize) -> Option<Move<'l>>

Returns the move at the given index, if it exists.

pub fn sort(&mut self)

Sorts the list in ascending order.

pub fn sort_by<F>(&mut self, compare: F)

where F: for<'a> FnMut(Move<'a>, Move<'a>) -> Ordering,

Available on crate feature alloc only.

Sorts the list in ascending order with a comparison function, preserving initial order of equal elements.

See slice::sort_by for details.

pub fn sort_unstable_by<F>(&mut self, compare: F)

where F: for<'a> FnMut(Move<'a>, Move<'a>) -> Ordering,

Sorts the list in ascending order with a comparison function, without preserving the initial order of equal elements.

See slice::sort_unstable_by for details.

pub fn select_nth_unstable(&mut self, index: usize) -> Move<'l>

Reorders the slice such that the element at index is at a sort-order position.

See slice::select_nth_unstable for details.

pub fn select_nth_unstable_by<F>( &mut self, index: usize, compare: F, ) -> Move<'l>

where F: for<'a> FnMut(Move<'a>, Move<'a>) -> Ordering,

Reorders the slice with a comparator function such that the element at index is at a sort-order position.

See slice::select_nth_unstable_by for details.

Trait Implementations

impl<'l> Clone for Moves<'l>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'l> Debug for Moves<'l>

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

Formats the value using the given formatter.

impl<'l> IntoIterator for &'l Moves<'l>

type Item = Move<'l>

The type of the elements being iterated over.

type IntoIter = MovesIter<'l>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'l> IntoIterator for Moves<'l>

type Item = Move<'l>

The type of the elements being iterated over.

type IntoIter = MovesIntoIter<'l>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.