Struct redfa::derivatives::Derivatives

pub struct Derivatives<T, R> {
    pub d: Vec<(Vec<T>, R)>,
    pub rest: R,
}

The set of some object’s derivatives with respect to an alphabet T.

Fields

d: Vec<(Vec<T>, R)>

Holds a set of pairs (chars, derivative), meaning that the derivative with respect to any element of chars is derivative.

rest: R

The derivative with respect to any character not listed in d.

Implementations

impl<T, R> Derivatives<T, R>

pub fn map<F: FnMut(R) -> R>(self, f: F) -> Derivatives<T, R>

Examples found in repository

examples/test.rs (line 15)

fn main() {
    let stdin = std::io::stdin();
    for line in stdin.lock().lines() {
        let line = line.unwrap();
        match line.trim().parse::<Regex<char>>() {
            Err(e) => println!("error: {}", e),
            Ok(x) => {
                println!("ok: {:?}", x);
                let x = x.normalize();
                println!("{:?}", x);
                println!("{:?}", x.derivative().map(Normalize::normalize));
                let (dfa, _mapping) = Dfa::from_derivatives(vec![x, Regex::Null]);
                let dfa = dfa.map(|reg| reg.nullable());
                println!("DFA: {:?}\n", dfa);
                let mdfa = dfa.minimize().map(|x| *x);
                println!("Minimized DFA: {:?}\n", mdfa);
                println!("dfa == mdfa: {:?}\n", dfa == mdfa);
            }
        }
    }
}

Trait Implementations

impl<T: Clone, R: Clone> Clone for Derivatives<T, R>

fn clone(&self) -> Derivatives<T, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, R: Debug> Debug for Derivatives<T, R>

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

Formats the value using the given formatter.