Trait egg::Language [−][src]
pub trait Language: Debug + Clone + Eq + Ord + Hash {
Show 14 methods
fn matches(&self, other: &Self) -> bool;
fn children(&self) -> &[Id]ⓘ;
fn children_mut(&mut self) -> &mut [Id]ⓘ;
fn for_each<F: FnMut(Id)>(&self, f: F) { ... }
fn for_each_mut<F: FnMut(&mut Id)>(&mut self, f: F) { ... }
fn try_for_each<E, F>(&self, f: F) -> Result<(), E>
where
F: FnMut(Id) -> Result<(), E>,
E: Clone,
{ ... }
fn len(&self) -> usize { ... }
fn is_leaf(&self) -> bool { ... }
fn update_children<F: FnMut(Id) -> Id>(&mut self, f: F) { ... }
fn map_children<F: FnMut(Id) -> Id>(self, f: F) -> Self { ... }
fn fold<F, T>(&self, init: T, f: F) -> T
where
F: FnMut(T, Id) -> T,
T: Clone,
{ ... }
fn all<F: FnMut(Id) -> bool>(&self, f: F) -> bool { ... }
fn any<F: FnMut(Id) -> bool>(&self, f: F) -> bool { ... }
fn to_recexpr<'a, F>(&self, child_recexpr: F) -> RecExpr<Self>
where
Self: 'a,
F: FnMut(Id) -> &'a [Self],
{ ... }
}
Expand description
Trait that defines a Language whose terms will be in the EGraph
.
Check out the define_language!
macro for an easy way to create
a Language
.
If you want to pretty-print expressions, you should implement Display
to
display the language node’s operator. For example, a language node
Add([Id; 2])
might be displayed as “+”.
To parse expressions from strings you should also implement FromOp
.
The define_language!
macro automatically implements both Display
and
FromOp
.
See SymbolLang
for quick-and-dirty use cases.
Required methods
Returns true if this enode matches another enode.
This should only consider the operator, not the children Id
s.
Returns the children of this e-node.
Provided methods
fn for_each_mut<F: FnMut(&mut Id)>(&mut self, f: F)
fn for_each_mut<F: FnMut(&mut Id)>(&mut self, f: F)
Runs a given function on each child Id
, allowing mutation of that Id
.
Runs a falliable function on each child, stopping if the function returns an error.
Returns the number of the children this enode has.
The default implementation uses fold
to accumulate the number of
children.
fn update_children<F: FnMut(Id) -> Id>(&mut self, f: F)
fn update_children<F: FnMut(Id) -> Id>(&mut self, f: F)
Runs a given function to replace the children.
fn map_children<F: FnMut(Id) -> Id>(self, f: F) -> Self
fn map_children<F: FnMut(Id) -> Id>(self, f: F) -> Self
Creates a new enode with children determined by the given function.
Folds over the children, given an initial accumulator.
Returns true if the predicate is true on all children. Does not short circuit.
Returns true if the predicate is true on any children. Does not short circuit.
fn to_recexpr<'a, F>(&self, child_recexpr: F) -> RecExpr<Self> where
Self: 'a,
F: FnMut(Id) -> &'a [Self],
fn to_recexpr<'a, F>(&self, child_recexpr: F) -> RecExpr<Self> where
Self: 'a,
F: FnMut(Id) -> &'a [Self],
Make a RecExpr
converting this enodes children to RecExpr
s
Example
let a_plus_2: RecExpr<SymbolLang> = "(+ a 2)".parse().unwrap();
// here's an enode with some meaningless child ids
let enode = SymbolLang::new("*", vec![Id::from(0), Id::from(0)]);
// make a new recexpr, replacing enode's children with a_plus_2
let recexpr = enode.to_recexpr(|_id| a_plus_2.as_ref());
assert_eq!(recexpr, "(* (+ a 2) (+ a 2))".parse().unwrap())