Trait FromOp 

pub trait FromOp: Language + Sized {
    type Error: Debug;

    // Required method
    fn from_op(op: &str, children: Vec<Id>) -> Result<Self, Self::Error>;
}

A trait for parsing e-nodes. This is implemented automatically by define_language!.

If a Language implements both Display and FromOp, the Display implementation should produce a string suitable for parsing by from_op:

fn from_op_display_compatible<T: FromOp + Display>(node: T) {
    let op = node.to_string();
    let mut children = Vec::new();
    node.for_each(|id| children.push(id));
    let parsed = T::from_op(&op, children).unwrap();

    assert_eq!(node, parsed);
}

Examples

define_language! implements FromOp and Display automatically:

define_language! {
    enum Calc {
       "+" = Add([Id; 2]),
       Num(i32),
    }
}

let add = Calc::Add([Id::from(0), Id::from(1)]);
let parsed = Calc::from_op("+", vec![Id::from(0), Id::from(1)]).unwrap();

assert_eq!(add.to_string(), "+");
assert_eq!(parsed, add);

Required Associated Types

type Error: Debug

The error type returned by from_op if its arguments do not represent a valid e-node.

Required Methods

fn from_op(op: &str, children: Vec<Id>) -> Result<Self, Self::Error>

Parse an e-node with operator op and children children.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl FromOp for SymbolLang

type Error = Infallible

impl<L: FromOp> FromOp for ENodeOrVar<L>

type Error = ENodeOrVarParseError<<L as FromOp>::Error>