Struct parol::grammar::production::Pr

pub struct Pr(pub Symbol, pub Rhs, pub ProductionAttribute);

Production type

Tuple Fields

0: Symbol

1: Rhs

2: ProductionAttribute

Implementations

impl Pr

pub fn new(n: &str, r: Rhs) -> Self

Creates a new item from a non-terminal name and a Rhs

pub fn get_n(&self) -> String

Returns a clone of the non-terminal

pub fn get_n_str(&self) -> &str

Returns a reference of the non-terminal

pub fn get_r(&self) -> &Rhs

Returns a reference of the ride-hand side

pub fn take(self) -> (String, Rhs, ProductionAttribute)

Extracts the members of self while consuming self

pub fn set_n(&mut self, n: String)

Sets the non-terminal

pub fn is_empty(&self) -> bool

Checks if Rhs is empty

pub fn len(&self) -> usize

Returns the length of Rhs

pub fn effective_len(&self) -> usize

Returns the length of Rhs while counting only parser relevant symbols

pub fn format<R, S>( &self, scanner_state_resolver: &R, user_type_resolver: &S ) -> Result<String>

where R: Fn(&[usize]) -> String, S: Fn(&str) -> Option<String>,

Formats self with the help of a scanner state resolver

Trait Implementations

impl Clone for Pr

fn clone(&self) -> Pr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Pr

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

Formats the value using the given formatter.

impl Default for Pr

fn default() -> Self

Returns the “default value” for a type.

impl Display for Pr

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

The output format for a production roughly follows the Yacc format.

use parol::{Pr, Symbol, SymbolAttribute, Terminal, TerminalKind};

macro_rules! terminal {
    ($term:literal) => {Symbol::T(Terminal::Trm($term.to_string(), TerminalKind::Legacy,
        vec![0], SymbolAttribute::None, None))};
}

let pr = Pr::new("S", vec![]);
assert_eq!("S: ;", format!("{}", pr));
let pr = Pr::new("S", vec![Symbol::n("N"), Symbol::n("L")]);
assert_eq!("S: N L;", format!("{}", pr));
let pr = Pr::new("S", vec![Symbol::n("I"), Symbol::n("L")]);
assert_eq!("S: I L;", format!("{}", pr));
let pr = Pr::new("S", vec![terminal!(","), Symbol::n("N")]);
assert_eq!(r#"S: "," N;"#, format!("{}", pr));
let pr = Pr::new("S", vec![terminal!("d")]);
assert_eq!(r#"S: "d";"#, format!("{}", pr));
let pr = Pr::new("S", vec![terminal!(r#"[0-9]"#), terminal!("e")]);
assert_eq!(r#"S: "[0-9]" "e";"#, format!("{}", pr));

impl Hash for Pr

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 Ord for Pr

fn cmp(&self, other: &Pr) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Pr

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Pr

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Eq for Pr

impl StructuralPartialEq for Pr