Struct BestProgram

pub struct BestProgram<C> { /* private fields */ }

Implementations

impl<C> BestProgram<C>

pub fn new(cost_fn: C, root: Id) -> Self

where C: Clone + 'static,

pub fn new_with(cost_fn: impl Fn() -> C + 'static, root: Id) -> Self

Examples found in repository

examples/simple.rs (line 63)

fn simplify_with(
    s: &str,
    scheduler: impl RewriteScheduler<SimpleLanguage, ()> + 'static,
    path: impl AsRef<Path>,
) {
    // parse the expression, the type annotation tells it which Language to use
    let expr: RecExpr<SimpleLanguage> = s.parse().unwrap();

    let mut egraph = EGraph::new(());
    let root = egraph.add_expr(&expr);

    // simplify the expression using a Runner, which creates an e-graph with
    // the given expression and runs the given rules over it
    Runner::default()
        .with_scheduler(
            LoggingScheduler::from(scheduler)
                .with_out_file(
                    OpenOptions::new()
                        .write(true)
                        .create(true)
                        .truncate(true)
                        .open(path.as_ref())
                        .unwrap(),
                )
                .with_logging_enabled(true)
                .with_recorder(recorders::Timestamp::new(Instant::now()))
                .with_recorder(recorders::NumberENodes)
                .with_recorder(recorders::NumberEClasses)
                .with_recorder(recorders::BestProgram::new_with(|| AstSize, root)),
        )
        .with_egraph(egraph)
        .run(&make_rules());

    println!("Wrote {:?}", path.as_ref());
}

pub fn with_rebuild(self, rebuild: bool) -> Self

Trait Implementations

impl<L, N, C> Recorder<L, N> for BestProgram<C>

where L: Language, N: Analysis<L>, C: CostFunction<L>, <C as CostFunction<L>>::Cost: Display,

fn identifier(&self) -> Cow<'static, str>

fn record_before_rewrite( &self, _iteration: usize, egraph: &mut EGraph<L, N>, _rewrite: &Rewrite<L, N>, _matches: &[SearchMatches<'_, L>], ) -> Option<String>

fn record_after_rewrite( &self, _iteration: usize, egraph: &mut EGraph<L, N>, _rewrite: &Rewrite<L, N>, _n_matches: usize, ) -> Option<String>

fn record_before_search<'r>( &self, iteration: usize, egraph: &'r EGraph<L, N>, rewrite: &'r Rewrite<L, N>, ) -> Option<String>

fn record_after_search<'r>( &self, iteration: usize, egraph: &'r EGraph<L, N>, rewrite: &'r Rewrite<L, N>, matches: &[SearchMatches<'_, L>], ) -> Option<String>