## 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 `FlatTerm`

s,
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

`Pattern`

s.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.