Alias for eval->val.

Alias for eval->val-all.

Alias for eval->expr.

Alias for eval->expr-all.

Alias for simplify.

FIXME: write docs

Obsolete → use nested-l>> or nested-r>> instead!

Defines a new operator by its symbol (a keyword), a vector of arguments and an interpretation function. Takes additional key-value pairs for options.

Registers various methods for the operator:

• interpret-op (use interpret) to access the interpretation function
• make-op (use make) → constructor (either uses the provided args or a custom constructor function via the option :constructor)
• simplify-op (use simplify) → simplifier (either defaults to the given interpretation function or uses a custom reducer via the option :reducer)
• valid-op? → validator (provided by the :predicate option)
• op-data → returns a key-value map of the operator arguments
• op-get → returns a specific value by a given argument-key

Defines a new expression symbol by its symbol (a keyword) and an interpretation function. Takes additional key-value pairs for options.

Registers various methods for the expression symbol:

• interpret-sym (use interpret) → to access the interpretation function
• simplify-sym (use simplify) → simplifier (either defaults to the given interpretation function or uses a custom reducer via the option :reducer)

Equality check for expressions. Two expressions are considered equal, if their formDNAs are equal. Compares formDNAs from evaluation results of each expression by calling calc/equal-dna?.

WARNING: Procedure and assumptions are being reassessed. Use with caution!

• ordering of variable names in formDNA matters, see find-vars
• stricter than equiv, which compares by calc/equiv-dna?

Equivalence check for expressions. Two expressions are considered equivalent, if their formDNAs are equivalent. Compares formDNAs from evaluation results of each expression by calling calc/equiv-dna?.

WARNING: Procedure and assumptions are being reassessed. Use with caution!

• ordering of variable names in formDNA is irrelevant
• looser than equal, which compares by calc/equal-dna?
• can be slow on expressions with 6+ variables

Evaluates a FORM expr with an optional env and returns an expression: either a constant or the simplified input expression, if it could not be determined to a value.

• env must be a map from variables to expressions

Like eval->expr, but evaluates all possible interpretations of any occurring variable in the expr. Returns an expression: either a constant, a formDNA expression (which collects all interpretation results) or the simplified input expression, if it could not be determined to a value in any of its interpretations.
* env must be a map from variables to expressions

An opts map can be provided with the following keys:

• :varorder → sets the variable interpretation order for the resulting formDNA
• :pre-simplify? → (default: true) simplifies the expression before interpretation, which might reduce terms and therefore evaluation time
• :reduce-dna? → (default: true) if result is a formDNA expression which can be reduced to fewer terms, reduces it to further simplify the output
• :allow-hole-results? → (default: false) sets a “value hole” (:_) in place of an uninterpretable result
• :allow-hole-exprs? → (default: false) allows “value holes” (:_) in the input expression (each instance will be treated like a different variable)

Evaluates a FORM expr with an optional env and returns a value: either a constant or a “value hole” :_ (in case a value cannot be determined, which usually happens when variables remain uninterpreted).

• env must be a map from variables to expressions

Like eval->val, but evaluates all possible interpretations of any occurring variable in the expr. Returns a complex value called formDNA, which collects all interpretation results.

• env must be a map from variables to expressions

Note: interpretation results might (in very rare cases) include “value holes” :_, if a value cannot be determined. This applies to unregistered symbols (like :pie) or uninterpretable results from custom, user-defined operators. To avoid holes, wrap them in unclear FORMs, e.g. (make :uncl :pie).

An opts map can be provided with the following keys:

• :varorder → sets the variable interpretation order for the resulting formDNA
• :pre-simplify? → (default: false) simplifies the expression before interpretation, which might reduce terms and therefore evaluation time
• :reduce-dna? → (default: false) if result is a formDNA expression which can be reduced to fewer terms, reduces it to further simplify the output
• :allow-hole-exprs? → (default: false) allows “value holes” (:_) in the input expression (each instance will be treated like a different variable)

Like evaluate, but evaluates all possible interpretations of any occurring variable in the expr, with an optional env.
* env must be a map from variables to expressions

Returns a map with the following entries:

• :results → vector of [<interpretation> <result>] tuples (with result like in evaluate), think of it as a kind of value table
• :varorder → the reading order of variable interpretations

An opts map can be provided with the following keys:

• :varorder → sets the variable interpretation order for the results
• :rich-results? → each results value will be a map as if returned by evaluate
• :pre-simplify? → (default: false) simplifies the expression before interpretation, which might reduce terms and therefore evaluation time
• :allow-hole-results? → (default: false) sets a “value hole” (:_) in place of nil for an uninterpretable result
• :allow-hole-exprs? → (default: false) allows “value holes” (:_) in the input expression (each instance will be treated like a different variable)

Convenience function that takes a 6-digit binary selection (as a vector) for a triple-selective decision system (TsDS) and returns the formDNA for the (as by eval->val-all) evaluated expression.

Note: contrary to eval->val-all, the resulting formDNA does not get reduced.

Evaluates a FORM expr with an optional env and returns a map with a :result entry that is either a constant or nil, if it could not be determined to a value. It also contains a :simplified entry with the simplified expression.
* env must be a map from variables to expressions

Returns the constant value/expression that corresponds to its simplest (as per simplify) input expr (including itself):

nil                     → :n
[]                      → :m
[:seq-re :<r nil nil]   → :u
[[:seq-re :<r nil nil]] → :i
[:u]                    → :i

FIXME: write docs

FIXME: write docs

Finds all subexpressions in expr that match any element of the given set subexprs.

Finds all variables in an expresson or returns the expression itself if it is a variable.

