Enum DeducerEnum

pub enum DeducerEnum {
    Str(StrDeducer),
    Simple(SimpleDeducer),
    List(ListDeducer),
    Int(IntDeducer),
}

Represents different deduction strategy implementations for string synthesis problems.

Encapsulates three variants to handle distinct deduction approaches: one variant specializes in string-specific deduction, another provides a baseline for basic deduction, and the third addresses deduction tasks for lists of strings. Each variant is annotated to facilitate formatted debugging output.

Variants

Str(StrDeducer)

Simple(SimpleDeducer)

List(ListDeducer)

Int(IntDeducer)

Implementations

impl DeducerEnum

pub fn from_nt(cfg: &Cfg, ctx: &Context, nt: usize) -> Self

Creates an instance of a deduction strategy based on the grammar configuration, context, and non-terminal index.

Selects a deduction approach by first checking whether deduction is disabled in the configuration and then matching on the non-terminal’s type. For string types, it initializes a strategy that fine-tunes parameters such as splitting operations, conditional (ite) concatenation, and join operations based on specific production rules; it also sets a decay rate and appends formatters retrieved from the grammar. For list-of-string types, it configures an alternative strategy that conditionally leverages a modified grammar when a list mapping operation is present. In all other cases, it falls back to a simple deduction strategy.

Trait Implementations

impl Debug for DeducerEnum

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

Formats the value using the given formatter.

impl Deducer for DeducerEnum

async fn deduce( &'static self, exec: &'static Executor, problem: Problem, ) -> &'static Expr

Asynchronously deduces an expression for a given synthesis subproblem using the appropriate deduction strategy based on the problem type.

This method first checks if the solution for the subproblem is pending in the executor’s cache. If it is, the method awaits and returns the pending result; otherwise, it delegates the deduction task to the underlying strategy implementation corresponding to the subproblem’s type. After obtaining the result, it logs the solved subproblem and records the expression back into the executor’s cache for future reuse.