Struct BoardChildrenIterator

pub struct BoardChildrenIterator<'a, B: Board> { /* private fields */ }

Implementations

impl<'a, B: Board> BoardChildrenIterator<'a, B>

pub fn new(board: &'a B) -> Result<Self, BoardDone>

Trait Implementations

impl<'a, B: Board> Clone for BoardChildrenIterator<'a, B>

where <B as BoardMoves<'a, B>>::AvailableMovesIterator: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, B: Board> Debug for BoardChildrenIterator<'a, B>

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

Formats the value using the given formatter.

impl<'a, B: Board> InternalIterator for BoardChildrenIterator<'a, B>

type Item = (<B as Board>::Move, B)

Type of items yielded by the iterator.

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

where F: FnMut(Self::Item) -> ControlFlow<R>,

Applies function each elements of the iterator. Stops early if the function returns ControlFlow::Break.

fn find_map<R, F>(self, f: F) -> Option<R>

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

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

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

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

Tests if every element of the iterator matches the predicate.

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

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

Tests if any element of the iterator matches the predicate.

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

where U: IntoInternalIterator<Item = Self::Item>,

Takes two iterators and returns an iterator that first iterates over the elements of the first iterator, and then over the second one.

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

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

Creates an iterator yields cloned elements of the original iterator.

fn collect<B>(self) -> B

where B: FromInternalIterator<Self::Item>,

Transforms the iterator into a collection.

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

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

Creates an iterator yields copied elements of the original iterator.

fn count(self) -> usize

Returns the number of elements yielded by the iterator.

fn enumerate(self) -> Enumerate<Self>

Creates an iterator that adds the index to every value of the original iterator.

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

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

Creates an iterator which only yields elements matching the predicate.

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

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

A combination of InternalIterator::filter and InternalIterator::map.

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

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

Returns the first element of the iterator that matches the predicate.

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

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

Creates and iterator which maps over the elements and flattens the resulting structure.

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

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

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

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

where F: FnMut(Self::Item),

Run the closure on each element.

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

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

Run the closure on each element, while passing that element on.

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

Returns the last element.

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

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

Transform each element in the iterator.

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

where Self::Item: Ord,

Returns the maximum element of an iterator.

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

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

Returns the maximum element of an iterator using a custom comparer function.

fn max_by_key<B>(self, key: impl FnMut(&Self::Item) -> B) -> Option<Self::Item>

where B: Ord,

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

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

where Self::Item: Ord,

Returns the minimum element of an iterator.

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

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

Returns the minimum element of an iterator using a custom comparer function.

fn min_by_key<B>(self, key: impl FnMut(&Self::Item) -> B) -> Option<Self::Item>

where B: Ord,

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

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

Returns the first element of the iterator.

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

Returns the nth element of the iterator.

fn position<F>(self, f: F) -> Option<usize>

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

Returns the index of the first element matching the predicate.

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

Skip first n elements of the iterator.

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

Take first n elements of the iterator, disregarding the rest.