Struct liblet::symbol::Symbol

pub struct Symbol { /* fields omitted */ }

The main type of this module. It provides abstraction over symbols. Great to work with correct dataset when dealing with grammars and productions, or similar.

A Symbol can be made of every ascii-graphic chars, like the one described in rust documentation for chars ascii_graphic method, which accept chars going from U+0021 '!' ..= U+007E '~', including 'ε', the "empty word" symbol.

Symbols can be logically divided in 2 major categories, defined as follow:

• non terminals, which start with an uppercase letter (A-Z)
• terminals, which start with everything else

Checking if a symbol is terminal or non terminal can be done using the according boolean methods you can find below.

A symbol can be created easily from strings, following these rules:

• string can contain any number of whitespace
• string has to contain at least one valid char (see above)
• string can't contain anything else

It also implements the IntoIterator to iterate over the collection of chars which make up the Symbol.

Implementations

impl Symbol

pub fn new(string: &str) -> Result<Symbol, SymbolError>

Creates a new Symbol based on the chars in the input.

Errors

It can return an error if the input is empty or contains invalid chars.

Examples

use liblet::symbol::Symbol;

// create a new symbol based from the string "mysymbol"
let symbol = Symbol::new("mysymbol");

assert!(symbol.is_ok());

pub fn as_str(&self) -> &str

Return the &str representing this symbol chars.

Examples

use liblet::symbol::Symbol;

// create a new symbol based from the string "mysymbol"
let symbol = Symbol::new("mysymbol")?;

assert_eq!(symbol.as_str(), "mysymbol");

pub fn to_string(&self) -> String

Return the String representing this symbol chars.

Examples

use liblet::symbol::Symbol;

// create a new symbol based from the string "mysymbol"
let symbol = Symbol::new("mysymbol")?;

assert_eq!(symbol.to_string(), String::from("mysymbol"));

pub fn is_terminal(&self) -> bool

Check if symbol is terminal. You can expect the call to is_non_terminal to return an opposite result.

true if symbol is terminal, false otherwise

Examples

use liblet::symbol::Symbol;

// create a new symbol based from the string "mysymbol"
let symbol = Symbol::new("mysymbol").unwrap();

assert!(symbol.is_terminal());
assert!(!symbol.is_non_terminal());

pub fn is_non_terminal(&self) -> bool

Check if symbol is non terminal. You can expect the call to is_terminal to return an opposite result.

true if symbol is non terminal, false otherwise

Examples

use liblet::symbol::Symbol;

// create a new symbol based from the string "Mysymbol"
let symbol = Symbol::new("Mysymbol")?;

assert!(symbol.is_non_terminal());
assert!(!symbol.is_terminal());

pub fn is_valid_char(c: &char) -> bool

Check if char is a valid symbol char. true if char is a valid symbol char, false otherwise

Examples

use liblet::symbol::Symbol;

assert!(Symbol::is_valid_char(&'c'));
assert!(!Symbol::is_valid_char(&'\n'));

pub fn is_valid_symbol(string: &str) -> bool

Check if a string is a valid symbol. true if the string is a valid symbol, false otherwise

Examples

use liblet::symbol::Symbol;

assert!(Symbol::is_valid_symbol("A"));
assert!(!Symbol::is_valid_symbol("\n"));

pub fn from_string(string: &str) -> Result<Vec<Symbol>, SymbolError>

Create a collection of symbols from a raw input string.

Errors

Can return an error if the raw string can't be parsed to obtain actual symbols both due to wrong string formatting (symbols should be contiguous chars separated between them by every kind of whitespace) and due to symbol creation error (invalid char, empty symbol, etc.).

In the case an empty or whitespace only string is given, it just returns an empty collection of symbols.

Examples

use liblet::symbol::Symbol;

let result = Symbol::from_string("A B C")?;

assert_eq!(result.len(), 3);

pub fn epsilon() -> Symbol

Return a new symbol which represents the empty symbol 'ε'.

Examples

use liblet::symbol::Symbol;

let symbol = Symbol::epsilon();

assert_eq!(symbol.to_string(), "ε");

pub fn is_epsilon(&self) -> bool

Check if a symbol is the empty symbol ε.

Return true if it is, false otherwise.

Examples

use liblet::symbol::{Symbol,symbol};

let symbol_epsilon = Symbol::epsilon();
let symbol_other = symbol("A");

assert!(symbol_epsilon.is_epsilon());
assert!(!symbol_other.is_epsilon());

Trait Implementations

impl Clone for Symbol

fn clone(&self) -> Symbol

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Symbol

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Symbol

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for Symbol

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

Formats the value using the given formatter.

impl Eq for Symbol

impl Hash for Symbol

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, 

Feeds a slice of this type into the given [Hasher].

impl<'a> IntoIterator for &'a Symbol

type Item = char

The type of the elements being iterated over.

type IntoIter = Chars<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Ord for Symbol

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

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialEq<Symbol> for Symbol

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

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

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

This method tests for !=.

impl PartialOrd<Symbol> for Symbol

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

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

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

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

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

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

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

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

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

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

impl Serialize for Symbol

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralEq for Symbol

impl StructuralPartialEq for Symbol

impl<'_> TryFrom<&'_ str> for Symbol

type Error = SymbolError

The type returned in the event of a conversion error.

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

Performs the conversion.