Modules
Macros
A macro to easily create a
Language.this macros defines two lazy static variables PRIMS and FUNCS
this macro is used at the start of a DSL function to load arguments out of their args vec
this macro is used at the start of a DSL function to load arguments out of their args vec
Make a test function
Structs
A simple
CostFunction that counts maximum ast depth.A simple
CostFunction that counts total ast size.A
RewriteScheduler that implements exponentional rule backoff.A
Condition that checks if two terms are equivalent.Wraps a DSL function in a struct that manages currying of the arguments
which are fed in one at a time through .apply(). Example: the “+” primitive
evaluates to a CurriedFn with arity 2 and empty partial_args. The expression
(app + 3) evals to a CurriedFn with vec![3] as the partial_args. The expression
(app (app + 3) 4) will evaluate to 7 (since .apply() will fill the last argument,
notice that all arguments are filled, and return the result).
Result of
Analysis::merge indicating which of the inputs
are different from the merged result.An equivalence class of enodes.
A data structure to keep track of equalities between expressions.
A data structure representing an explanation that two terms are equivalent.
An untyped lambda calculus expression, much like
egg::RecExpr but with a public nodes field
and many attached functions. See Lambda for details on the individual nodes.A single term in an flattened explanation.
After the first term in a
FlatExplanation, each term
will be annotated with exactly one backward_rule or one
forward_rule. This can appear in children FlatTerms,
indicating that the child is being rewritten.A generic error for failing to parse an operator. This is the error type
used by
define_language! for FromOp::Error, and is a sensible choice
when implementing FromOp manually.the cost of a program, where
app and lam cost 1, programs costs nothing,
ivar and var and prim cost 100.depth of a program. For example a leaf is depth 1.
A rewrite that searches for the lefthand side and applies the righthand side.
The result of searching a
Searcher over one eclass.A very simple
RewriteScheduler that runs every rewrite every
time.An interned string.
A simple language used for testing.
An explanation for a term and its equivalent children.
Each child is a proof transforming the initial child into the final child term.
The initial term is given by taking each first sub-term
in each
child_proofs recursivly.
The final term is given by all of the final terms in each child_proofs.Enums
The language of
Patterns.A node of an untyped lambda calculus expression compatible with
egg but also used more widely throughout this crate.
Note that there is no domain associated with this object. This makes it easy to run compression on
domains that don’t have semantics yet, makes it easy to add new prims (eg learned functions), etc.
You’ll have to specify a domain when you execute the expression, type check it, etc, but you can easily do
that at the time through generics on those functions.An error type for failures when attempting to parse an s-expression as a
RecExpr<L>.Error returned by
Runner when it stops.int
[Term(“int”,None)]
a value can either be some domain specific value Dom(D) like an Int,
or it can be a primitive function or partially applied primitive function like + or (+ 2)
or it can be a lambda function with some captured env like (lam (* $1 $0)) where $1 may have been captured from
the surrounding code and this whole object may now be passed around
Constants
Traits
A condition to check in a
ConditionalApplier.A cost function that can be used by an
Extractor.The key trait that defines a domain
A trait for parsing e-nodes. This is implemented automatically by
define_language!.A marker that defines acceptable children types for
define_language!.Functions
convenience function for equality assertions
convenience function for asserting that something executes to what you’d expect
A utility for implementing
Analysis::merge
when the Data type has a total ordering.
This will take the maximum of the two values.A utility for implementing
Analysis::merge
when the Data type has a total ordering.
This will take the minimum of the two values.convenience function for returning arguments from a DSL function
Type Definitions
env[i] is the value at $i
FlatExplanation are the simpler, expanded representation
showing one term being rewritten to another.
Each step contains a full
FlatTerm. Each flat term
is connected to the previous by exactly one rewrite.Explanation trees are the compact representation showing
how one term can be rewritten to another.