Options:

• {:ordered true} to return variables in: type order → alphanumeric order
• {:vars #{…}} can be given a set of specific variables to find

Constructor for FORM expressions [ … ]. Calls make on args.

Returns a FORM with each exprs argument marked, e.g. ((a) (b) …).

• group expressions with arrangements: (make x y …)

Nests exprs leftwards in a FORM, e.g. ((((…) y) z).

• use nil for empty expressions
• use an arrangement (make x y …) to add multiple exprs. to the same level

Nests exprs rightwards in a FORM, e.g. (a (b (…))).

• use nil for empty expressions
• use an arrangement (make x y …) to add multiple exprs. to the same level

FIXME: write docs

Takes a formDNA expression and returns its formDNA perspective group.

FIXME: write docs

Generates a number of variables with random names.

Alias for simplify-in.

Interprets an expression of any kind. Returns the original expression if it cannot be interpreted.

Can be given an env map to interpret variables (as keys). This map can have an optional --defocus entry whose value is a set of items that should not be interpreted and a complementary --focus entry to only interpret the items specified in its set and nothing else.

• the keywords :ops / :syms / :vars designate all operations / expression symbols / variables
• an operator symbol can provided to designate a specific operator
• any other expression (like a variable) can be designated as itself
• --focus and --defocus can cancel each other out if they contain the same item so you usually pick one or the other

Like interpret, but repeats substitution on interpreted expressions until they cannot be interpreted any further.

Interprets a symbolic expression with a registered operator.

Note: default to use interpret instead

Interprets a registered symbol.

Note: default to use interpret instead

Recursively calls interpret on given expression and all its subexpressions with a depth-first walk.

Like interpret-walk, but repeats substitution on interpreted (sub-)expressions until they cannot be interpreted any further.

Given a constant, returns the corresponding FORM from the isolator class.

Constructor for expressions of any kind. Validates its input.

If the first argument (or the first after the options map) is a keyword of a registered operator, will call the constructor for that operator

Can be given an options map as first argument:

• mark? (default: false) marks the whole expression, creating a FORM
• splice? (default: true) dissolves all top-level arrangements

Returns an arrangement with each exprs argument marked, e.g. (a) (b) ….

• group expressions with arrangements: (make x y …)

Nests exprs leftwards in an arrangement, e.g. ((…) y) z.

• use nil for empty expressions
• use an arrangement (make x y …) to add multiple exprs. to the same level

Nests exprs rightwards in an arrangement, e.g. a (b (…)).

• use nil for empty expressions
• use an arrangement (make x y …) to add multiple exprs. to the same level

Constructs a symbolic expression given a registered operator and parameters.

Note: default to use make instead of make-op

Obsolete → use make-marked or form-marked instead.

Constructs a memory FORM from a given list of rem-pairs (key-value pairs, where both the key and the value is an expression) and one or more expressions which are in their scope.

Takes a memory FORM and extends its rem-pairs by one or more given extension pairs.

Takes a memory FORM and replaces its rem-pairs by one or more given replacement pairs.

FIXME: write docs

Obsolete → use make-nested-l/make-nested-r or form-nested-l/form-nested-r instead.

Alias for simplify-nested-l.

Alias for simplify-nested-r.

Gets all parameters from a symbolic expression with a registered operator as a map.

Gets a specified part from a symbolic expression with a registered operator.

Returns the symbol of a given operator.

FIXME: write docs

FIXME: write docs

Generates all permutations of a variable order (a sequence of variables).

FIXME: write docs

Given a map variable->constant, returns a FORM from the selector class.

Constructs a self-equivalent re-entry FORM given the arguments:

• specs: either a seq-reentry-signature or an options map
• nested-exprs: zero or more expressions intended as a nested sequence

Inverse map of seq-reentry-sign->opts with default args.

FIXME: write docs

Maps signatures for self-equivalent re-entry FORMs to their corresponding option-maps.

FIXME: write docs

FIXME: write docs

Simplifies a FORM recursively until it cannot be further simplified. All deductions are justified by the axioms of FORM logic.

• if no simplification applies, tries to retrieve the value from given env
• if retrieval was unsuccessful, returns x as is

An opts map can be provided with the following keys:

• :allow-hole-exprs? → (default: false) allows “value holes” (:_) in the input expression (each instance will be treated like a different variable)

Obsolete → use simplify-nested-l or simplify-nested-r instead!

Simplifies a context/sequence of FORMs recursively until it cannot be further simplified. All deductions are justified by the axioms of FORM logic.

An opts map can be provided with the following keys:

• :allow-hole-exprs? → (default: false) allows “value holes” (:_) in the input expression (each instance will be treated like a different variable)

Reduces a leftward nesting-chain, a sequence of expressions ( … x y z ) whose interpretation is ( [[[…] x] y] z ), to a simplified nesting chain, possibly spliced or shortened via inference.

• takes an optional env that gets applied to the nested expansion

An opts map can be provided with the following keys:

• :allow-hole-exprs? → (default: false) allows “value holes” (:_) in the input expression (each instance will be treated like a different variable)

Reduces a rightward nesting-chain, a sequence of expressions ( a b c … ) whose interpretation is ( a [b [c […]]] ), to a simplified nesting chain, possibly spliced or shortened via inference.

• takes an optional env that gets applied to the nested expansion

An opts map can be provided with the following keys:

• :allow-hole-exprs? → (default: false) allows “value holes” (:_) in the input expression (each instance will be treated like a different variable)

Alias for eval-tsds->val-all.

FIXME: write docs

Validates the shape of a symbolic expression with a registered operator.

FIXME: write docs