Enum Turn

pub enum Turn {
    Castling(Castling),
    Move(Move),
}

Struct representation of a string formatted chess turn

Turn can be either Move or Castling turn.

Example for Move

use chess_notation_parser::{Turn, Move, Square, Piece, Flag};

let turn = Turn::Move(
    Move {
        who: Piece::Queen,
        dst: Square::D7,
        flags: Flag::NONE,
        src: None,
        promotion: None,
    }
);
assert_eq!(turn, Turn::try_from("Qd7").unwrap());

// Turn::Move can be created with macro
use chess_notation_parser::turn_move;
let turn = turn_move!(Piece::Bishop, Square::C4);
assert_eq!(turn, Turn::try_from("Bc4").unwrap());

let turn = turn_move!(
    Piece::King,
    Square::D5,
    Flag::CAPTURE,
    Some(vec![Square::E3])
);
assert_eq!(turn, Turn::try_from("Ke3xd5").unwrap());

Example for Castling

use chess_notation_parser::{Turn, Castling, CastlingType, Flag};
use chess_notation_parser::turn_castling;

let turn = turn_castling!(
    CastlingType::Long,
    Flag::NONE
);

assert_eq!(turn, Turn::try_from("0-0-0").unwrap());

Variants

Castling(Castling)

Move(Move)

Implementations

impl Turn

pub fn is_check(&self) -> bool

Check if Turn results in check

pub fn is_checkmate(&self) -> bool

Check if Turn results in checkmate

pub fn is_capture(&self) -> bool

Check if Turn results in capture of opponent’s piece

Trait Implementations

impl Clone for Turn

fn clone(&self) -> Turn

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Turn

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

Formats the value using the given formatter.

impl Display for Turn

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

Formats the value using the given formatter.

impl PartialEq for Turn

fn eq(&self, other: &Turn) -> 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 TryFrom<&str> for Turn

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(turn: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl StructuralPartialEq for Turn