Enum San

pub enum San {
    Normal {
        role: Role,
        file: Option<File>,
        rank: Option<Rank>,
        capture: bool,
        to: Square,
        promotion: Option<Role>,
    },
    Castle(CastlingSide),
    Put {
        role: Role,
        to: Square,
    },
    Null,
}

A move in Standard Algebraic Notation.

Variants

Normal

Fields

role: Role

file: Option<File>

rank: Option<Rank>

capture: bool

to: Square

promotion: Option<Role>

Castle(CastlingSide)

Put

Fields

role: Role

to: Square

Null

Implementations

impl San

pub fn from_ascii(san: &[u8]) -> Result<San, ParseSanError>

Parses a SAN. Ignores a possible check or checkmate suffix.

Errors

Returns ParseSanError if san is not syntactically valid.

pub fn from_move<P>(pos: &P, m: Move) -> San

where P: Position,

Converts a move to Standard Algebraic Notation.

pub fn to_move<P>(self, pos: &P) -> Result<Move, SanError>

where P: Position,

Tries to convert the San to a legal move in the context of a position.

Errors

Returns SanError if there is no unique matching legal move.

pub fn disambiguate( m: Move, moves: &ArrayVec<Move, shakmaty::::m::MoveList::{constant#0}>, ) -> San

pub fn find_move( self, moves: &ArrayVec<Move, shakmaty::::m::MoveList::{constant#0}>, ) -> Result<&Move, SanError>

Searches a MoveList for a unique matching move.

Errors

Returns SanError if there is no unique matching legal move.

pub fn matches(self, m: Move) -> bool

Test if the San can match the Move (in any position).

Examples

use shakmaty::{Square, Role, Move, san::San};

let m = Move::Normal {
    role: Role::Knight,
    from: Square::G1,
    to: Square::F3,
    capture: None,
    promotion: None,
};

let nf3 = San::from_ascii(b"Nf3")?;
assert!(nf3.matches(m));

let ng1f3 = San::from_ascii(b"Ng1f3")?;
assert!(ng1f3.matches(m));

// capture does not match
let nxf3 = San::from_ascii(b"Nxf3")?;
assert!(!nxf3.matches(m));

// other file does not match
let nef3 = San::from_ascii(b"Nef3")?;
assert!(!nef3.matches(m));

pub fn append_to_string(self, s: &mut String)

pub fn append_ascii_to(self, buf: &mut Vec<u8>)

Trait Implementations

impl Clone for San

fn clone(&self) -> San

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for San

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

Formats the value using the given formatter.

impl Display for San

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

Formats the value using the given formatter.

impl FromStr for San

type Err = ParseSanError

The associated error which can be returned from parsing.

fn from_str(san: &str) -> Result<San, ParseSanError>

Parses a string s to return a value of this type.

impl Hash for San

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

where __H: Hasher,

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 PartialEq for San

fn eq(&self, other: &San) -> 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 Copy for San

impl Eq for San

impl StructuralPartialEq for San