The ttt Reference Manual

This is the ttt Reference Manual, version 2.1.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed May 15 07:12:58 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

The main system appears first, followed by any subsystem dependency.


2.1 ttt

A language for transparent modifications of s-expression based trees.

Author

Adam Purtee and Gene Louis Kim <>

License

GPLv3

Version

2.1.0

Dependency

bordeaux-threads (system).

Source

ttt.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


3.1 Lisp


3.1.1 ttt/ttt.asd

Source

ttt.asd.

Parent Component

ttt (system).

ASDF Systems

ttt.


3.1.2 ttt/package.lisp

Source

ttt.asd.

Parent Component

ttt (system).

Packages

ttt.


3.1.3 ttt/types.lisp

Dependency

package.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Internals

tree-expr (type).


3.1.4 ttt/operators.lisp

Dependency

types.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Internals

3.1.5 ttt/expressions.lisp

Dependency

operators.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Internals

3.1.6 ttt/keys.lisp

Dependency

expressions.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Internals

3.1.7 ttt/bindings.lisp

Dependency

keys.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Internals

3.1.8 ttt/trees.lisp

Dependency

bindings.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Internals

3.1.9 ttt/patterns.lisp

Dependency

trees.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Public Interface

match-expr (function).

Internals

3.1.10 ttt/operators/unrestricted-seq.lisp

Dependency

patterns.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Internals

3.1.11 ttt/operators/restricted-seq.lisp

Dependency

operators/unrestricted-seq.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Internals

3.1.12 ttt/operators/fpseq-gen.lisp

Dependency

operators/restricted-seq.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Internals

3.1.13 ttt/operators/descendant.lisp

Dependency

operators/fpseq-gen.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Internals

3.1.14 ttt/operators/vertical.lisp

Dependency

operators/descendant.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Internals

3.1.15 ttt/operators/literal.lisp

Dependency

operators/vertical.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Internals

3.1.16 ttt/sticky.lisp

Dependency

operators/literal.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Internals

3.1.17 ttt/predicates.lisp

Dependency

sticky.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Public Interface

store-pred (function).

Internals

3.1.18 ttt/template-construction.lisp

Dependency

predicates.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Internals

3.1.19 ttt/transductions.lisp

Dependency

template-construction.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Public Interface
Internals

3.1.20 ttt/util.lisp

Dependency

transductions.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Public Interface
Internals

3.1.21 ttt/process-tb.lisp

Dependency

util.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Internals

process-tb (function).


3.1.22 ttt/search-tb.lisp

Dependency

process-tb.lisp (file).

Source

ttt.asd.

Parent Component

ttt (system).

Internals

search-tb (function).


4 Packages

Packages are listed by definition order.


4.1 ttt

the TTT (template to template transduction) package!

Source

package.lisp.

Use List

common-lisp.

Public Interface
Internals

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


5.1 Public Interface


5.1.1 Ordinary functions

Function: apply-rule (rule-expr tree-expr &key shallow trace max-n rule-depth)

Apply a single rule to a tree expression until converged.
Returns a new tree expression.

shallow limits rule applications to root of tree
max-n limits the maximum number of edits to a tree
trace when t, displays debugging info to stdout
otherwise, when non-nil write debugging info to file appending to the file if it already exists
format is (one triple of lines per transduction):
<tree before transduction>
<tree after transduction>
<blank line>

rule-depth
:default Rule application can occur at any depth, but only one match is returned at each step.
:shallow Rule application can only occur at the root of the tree. :deepest Rule application can occur at any depth, and all matches are returned at each step. Setting a rule-depth value is recommended when using this option to enable reasonable runtimes.

Package

ttt.

Source

transductions.lisp.

Function: apply-rules (rules tree-expr &key rule-order trace shallow deepest max-n rule-depth)

Apply each of the rules in list rules to a tree expression
until each rule is no longer applicable. The rules list is only processed once. Returns a new tree expression.

shallow limits rule applications to root of tree (alternative to using :rule-depth :shallow)
deepest allows multiple recursive matches into the tree at each step (alternative to using :rule-depth :deepest)
max-n limits the maximum number of edits to a tree
trace when t, displays debugging info to stdout
otherwise, when non-nil write debugging info to file appending to the file if it already exists

trace format is one 4-tuple of lines per transduction:
<rule expression>
<tree before transduction>
<tree after transduction>
<blank line>

rule-order
:slow-forward - apply each rule until that rule no longer
applies, possibly repeating the entire sequence :earliest-first - always apply the first rule in the list that
is applicable, repeat until no rules are applicable the rule list may be processed multiple times :fast-forward - apply each rule at most once, in order, repeating
the list until convergence

rule-depth
:default Rule application can occur at any depth, but only one match is returned at each step.
:shallow Rule application can only occur at the root of the tree. :deepest Rule application can occur at any depth, and all matches are returned at each step. Setting a rule-depth value is recommended when using this option to enable reasonable runtimes. This rule may only be used with rule-order :slow-forward. Behavior is undefined for other rule-order options.

Package

ttt.

Source

transductions.lisp.

Function: hide-ttt-ops (expr &optional all-pkg)
Package

ttt.

Source

util.lisp.

Function: match-expr (pattern-expr tree-expr &key bind-form)

Added because the suffix expr is more meaningful than encap.

Package

ttt.

Source

patterns.lisp.

Function: store-pred (symbol function)
Package

ttt.

Source

predicates.lisp.

Function: ttt-all-rule-results (rule tree)
Package

ttt.

Source

util.lisp.

Function: ttt-apply-rule-possibilities (rule tree &key max-per-tree min-per-tree)
Package

ttt.

Source

util.lisp.

Function: unhide-ttt-ops (expr &optional all-pkg)
Package

ttt.

Source

util.lisp.


5.2 Internals


5.2.1 Special variables

Special Variable: *built-patterns*
Package

ttt.

Source

patterns.lisp.

Special Variable: *invalid-suffix-chars*
Package

ttt.

Source

operators.lisp.

Special Variable: *next-int-lock*
Package

ttt.

Source

template-construction.lisp.

Special Variable: *operation-table*
Package

ttt.

Source

operators.lisp.

Special Variable: *operator-lock*
Package

ttt.

Source

operators.lisp.

Special Variable: *pattern-lock*
Package

ttt.

Source

patterns.lisp.

Special Variable: *predicate-lock*
Package

ttt.

Source

predicates.lisp.

Special Variable: *predicate-table*
Package

ttt.

Source

predicates.lisp.

Special Variable: *subst-new-next-int*
Package

ttt.

Source

template-construction.lisp.

Special Variable: *ttt-debug-level*
Package

ttt.

Source

patterns.lisp.


5.2.2 Ordinary functions

Function: add-binding (binding bindings)

Nondestructively add the binding to bindings.

Package

ttt.

Source

bindings.lisp.

Function: add-op (op &key predicate requires-args)

Insert op into the operation table. Associate the operation with match-fn. Optionally set predicate or requires-args booleans. (both default to nil)

Package

ttt.

Source

operators.lisp.

Function: add-to-index (key value idx)

add key/value pair to index. does not check for duplication of values. values may be stored in any order.

Package

ttt.

Source

keys.lisp.

Function: apply! (x &rest y)

Applies the first argument to the rest of the arguments. This is a syntactic shortcut to avoid defining duplicates of lisp functions, but with the names ending in ’!’.

Package

ttt.

Source

template-construction.lisp.

Function: bind-seq (binding)
Package

ttt.

Source

bindings.lisp.

Function: bind-var (binding)
Package

ttt.

Source

bindings.lisp.

Function: bound? (var bindings)

Return t if variable is bound, nil otherwise.

Package

ttt.

Source

bindings.lisp.

Function: build-pattern (expression)

Builds a pattern object according to expression.

Package

ttt.

Source

patterns.lisp.

Function: build-tree (expression &key root index-subtrees)

Convert a Lisp expression into a nodal tree.
This function should be optimized, because it will always be called once per tree expression to be matched. (Eg., 25k times for Brown, 5m times for BNC)

Package

ttt.

Source

trees.lisp.

Function: compile-helper (patt)

Compile general tree, free-standing, and permutation patterns.

Package

ttt.

Source

operators/fpseq-gen.lisp.

Function: concatenate-syms! (&rest args)

Takes a free-standing sequence of symbols as arguments.
Returns the symbol which is the concatenation of their symbol names, with dashes in between. Ex: (join-with-dash! ’X ’Y ’Z) => X-Y-Z

Package

ttt.

Source

template-construction.lisp.

Function: copy-d-state (instance)
Package

ttt.

Source

operators/descendant.lisp.

Function: copy-h-state (instance)
Package

ttt.

Source

operators/fpseq-gen.lisp.

Function: copy-rs-state (instance)
Package

ttt.

Source

operators/restricted-seq.lisp.

Function: copy-t-bind (instance)
Package

ttt.

Source

transductions.lisp.

Function: copy-v-state (instance)
Package

ttt.

Source

operators/vertical.lisp.

Reader: d-state-depth (instance)
Writer: (setf d-state-depth) (instance)
Package

ttt.

Source

operators/descendant.lisp.

Target Slot

depth.

Reader: d-state-node (instance)
Writer: (setf d-state-node) (instance)
Package

ttt.

Source

operators/descendant.lisp.

Target Slot

node.

Function: d-state-p (object)
Package

ttt.

Source

operators/descendant.lisp.

Function: deep-match-brute (pattern tree)

Matched a compiled pattern against a compiled tree object, each subtree is tested.

Package

ttt.

Source

patterns.lisp.

Function: deep-substitute (newitem olditem sequence)

Recursively replace all occurences of olditem in sequence with newitem.

Package

ttt.

Source

template-construction.lisp.

Function: deepest-matches-brute (pattern tree)

Matched a compiled pattern against a compiled tree object, each subtree is tested and a list of all results are returned.

Package

ttt.

Source

patterns.lisp.

Function: do-transduction (tree t-binding bindings)

Destructively modifies tree to implement the results of a previously bound transduction operator. Returns the modified tree.

Package

ttt.

Source

transductions.lisp.

Function: ensure-compiled (patt)
Package

ttt.

Source

operators/vertical.lisp.

Function: expr-height (expression)
Package

ttt.

Source

expressions.lisp.

Function: extract-keys (pattern &key with-ops no-dups maxdepth)

return a list of keys, where each key is a cons of the form
(token . depth)
=> (extract-keys ’X)
((X . 0)
=> (extract-keys ’(S (NP (NN He)) (VP (VBZ Ran)) (|.| |.|)))
((S . 1) (NP . 2) (VP . 2) (|.| . 2))
=> (extract-keys ’(<> X Y (S (NP (NN He)) (VP (VBZ Ran)) (|.| |.|)))) ((X . 0) (Y . 0) (S . 1) (NP . 2) (VP . 2) (|.| . 2))

This was re-implemented for better factoring and to eliminate
the depth 2 limit.

Package

ttt.

Source

keys.lisp.

Function: fastmap (key idx)

used as an accessor by build-tree to reverse the list

Package

ttt.

Source

keys.lisp.

Function: filter-ops (expression &optional maxdepth)

return filter-ops + finite-required-sets-of-ors for the same depth

=> (filter-ops ’((! PP-IN PP-WITH) _*))
(PP-IN PP-WITH)

((! S SBAR) _+) - fire only when S or SBAR encountered
((! S _+) _+) - fire on every tree

for patterns with choices (! ... +)

(! if this can only match symbols from a finite set, return that set otherwise, return the empty set)

(+ if there exists a finite subset of symbols such that this rule
must match a symbol from within that set then return that set

what this buys us:
if (null (intersection (patt-keys expression) (tree-keys tree)))
then the pattern will fail to match tree

so that we can map from trees to applicable patterns:

(foreach sub-tree in tree do
(dolist (key (tree-keys sub-tree))
(dolist (pattern (gethash key *rules-by-key*))
(let ((bindings (match pattern sub-tree)))
(if bindings (print ’successful-match))))))

re-ranker parses of Brown have an average of 2.85 keys per sub-tree

return a list of the freestanding elements
=> (filter-ops ’(<> X Y))
(X Y)

=> (filter-ops ’(X Y))
((X Y))
could extend to filter-all - return ALL such sets to any depth

maxdepth stops this process at a specific depth. If an operator set includes subtrees beyond the depth, the whole pattern is omitted.

Package

ttt.

Source

expressions.lisp.

Function: get-/m (sym)
Package

ttt.

Source

operators.lisp.

Function: get-/n (sym)
Package

ttt.

Source

operators.lisp.

Function: get-binding (bvar bindings)

Return the binding for variable bvar in bindings.

Package

ttt.

Source

bindings.lisp.

Function: get-matches (pattern tree rule-depth)

Runes the compiled pattern agains a compiled tree object with the given rule-depth option. This is a helper function for apply-rule and apply-rules and does not check any of the inputs.

Returns a list of matched subtrees.

Package

ttt.

Source

transductions.lisp.

Function: get-op (sym)

Return the operation associated with sym.
If sym is a variable then return the symbol which corresponds
to the variable with additional binding information stripped.
The operation is stored in sym’s property list to avoid
future textual searching. If sym is a list or represents a literal then return nil.

Package

ttt.

Source

operators.lisp.

Function: get-pred-fn (sym)

Return the function for the base predicate symbol.

Package

ttt.

Source

predicates.lisp.

Function: get-pred-instance (pred-op)
Package

ttt.

Source

predicates.lisp.

Function: get-var (sym)

returns the thing which should be bound-to in the case of variables (and predicates); returns nil in the case of a variable, a literal, or a list

Package

ttt.

Source

operators.lisp.

Reader: h-state-binds (instance)
Writer: (setf h-state-binds) (instance)
Package

ttt.

Source

operators/fpseq-gen.lisp.

Target Slot

binds.

Function: h-state-p (object)
Package

ttt.

Source

operators/fpseq-gen.lisp.

Reader: h-state-pseq (instance)
Writer: (setf h-state-pseq) (instance)
Package

ttt.

Source

operators/fpseq-gen.lisp.

Target Slot

pseq.

Reader: h-state-tseq (instance)
Writer: (setf h-state-tseq) (instance)
Package

ttt.

Source

operators/fpseq-gen.lisp.

Target Slot

tseq.

Function: join-with-dash! (&rest args)

Takes a free-standing sequence of symbols as arguments.
Returns the symbol which is the concatenation of their symbol names, with dashes in between. Ex: (join-with-dash! ’X ’Y ’Z) => X-Y-Z

Package

ttt.

Source

template-construction.lisp.

Function: keys-to-filter-ops (keys)

for handling predicates. a crutch.
switch from ((A.0) (B.0) (C.1) (D.2) (E.2)) to (A B (C) (D E))

Package

ttt.

Source

expressions.lisp.

Function: lispify-parser-output (char-string)
Package

ttt.

Source

util.lisp.

Function: listify (n expr)
Package

ttt.

Source

expressions.lisp.

Function: literal? (sym)

return t if sym can only match itself

Package

ttt.

Source

operators.lisp.

Function: make-d-state (&key depth node)
Package

ttt.

Source

operators/descendant.lisp.

Function: make-h-state (&key pseq tseq binds)
Package

ttt.

Source

operators/fpseq-gen.lisp.

Function: make-index ()
Package

ttt.

Source

keys.lisp.

Function: make-rs-state (&key n m a tseq binds)
Package

ttt.

Source

operators/restricted-seq.lisp.

Function: make-t-bind (&key parent parent-idx template-expr)
Package

ttt.

Source

transductions.lisp.

Function: make-v-state (&key pargs tseq binds leading-vars)
Package

ttt.

Source

operators/vertical.lisp.

Function: match-encap (pattern-expr tree-expr &key bind-form)

Match a pattern expression against a tree expression.

Package

ttt.

Source

patterns.lisp.

Function: mk-binding (variable target)
Package

ttt.

Source

bindings.lisp.

Function: mk-pred-ttt (pred-op patt-expr)

Defines a predicate function within the TTT package. The predicate operator will be interned to TTT and lose the package it is in when called. TODO: make a version that is more general to other packages.

Package

ttt.

Source

predicates.lisp.

Function: mk-tmp (op &optional bind)
Package

ttt.

Source

bindings.lisp.

Function: mk-var (op &optional bind)
Package

ttt.

Source

operators.lisp.

Function: nadd-binding (binding bindings)

Destructively add the binding to bindings.

Package

ttt.

Source

bindings.lisp.

Function: next-v-states (vstate)
Package

ttt.

Source

operators/vertical.lisp.

Function: op-is-pred? (op)

Return t if the operation is a predicate. Nil otherwise.

Package

ttt.

Source

operators.lisp.

Function: op-requires-args? (op)

Return t if the operation requires args (!,+,*,?,{},<>,^,^n,^*,^+,^@). Nil otherwise (_!,_+,_*,_?).

Package

ttt.

Source

operators.lisp.

Function: patt-expr-get-op (expression)

If an operator exists which handles the particular pattern,
then return the proper operator,
otherwise return literal for tree literals or general for nonliterals.

Package

ttt.

Source

expressions.lisp.

Function: patt-expr-get-var (expression)

If the top-level pattern should be bound, return the variable.

Package

ttt.

Source

expressions.lisp.

Function: patt-expr-max-width (expression)
Package

ttt.

Source

expressions.lisp.

Function: patt-expr-min-width (expression)
Package

ttt.

Source

expressions.lisp.

Function: patt-expr-neg-args (expression)

Given patt = ’(op X1 X1 ... Xm ~ Y1 Y2 ... Yn) return ’(Y1 Y2 ... Yn)

Package

ttt.

Source

expressions.lisp.

Function: patt-expr-pos-args (expression)

Given patt = ’(op X1 X2 ... Xm ~ Y1 Y2 ... Yn) return ’(X1 X2 ... Xm)

Package

ttt.

Source

expressions.lisp.

Function: pred-sym-p (sym)

Check to see if the symbol is a predicate optionally followed by digits.

Package

ttt.

Source

operators.lisp.

Function: preslash-unsafe-chars (char-string)
Package

ttt.

Source

util.lisp.

Function: process-tb (ruleset treebank-file &key inspect-fn inspect-show-src inspect-show-res disp-summary new-tb-fn)

Apply a set of rules to a treebank.
treebank-file should be consist of one parse tree per line. ruleset should be a list of TTT rules in expression form note: Lisp will change (CD 0600) to (CD 600).

Package

ttt.

Source

process-tb.lisp.

Function: purge-op (op)

Purge op from the operation table.

Package

ttt.

Source

operators.lisp.

Reader: rs-state-a (instance)
Writer: (setf rs-state-a) (instance)
Package

ttt.

Source

operators/restricted-seq.lisp.

Target Slot

a.

Reader: rs-state-binds (instance)
Writer: (setf rs-state-binds) (instance)
Package

ttt.

Source

operators/restricted-seq.lisp.

Target Slot

binds.

Reader: rs-state-m (instance)
Writer: (setf rs-state-m) (instance)
Package

ttt.

Source

operators/restricted-seq.lisp.

Target Slot

m.

Reader: rs-state-n (instance)
Writer: (setf rs-state-n) (instance)
Package

ttt.

Source

operators/restricted-seq.lisp.

Target Slot

n.

Function: rs-state-p (object)
Package

ttt.

Source

operators/restricted-seq.lisp.

Reader: rs-state-tseq (instance)
Writer: (setf rs-state-tseq) (instance)
Package

ttt.

Source

operators/restricted-seq.lisp.

Target Slot

tseq.

Function: satisfies-constraints (binds constraints)

STUB

Package

ttt.

Source

bindings.lisp.

Function: search-tb (treebank-stream patt-expr &key verbose)

Patt-expr should be a basic s-expression. treebank-file should be an open steam.

Package

ttt.

Source

search-tb.lisp.

Function: sticky? (op)

Return true if the atomic symbol op represents a sticky variable; memoize the result.

Package

ttt.

Source

operators.lisp.

Function: subst-new! (sym expr)

Replaces every occurence of symbol sym in expr with a single new symbol, which is created by appending a period and an integer onto the symbol-name of sym. Ex: (subst-new! ’X (A X (X))) => (A X.1 (X.1))

Package

ttt.

Source

template-construction.lisp.

Function: t-bind-p (object)
Package

ttt.

Source

transductions.lisp.

Reader: t-bind-parent (instance)
Writer: (setf t-bind-parent) (instance)
Package

ttt.

Source

transductions.lisp.

Target Slot

parent.

Reader: t-bind-parent-idx (instance)
Writer: (setf t-bind-parent-idx) (instance)
Package

ttt.

Source

transductions.lisp.

Target Slot

parent-idx.

Reader: t-bind-template-expr (instance)
Writer: (setf t-bind-template-expr) (instance)
Package

ttt.

Source

transductions.lisp.

Target Slot

template-expr.

Function: template-to-tree (template-expr bindings return-expr)

Build a new tree expression from template-expression and bindings. When return-expr is nil, a tree object is returned instead.

Package

ttt.

Source

template-construction.lisp.

Reader: v-state-binds (instance)
Writer: (setf v-state-binds) (instance)
Package

ttt.

Source

operators/vertical.lisp.

Target Slot

binds.

Reader: v-state-leading-vars (instance)
Writer: (setf v-state-leading-vars) (instance)
Package

ttt.

Source

operators/vertical.lisp.

Target Slot

leading-vars.

Function: v-state-p (object)
Package

ttt.

Source

operators/vertical.lisp.

Reader: v-state-pargs (instance)
Writer: (setf v-state-pargs) (instance)
Package

ttt.

Source

operators/vertical.lisp.

Target Slot

pargs.

Reader: v-state-tseq (instance)
Writer: (setf v-state-tseq) (instance)
Package

ttt.

Source

operators/vertical.lisp.

Target Slot

tseq.

Function: valid-op-suffix (string)

Added so that ** isn’t parsed as an operator with suffix *

Package

ttt.

Source

operators.lisp.

Function: variable? (sym)

return t if sym is an operator with a variable

Package

ttt.

Source

operators.lisp.

Function: wrap-sticky-check (var function)
Package

ttt.

Source

sticky.lisp.


5.2.3 Generic functions

Generic Reader: children (object)
Package

ttt.

Methods
Reader Method: children ((tree tree))

automatically generated reader method

Source

trees.lisp.

Target Slot

children.

Generic Writer: (setf children) (object)
Package

ttt.

Methods
Writer Method: (setf children) ((tree tree))

automatically generated writer method

Source

trees.lisp.

Target Slot

children.

Generic Function: compile-pattern (patt)
Package

ttt.

Methods
Method: compile-pattern ((patt transduction))
Source

transductions.lisp.

Method: compile-pattern ((patt stuck-patt))
Source

sticky.lisp.

Method: compile-pattern ((patt literal-patt))

Tree is a tree in Lisp expression form: E.g, (X (Y) (Z))
tree-seq is a list of instances of class tree, results of build-tree

For efficiency, compile-tree-literal expects tree objects to have constant time access to their underlying expression through to-expr. Similarly, pattern is expected to be an instance of class pattern, and to represent a tree literal. The underlying literal should be able to be accessed in constant time through to-literal.

Source

operators/literal.lisp.

Method: compile-pattern ((patt point-of-attachment))
Source

operators/vertical.lisp.

Method: compile-pattern ((patt vertical-patt))
Source

operators/vertical.lisp.

Method: compile-pattern ((patt descendant-patt))

Compile patterns with operators ^ ^^ ^* ^n

Source

operators/descendant.lisp.

Method: compile-pattern ((patt general-patt))
Source

operators/fpseq-gen.lisp.

Method: compile-pattern ((patt permuted-seq))
Source

operators/fpseq-gen.lisp.

Method: compile-pattern ((patt free-seq))
Source

operators/fpseq-gen.lisp.

Method: compile-pattern ((patt restricted-seq))

Set the match-fn for restricted sequence pattern patt.

Source

operators/restricted-seq.lisp.

Method: compile-pattern ((patt unrestricted-seq))

Set the match-fn for unrestriced sequence pattern patt.

Source

operators/unrestricted-seq.lisp.

Generic Reader: compiled? (object)
Package

ttt.

Methods
Reader Method: compiled? ((pattern pattern))

automatically generated reader method

Source

patterns.lisp.

Target Slot

compiled?.

Generic Writer: (setf compiled?) (object)
Package

ttt.

Methods
Writer Method: (setf compiled?) ((pattern pattern))

automatically generated writer method

Source

patterns.lisp.

Target Slot

compiled?.

Generic Function: deep-match (patt tree)
Package

ttt.

Methods
Method: deep-match ((patt pattern) tree)

Match a compiled pattern against a compiled tree object, use keys to avoid matching when guaranteed to fail.

Source

patterns.lisp.

Generic Function: deepest-matches (patt tree)
Package

ttt.

Methods
Method: deepest-matches ((patt pattern) tree)

Matched a compiled pattern against a compiled tree object, each subtree is tested and a list of all results are returned. Use keys to avoid matching when guaranteed to fail.

Source

patterns.lisp.

Generic Reader: dfs-order (object)
Package

ttt.

Methods
Reader Method: dfs-order ((tree tree))

automatically generated reader method

Source

trees.lisp.

Target Slot

dfs-order.

Generic Writer: (setf dfs-order) (object)
Package

ttt.

Methods
Writer Method: (setf dfs-order) ((tree tree))

automatically generated writer method

Source

trees.lisp.

Target Slot

dfs-order.

Generic Reader: height (object)
Package

ttt.

Methods
Reader Method: height ((tree tree))

automatically generated reader method

Source

trees.lisp.

Target Slot

height.

Generic Writer: (setf height) (object)
Package

ttt.

Methods
Writer Method: (setf height) ((tree tree))

automatically generated writer method

Source

trees.lisp.

Target Slot

height.

Generic Reader: index (object)
Package

ttt.

Methods
Reader Method: index ((index index))

automatically generated reader method

Source

keys.lisp.

Target Slot

index.

Generic Writer: (setf index) (object)
Package

ttt.

Methods
Writer Method: (setf index) ((index index))

automatically generated writer method

Source

keys.lisp.

Target Slot

index.

Generic Reader: initialized? (object)
Package

ttt.

Methods
Reader Method: initialized? ((pattern pattern))

automatically generated reader method

Source

patterns.lisp.

Target Slot

initialized?.

Generic Writer: (setf initialized?) (object)
Package

ttt.

Methods
Writer Method: (setf initialized?) ((pattern pattern))

automatically generated writer method

Source

patterns.lisp.

Target Slot

initialized?.

Generic Reader: keys (object)
Package

ttt.

Methods
Reader Method: keys ((pattern pattern))

automatically generated reader method

Source

patterns.lisp.

Target Slot

keys.

Reader Method: keys ((tree tree))

automatically generated reader method

Source

trees.lisp.

Target Slot

keys.

Generic Writer: (setf keys) (object)
Package

ttt.

Methods
Writer Method: (setf keys) ((pattern pattern))

automatically generated writer method

Source

patterns.lisp.

Target Slot

keys.

Writer Method: (setf keys) ((tree tree))

automatically generated writer method

Source

trees.lisp.

Target Slot

keys.

Generic Function: leaf? (node)
Package

ttt.

Methods
Method: leaf? ((node tree))
Source

trees.lisp.

Generic Reader: lhs (object)
Package

ttt.

Methods
Reader Method: lhs ((transduction transduction))

automatically generated reader method

Source

transductions.lisp.

Target Slot

lhs.

Generic Writer: (setf lhs) (object)
Package

ttt.

Methods
Writer Method: (setf lhs) ((transduction transduction))

automatically generated writer method

Source

transductions.lisp.

Target Slot

lhs.

Generic Function: match (patt tree-seq bindings)
Package

ttt.

Methods
Method: match ((pred predicate-patt) tree-seq bindings)

Predicates do not access or modify bindings.

Source

predicates.lisp.

Method: match ((patt pattern) tree-seq bindings)

Generic method to match a compiled pattern against a sequence of trees

Source

patterns.lisp.

Generic Reader: match-fn (object)
Package

ttt.

Methods
Reader Method: match-fn ((pattern pattern))

automatically generated reader method

Source

patterns.lisp.

Target Slot

match-fn.

Generic Writer: (setf match-fn) (object)
Package

ttt.

Methods
Writer Method: (setf match-fn) ((pattern pattern))

automatically generated writer method

Source

patterns.lisp.

Target Slot

match-fn.

Generic Reader: max-depth (object)
Package

ttt.

Methods
Reader Method: max-depth ((has-depth-constraints has-depth-constraints))

automatically generated reader method

Source

patterns.lisp.

Target Slot

max-depth.

Generic Writer: (setf max-depth) (object)
Package

ttt.

Methods
Writer Method: (setf max-depth) ((has-depth-constraints has-depth-constraints))

automatically generated writer method

Source

patterns.lisp.

Target Slot

max-depth.

Generic Reader: max-height (object)
Package

ttt.

Methods
Reader Method: max-height ((pattern pattern))

automatically generated reader method

Source

patterns.lisp.

Target Slot

max-height.

Generic Writer: (setf max-height) (object)
Package

ttt.

Methods
Writer Method: (setf max-height) ((pattern pattern))

automatically generated writer method

Source

patterns.lisp.

Target Slot

max-height.

Generic Reader: max-iter (object)
Package

ttt.

Methods
Reader Method: max-iter ((has-iter-constraints has-iter-constraints))

automatically generated reader method

Source

patterns.lisp.

Target Slot

max-iter.

Generic Writer: (setf max-iter) (object)
Package

ttt.

Methods
Writer Method: (setf max-iter) ((has-iter-constraints has-iter-constraints))

automatically generated writer method

Source

patterns.lisp.

Target Slot

max-iter.

Generic Reader: max-width (object)
Package

ttt.

Methods
Reader Method: max-width ((pattern pattern))

automatically generated reader method

Source

patterns.lisp.

Target Slot

max-width.

Generic Writer: (setf max-width) (object)
Package

ttt.

Methods
Writer Method: (setf max-width) ((pattern pattern))

automatically generated writer method

Source

patterns.lisp.

Target Slot

max-width.

Generic Reader: min-depth (object)
Package

ttt.

Methods
Reader Method: min-depth ((has-depth-constraints has-depth-constraints))

automatically generated reader method

Source

patterns.lisp.

Target Slot

min-depth.

Generic Writer: (setf min-depth) (object)
Package

ttt.

Methods
Writer Method: (setf min-depth) ((has-depth-constraints has-depth-constraints))

automatically generated writer method

Source

patterns.lisp.

Target Slot

min-depth.

Generic Reader: min-height (object)
Package

ttt.

Methods
Reader Method: min-height ((pattern pattern))

automatically generated reader method

Source

patterns.lisp.

Target Slot

min-height.

Generic Writer: (setf min-height) (object)
Package

ttt.

Methods
Writer Method: (setf min-height) ((pattern pattern))

automatically generated writer method

Source

patterns.lisp.

Target Slot

min-height.

Generic Reader: min-iter (object)
Package

ttt.

Methods
Reader Method: min-iter ((has-iter-constraints has-iter-constraints))

automatically generated reader method

Source

patterns.lisp.

Target Slot

min-iter.

Generic Writer: (setf min-iter) (object)
Package

ttt.

Methods
Writer Method: (setf min-iter) ((has-iter-constraints has-iter-constraints))

automatically generated writer method

Source

patterns.lisp.

Target Slot

min-iter.

Generic Reader: min-width (object)
Package

ttt.

Methods
Reader Method: min-width ((pattern pattern))

automatically generated reader method

Source

patterns.lisp.

Target Slot

min-width.

Generic Writer: (setf min-width) (object)
Package

ttt.

Methods
Writer Method: (setf min-width) ((pattern pattern))

automatically generated writer method

Source

patterns.lisp.

Target Slot

min-width.

Generic Reader: nchildren (object)
Package

ttt.

Methods
Reader Method: nchildren ((tree tree))

automatically generated reader method

Source

trees.lisp.

Target Slot

nchildren.

Generic Writer: (setf nchildren) (object)
Package

ttt.

Methods
Writer Method: (setf nchildren) ((tree tree))

automatically generated writer method

Source

trees.lisp.

Target Slot

nchildren.

Generic Reader: neg-args (object)
Package

ttt.

Methods
Reader Method: neg-args ((has-neg-args has-neg-args))

automatically generated reader method

Source

patterns.lisp.

Target Slot

neg-args.

Generic Writer: (setf neg-args) (object)
Package

ttt.

Methods
Writer Method: (setf neg-args) ((has-neg-args has-neg-args))

automatically generated writer method

Source

patterns.lisp.

Target Slot

neg-args.

Generic Reader: parent (object)
Package

ttt.

Methods
Reader Method: parent ((tree tree))

automatically generated reader method

Source

trees.lisp.

Target Slot

parent.

Generic Writer: (setf parent) (object)
Package

ttt.

Methods
Writer Method: (setf parent) ((tree tree))

automatically generated writer method

Source

trees.lisp.

Target Slot

parent.

Generic Reader: parent-idx (object)
Package

ttt.

Methods
Reader Method: parent-idx ((tree tree))

automatically generated reader method

Source

trees.lisp.

Target Slot

parent-idx.

Generic Writer: (setf parent-idx) (object)
Package

ttt.

Methods
Writer Method: (setf parent-idx) ((tree tree))

automatically generated writer method

Source

trees.lisp.

Target Slot

parent-idx.

Generic Reader: patt (object)
Package

ttt.

Methods
Reader Method: patt ((predicate-patt predicate-patt))

automatically generated reader method

Source

predicates.lisp.

Target Slot

patt.

Generic Writer: (setf patt) (object)
Package

ttt.

Methods
Writer Method: (setf patt) ((predicate-patt predicate-patt))

automatically generated writer method

Source

predicates.lisp.

Target Slot

patt.

Generic Reader: pos-args (object)
Package

ttt.

Methods
Reader Method: pos-args ((has-pos-args has-pos-args))

automatically generated reader method

Source

patterns.lisp.

Target Slot

pos-args.

Generic Writer: (setf pos-args) (object)
Package

ttt.

Methods
Writer Method: (setf pos-args) ((has-pos-args has-pos-args))

automatically generated writer method

Source

patterns.lisp.

Target Slot

pos-args.

Generic Reader: rhs (object)
Package

ttt.

Methods
Reader Method: rhs ((transduction transduction))

automatically generated reader method

Source

transductions.lisp.

Target Slot

rhs.

Generic Writer: (setf rhs) (object)
Package

ttt.

Methods
Writer Method: (setf rhs) ((transduction transduction))

automatically generated writer method

Source

transductions.lisp.

Target Slot

rhs.

Generic Reader: to-expr (object)
Package

ttt.

Methods
Reader Method: to-expr ((pattern pattern))

automatically generated reader method

Source

patterns.lisp.

Target Slot

to-expr.

Reader Method: to-expr ((tree tree))

automatically generated reader method

Source

trees.lisp.

Target Slot

to-expr.

Generic Writer: (setf to-expr) (object)
Package

ttt.

Methods
Writer Method: (setf to-expr) ((pattern pattern))

automatically generated writer method

Source

patterns.lisp.

Target Slot

to-expr.

Writer Method: (setf to-expr) ((tree tree))

automatically generated writer method

Source

trees.lisp.

Target Slot

to-expr.

Generic Reader: to-subtrees (object)
Package

ttt.

Methods
Reader Method: to-subtrees ((tree tree))

automatically generated reader method

Source

trees.lisp.

Target Slot

to-subtrees.

Generic Writer: (setf to-subtrees) (object)
Package

ttt.

Methods
Writer Method: (setf to-subtrees) ((tree tree))

automatically generated writer method

Source

trees.lisp.

Target Slot

to-subtrees.

Generic Reader: ttt-pred (object)
Package

ttt.

Methods
Reader Method: ttt-pred ((predicate-patt predicate-patt))

automatically generated reader method

Source

predicates.lisp.

Target Slot

ttt-pred.

Generic Writer: (setf ttt-pred) (object)
Package

ttt.

Methods
Writer Method: (setf ttt-pred) ((predicate-patt predicate-patt))

automatically generated writer method

Source

predicates.lisp.

Target Slot

ttt-pred.

Generic Function: update-dfs-order (root)
Package

ttt.

Methods
Method: update-dfs-order ((root tree))

recomputes dfs-order for all subtrees.
particularly useful after transductions modify a tree.

Source

trees.lisp.

Generic Function: update-subtree-index (root)
Package

ttt.

Methods
Method: update-subtree-index ((root tree))

recomputes to-subtrees index for a tree.
particularly useful after transductions modify a tree. assumes keys are valid.

Source

trees.lisp.

Generic Reader: var (object)
Package

ttt.

Methods
Reader Method: var ((pattern pattern))

automatically generated reader method

Source

patterns.lisp.

Target Slot

var.

Generic Writer: (setf var) (object)
Package

ttt.

Methods
Writer Method: (setf var) ((pattern pattern))

automatically generated writer method

Source

patterns.lisp.

Target Slot

var.


5.2.4 Structures

Structure: d-state
Package

ttt.

Source

operators/descendant.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: depth
Readers

d-state-depth.

Writers

(setf d-state-depth).

Slot: node
Readers

d-state-node.

Writers

(setf d-state-node).

Structure: h-state
Package

ttt.

Source

operators/fpseq-gen.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: pseq
Readers

h-state-pseq.

Writers

(setf h-state-pseq).

Slot: tseq
Readers

h-state-tseq.

Writers

(setf h-state-tseq).

Slot: binds
Readers

h-state-binds.

Writers

(setf h-state-binds).

Structure: rs-state
Package

ttt.

Source

operators/restricted-seq.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: n
Readers

rs-state-n.

Writers

(setf rs-state-n).

Slot: m
Readers

rs-state-m.

Writers

(setf rs-state-m).

Slot: a
Readers

rs-state-a.

Writers

(setf rs-state-a).

Slot: tseq
Readers

rs-state-tseq.

Writers

(setf rs-state-tseq).

Slot: binds
Readers

rs-state-binds.

Writers

(setf rs-state-binds).

Structure: t-bind
Package

ttt.

Source

transductions.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: parent
Readers

t-bind-parent.

Writers

(setf t-bind-parent).

Slot: parent-idx
Readers

t-bind-parent-idx.

Writers

(setf t-bind-parent-idx).

Slot: template-expr
Readers

t-bind-template-expr.

Writers

(setf t-bind-template-expr).

Structure: v-state
Package

ttt.

Source

operators/vertical.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: pargs
Readers

v-state-pargs.

Writers

(setf v-state-pargs).

Slot: tseq
Readers

v-state-tseq.

Writers

(setf v-state-tseq).

Slot: binds
Readers

v-state-binds.

Writers

(setf v-state-binds).

Slot: leading-vars
Readers

v-state-leading-vars.

Writers

(setf v-state-leading-vars).


5.2.5 Classes

Class: descendant-patt

Descendant pattern of form:
(^ P1 P2 ... Pp ~ N1 N2 ... Nn) (^* P1 P2 ... Pp ~ N1 N2 ... Nn) (^+ P1 P2 ... Pp ~ N1 N2 ... Nn) (^n P1 P2 ... Pp ~ N1 N2 ... Nn) (^^ P1 P2 ... Pp ~ N1 N2 ... Nn)

Package

ttt.

Source

operators/descendant.lisp.

Direct superclasses
Direct methods

compile-pattern.

Class: free-seq

Free standing sequence of form: (<> P1 P2 ... Pp)

Package

ttt.

Source

operators/fpseq-gen.lisp.

Direct superclasses
Direct methods

compile-pattern.

Class: general-patt

General tree pattern: (_+ X Y _! Z)

Package

ttt.

Source

operators/fpseq-gen.lisp.

Direct superclasses
Direct methods

compile-pattern.

Class: has-depth-constraints
Package

ttt.

Source

patterns.lisp.

Direct subclasses

descendant-patt.

Direct methods
Direct slots
Slot: min-depth
Type

fixnum

Initform

0

Readers

min-depth.

Writers

(setf min-depth).

Slot: max-depth
Type

fixnum

Initform

most-positive-fixnum

Readers

max-depth.

Writers

(setf max-depth).

Class: has-iter-constraints
Package

ttt.

Source

patterns.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: min-iter
Type

fixnum

Initargs

:min-iter

Readers

min-iter.

Writers

(setf min-iter).

Slot: max-iter
Type

fixnum

Initargs

:max-iter

Readers

max-iter.

Writers

(setf max-iter).

Class: has-neg-args
Package

ttt.

Source

patterns.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: neg-args
Type

list

Initargs

:neg-args

Readers

neg-args.

Writers

(setf neg-args).

Class: has-pos-args
Package

ttt.

Source

patterns.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: pos-args
Type

list

Initargs

:pos-args

Readers

pos-args.

Writers

(setf pos-args).

Class: index
Package

ttt.

Source

keys.lisp.

Direct methods
Direct slots
Slot: index
Type

(simple-array hash-table *)

Readers

index.

Writers

(setf index).

Class: literal-patt

Tree-literal pattern (e.g, a pattern involving no operators)

Package

ttt.

Source

operators/literal.lisp.

Direct superclasses

pattern.

Direct methods

compile-pattern.

Class: pattern

General class representing properties common to all patterns,
such as min/max matchable tree sequence width, and operator type. This is a purely abstract class, not meant to be instantiated directly.

A pattern is a static object and should not be modified
after construction.

The constructors for descendant patterns should initialze match-fn to either a generic (interpreted) function or compiled function which is unique to the pattern object.

Package

ttt.

Source

patterns.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: min-width
Type

fixnum

Initform

0

Initargs

:min-width

Readers

min-width.

Writers

(setf min-width).

Slot: max-width
Type

fixnum

Initform

most-positive-fixnum

Initargs

:max-width

Readers

max-width.

Writers

(setf max-width).

Slot: min-height
Type

fixnum

Initform

0

Readers

min-height.

Writers

(setf min-height).

Slot: max-height
Type

fixnum

Initform

most-positive-fixnum

Readers

max-height.

Writers

(setf max-height).

Slot: keys
Type

list

Readers

keys.

Writers

(setf keys).

Slot: compiled?
Readers

compiled?.

Writers

(setf compiled?).

Slot: initialized?
Initargs

:initialized?

Readers

initialized?.

Writers

(setf initialized?).

Slot: to-expr
Type

ttt::tree-expr

Readers

to-expr.

Writers

(setf to-expr).

Slot: match-fn
Type

function

Readers

match-fn.

Writers

(setf match-fn).

Slot: var
Initargs

:var

Readers

var.

Writers

(setf var).

Class: permuted-seq

Permuted sequence of form: ({} P1 P2 ... Pp)

Package

ttt.

Source

operators/fpseq-gen.lisp.

Direct superclasses
Direct methods

compile-pattern.

Class: point-of-attachment
Package

ttt.

Source

operators/vertical.lisp.

Direct superclasses

pattern.

Direct methods

compile-pattern.

Class: predicate-patt

A predicate may only match tree-sequences of length 1. Their only arguments should be a tree sequence. They do not modify bindings.

Package

ttt.

Source

predicates.lisp.

Direct superclasses

pattern.

Direct methods
Direct slots
Slot: patt
Readers

patt.

Writers

(setf patt).

Slot: ttt-pred
Readers

ttt-pred.

Writers

(setf ttt-pred).

Class: restricted-seq

Restricted sequences of general forms:
(![n] P1 ... Pp ~ N1 ... Nn)
(+[n] P1 ... Pp ~ N1 ... Nn)
(?[n] P1 ... Pp ~ N1 ... Nn)
(*[n-m] P1 ... Pp ~ N1 ... Nn)

The iterative constraints and negated arguments are optional. When there are no negated arguments, the ~ should be omitted. A special case is: (! ~ N1 ... Nn), which matches any tree which does not match any of the negated arguments.

Package

ttt.

Source

operators/restricted-seq.lisp.

Direct superclasses
Direct methods

compile-pattern.

Class: stuck-patt

A class for matching free-standing sticky variables associated with operators which would typically require arugments and which can be sticky. I.e., ! + * ? <> {} ^ ^* ^@).

Package

ttt.

Source

sticky.lisp.

Direct superclasses

pattern.

Direct methods

compile-pattern.

Class: transduction

Returns special bindings.
one transduction operator per rule no named variables (no sticky) cannot be in iterated context
must match sequence of length 1 must replace with sequence of length 1

Package

ttt.

Source

transductions.lisp.

Direct superclasses

pattern.

Direct methods
Direct slots
Slot: lhs
Readers

lhs.

Writers

(setf lhs).

Slot: rhs
Readers

rhs.

Writers

(setf rhs).

Class: tree
Package

ttt.

Source

trees.lisp.

Direct methods
Direct slots
Slot: children
Type

ttt::tree-expr

Readers

children.

Writers

(setf children).

Slot: to-expr
Type

ttt::tree-expr

Readers

to-expr.

Writers

(setf to-expr).

Slot: nchildren
Type

fixnum

Readers

nchildren.

Writers

(setf nchildren).

Slot: height
Type

fixnum

Readers

height.

Writers

(setf height).

Slot: keys
Readers

keys.

Writers

(setf keys).

Slot: to-subtrees
Readers

to-subtrees.

Writers

(setf to-subtrees).

Slot: parent
Readers

parent.

Writers

(setf parent).

Slot: parent-idx
Readers

parent-idx.

Writers

(setf parent-idx).

Slot: dfs-order
Readers

dfs-order.

Writers

(setf dfs-order).

Class: unrestricted-seq

Unrestricted sequences of general forms: _![n] _+[n] _?[n] _*[n-m]
with stickied, named syntax: _!.[n]var _+.[n]var _?.[n]var _*.[n-m]var

matching a sequence of length
exactly n, at least n, at most n,
and between n and m, respectively.

Package

ttt.

Source

operators/unrestricted-seq.lisp.

Direct superclasses
Direct methods

compile-pattern.

Class: vertical-patt

Vertical path of form:
(^@ P1 P2 ... Pp ~ N1 N2 ... Nn)

Package

ttt.

Source

operators/vertical.lisp.

Direct superclasses
Direct methods

compile-pattern.


5.2.6 Types

Type: tree-expr ()
Package

ttt.

Source

types.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   (  
A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   R   S   T   U   V   W  
Index Entry  Section

(
(setf children): Private generic functions
(setf children): Private generic functions
(setf compiled?): Private generic functions
(setf compiled?): Private generic functions
(setf d-state-depth): Private ordinary functions
(setf d-state-node): Private ordinary functions
(setf dfs-order): Private generic functions
(setf dfs-order): Private generic functions
(setf h-state-binds): Private ordinary functions
(setf h-state-pseq): Private ordinary functions
(setf h-state-tseq): Private ordinary functions
(setf height): Private generic functions
(setf height): Private generic functions
(setf index): Private generic functions
(setf index): Private generic functions
(setf initialized?): Private generic functions
(setf initialized?): Private generic functions
(setf keys): Private generic functions
(setf keys): Private generic functions
(setf keys): Private generic functions
(setf lhs): Private generic functions
(setf lhs): Private generic functions
(setf match-fn): Private generic functions
(setf match-fn): Private generic functions
(setf max-depth): Private generic functions
(setf max-depth): Private generic functions
(setf max-height): Private generic functions
(setf max-height): Private generic functions
(setf max-iter): Private generic functions
(setf max-iter): Private generic functions
(setf max-width): Private generic functions
(setf max-width): Private generic functions
(setf min-depth): Private generic functions
(setf min-depth): Private generic functions
(setf min-height): Private generic functions
(setf min-height): Private generic functions
(setf min-iter): Private generic functions
(setf min-iter): Private generic functions
(setf min-width): Private generic functions
(setf min-width): Private generic functions
(setf nchildren): Private generic functions
(setf nchildren): Private generic functions
(setf neg-args): Private generic functions
(setf neg-args): Private generic functions
(setf parent): Private generic functions
(setf parent): Private generic functions
(setf parent-idx): Private generic functions
(setf parent-idx): Private generic functions
(setf patt): Private generic functions
(setf patt): Private generic functions
(setf pos-args): Private generic functions
(setf pos-args): Private generic functions
(setf rhs): Private generic functions
(setf rhs): Private generic functions
(setf rs-state-a): Private ordinary functions
(setf rs-state-binds): Private ordinary functions
(setf rs-state-m): Private ordinary functions
(setf rs-state-n): Private ordinary functions
(setf rs-state-tseq): Private ordinary functions
(setf t-bind-parent): Private ordinary functions
(setf t-bind-parent-idx): Private ordinary functions
(setf t-bind-template-expr): Private ordinary functions
(setf to-expr): Private generic functions
(setf to-expr): Private generic functions
(setf to-expr): Private generic functions
(setf to-subtrees): Private generic functions
(setf to-subtrees): Private generic functions
(setf ttt-pred): Private generic functions
(setf ttt-pred): Private generic functions
(setf v-state-binds): Private ordinary functions
(setf v-state-leading-vars): Private ordinary functions
(setf v-state-pargs): Private ordinary functions
(setf v-state-tseq): Private ordinary functions
(setf var): Private generic functions
(setf var): Private generic functions

A
add-binding: Private ordinary functions
add-op: Private ordinary functions
add-to-index: Private ordinary functions
apply!: Private ordinary functions
apply-rule: Public ordinary functions
apply-rules: Public ordinary functions

B
bind-seq: Private ordinary functions
bind-var: Private ordinary functions
bound?: Private ordinary functions
build-pattern: Private ordinary functions
build-tree: Private ordinary functions

C
children: Private generic functions
children: Private generic functions
compile-helper: Private ordinary functions
compile-pattern: Private generic functions
compile-pattern: Private generic functions
compile-pattern: Private generic functions
compile-pattern: Private generic functions
compile-pattern: Private generic functions
compile-pattern: Private generic functions
compile-pattern: Private generic functions
compile-pattern: Private generic functions
compile-pattern: Private generic functions
compile-pattern: Private generic functions
compile-pattern: Private generic functions
compile-pattern: Private generic functions
compiled?: Private generic functions
compiled?: Private generic functions
concatenate-syms!: Private ordinary functions
copy-d-state: Private ordinary functions
copy-h-state: Private ordinary functions
copy-rs-state: Private ordinary functions
copy-t-bind: Private ordinary functions
copy-v-state: Private ordinary functions

D
d-state-depth: Private ordinary functions
d-state-node: Private ordinary functions
d-state-p: Private ordinary functions
deep-match: Private generic functions
deep-match: Private generic functions
deep-match-brute: Private ordinary functions
deep-substitute: Private ordinary functions
deepest-matches: Private generic functions
deepest-matches: Private generic functions
deepest-matches-brute: Private ordinary functions
dfs-order: Private generic functions
dfs-order: Private generic functions
do-transduction: Private ordinary functions

E
ensure-compiled: Private ordinary functions
expr-height: Private ordinary functions
extract-keys: Private ordinary functions

F
fastmap: Private ordinary functions
filter-ops: Private ordinary functions
Function, (setf d-state-depth): Private ordinary functions
Function, (setf d-state-node): Private ordinary functions
Function, (setf h-state-binds): Private ordinary functions
Function, (setf h-state-pseq): Private ordinary functions
Function, (setf h-state-tseq): Private ordinary functions
Function, (setf rs-state-a): Private ordinary functions
Function, (setf rs-state-binds): Private ordinary functions
Function, (setf rs-state-m): Private ordinary functions
Function, (setf rs-state-n): Private ordinary functions
Function, (setf rs-state-tseq): Private ordinary functions
Function, (setf t-bind-parent): Private ordinary functions
Function, (setf t-bind-parent-idx): Private ordinary functions
Function, (setf t-bind-template-expr): Private ordinary functions
Function, (setf v-state-binds): Private ordinary functions
Function, (setf v-state-leading-vars): Private ordinary functions
Function, (setf v-state-pargs): Private ordinary functions
Function, (setf v-state-tseq): Private ordinary functions
Function, add-binding: Private ordinary functions
Function, add-op: Private ordinary functions
Function, add-to-index: Private ordinary functions
Function, apply!: Private ordinary functions
Function, apply-rule: Public ordinary functions
Function, apply-rules: Public ordinary functions
Function, bind-seq: Private ordinary functions
Function, bind-var: Private ordinary functions
Function, bound?: Private ordinary functions
Function, build-pattern: Private ordinary functions
Function, build-tree: Private ordinary functions
Function, compile-helper: Private ordinary functions
Function, concatenate-syms!: Private ordinary functions
Function, copy-d-state: Private ordinary functions
Function, copy-h-state: Private ordinary functions
Function, copy-rs-state: Private ordinary functions
Function, copy-t-bind: Private ordinary functions
Function, copy-v-state: Private ordinary functions
Function, d-state-depth: Private ordinary functions
Function, d-state-node: Private ordinary functions
Function, d-state-p: Private ordinary functions
Function, deep-match-brute: Private ordinary functions
Function, deep-substitute: Private ordinary functions
Function, deepest-matches-brute: Private ordinary functions
Function, do-transduction: Private ordinary functions
Function, ensure-compiled: Private ordinary functions
Function, expr-height: Private ordinary functions
Function, extract-keys: Private ordinary functions
Function, fastmap: Private ordinary functions
Function, filter-ops: Private ordinary functions
Function, get-/m: Private ordinary functions
Function, get-/n: Private ordinary functions
Function, get-binding: Private ordinary functions
Function, get-matches: Private ordinary functions
Function, get-op: Private ordinary functions
Function, get-pred-fn: Private ordinary functions
Function, get-pred-instance: Private ordinary functions
Function, get-var: Private ordinary functions
Function, h-state-binds: Private ordinary functions
Function, h-state-p: Private ordinary functions
Function, h-state-pseq: Private ordinary functions
Function, h-state-tseq: Private ordinary functions
Function, hide-ttt-ops: Public ordinary functions
Function, join-with-dash!: Private ordinary functions
Function, keys-to-filter-ops: Private ordinary functions
Function, lispify-parser-output: Private ordinary functions
Function, listify: Private ordinary functions
Function, literal?: Private ordinary functions
Function, make-d-state: Private ordinary functions
Function, make-h-state: Private ordinary functions
Function, make-index: Private ordinary functions
Function, make-rs-state: Private ordinary functions
Function, make-t-bind: Private ordinary functions
Function, make-v-state: Private ordinary functions
Function, match-encap: Private ordinary functions
Function, match-expr: Public ordinary functions
Function, mk-binding: Private ordinary functions
Function, mk-pred-ttt: Private ordinary functions
Function, mk-tmp: Private ordinary functions
Function, mk-var: Private ordinary functions
Function, nadd-binding: Private ordinary functions
Function, next-v-states: Private ordinary functions
Function, op-is-pred?: Private ordinary functions
Function, op-requires-args?: Private ordinary functions
Function, patt-expr-get-op: Private ordinary functions
Function, patt-expr-get-var: Private ordinary functions
Function, patt-expr-max-width: Private ordinary functions
Function, patt-expr-min-width: Private ordinary functions
Function, patt-expr-neg-args: Private ordinary functions
Function, patt-expr-pos-args: Private ordinary functions
Function, pred-sym-p: Private ordinary functions
Function, preslash-unsafe-chars: Private ordinary functions
Function, process-tb: Private ordinary functions
Function, purge-op: Private ordinary functions
Function, rs-state-a: Private ordinary functions
Function, rs-state-binds: Private ordinary functions
Function, rs-state-m: Private ordinary functions
Function, rs-state-n: Private ordinary functions
Function, rs-state-p: Private ordinary functions
Function, rs-state-tseq: Private ordinary functions
Function, satisfies-constraints: Private ordinary functions
Function, search-tb: Private ordinary functions
Function, sticky?: Private ordinary functions
Function, store-pred: Public ordinary functions
Function, subst-new!: Private ordinary functions
Function, t-bind-p: Private ordinary functions
Function, t-bind-parent: Private ordinary functions
Function, t-bind-parent-idx: Private ordinary functions
Function, t-bind-template-expr: Private ordinary functions
Function, template-to-tree: Private ordinary functions
Function, ttt-all-rule-results: Public ordinary functions
Function, ttt-apply-rule-possibilities: Public ordinary functions
Function, unhide-ttt-ops: Public ordinary functions
Function, v-state-binds: Private ordinary functions
Function, v-state-leading-vars: Private ordinary functions
Function, v-state-p: Private ordinary functions
Function, v-state-pargs: Private ordinary functions
Function, v-state-tseq: Private ordinary functions
Function, valid-op-suffix: Private ordinary functions
Function, variable?: Private ordinary functions
Function, wrap-sticky-check: Private ordinary functions

G
Generic Function, (setf children): Private generic functions
Generic Function, (setf compiled?): Private generic functions
Generic Function, (setf dfs-order): Private generic functions
Generic Function, (setf height): Private generic functions
Generic Function, (setf index): Private generic functions
Generic Function, (setf initialized?): Private generic functions
Generic Function, (setf keys): Private generic functions
Generic Function, (setf lhs): Private generic functions
Generic Function, (setf match-fn): Private generic functions
Generic Function, (setf max-depth): Private generic functions
Generic Function, (setf max-height): Private generic functions
Generic Function, (setf max-iter): Private generic functions
Generic Function, (setf max-width): Private generic functions
Generic Function, (setf min-depth): Private generic functions
Generic Function, (setf min-height): Private generic functions
Generic Function, (setf min-iter): Private generic functions
Generic Function, (setf min-width): Private generic functions
Generic Function, (setf nchildren): Private generic functions
Generic Function, (setf neg-args): Private generic functions
Generic Function, (setf parent): Private generic functions
Generic Function, (setf parent-idx): Private generic functions
Generic Function, (setf patt): Private generic functions
Generic Function, (setf pos-args): Private generic functions
Generic Function, (setf rhs): Private generic functions
Generic Function, (setf to-expr): Private generic functions
Generic Function, (setf to-subtrees): Private generic functions
Generic Function, (setf ttt-pred): Private generic functions
Generic Function, (setf var): Private generic functions
Generic Function, children: Private generic functions
Generic Function, compile-pattern: Private generic functions
Generic Function, compiled?: Private generic functions
Generic Function, deep-match: Private generic functions
Generic Function, deepest-matches: Private generic functions
Generic Function, dfs-order: Private generic functions
Generic Function, height: Private generic functions
Generic Function, index: Private generic functions
Generic Function, initialized?: Private generic functions
Generic Function, keys: Private generic functions
Generic Function, leaf?: Private generic functions
Generic Function, lhs: Private generic functions
Generic Function, match: Private generic functions
Generic Function, match-fn: Private generic functions
Generic Function, max-depth: Private generic functions
Generic Function, max-height: Private generic functions
Generic Function, max-iter: Private generic functions
Generic Function, max-width: Private generic functions
Generic Function, min-depth: Private generic functions
Generic Function, min-height: Private generic functions
Generic Function, min-iter: Private generic functions
Generic Function, min-width: Private generic functions
Generic Function, nchildren: Private generic functions
Generic Function, neg-args: Private generic functions
Generic Function, parent: Private generic functions
Generic Function, parent-idx: Private generic functions
Generic Function, patt: Private generic functions
Generic Function, pos-args: Private generic functions
Generic Function, rhs: Private generic functions
Generic Function, to-expr: Private generic functions
Generic Function, to-subtrees: Private generic functions
Generic Function, ttt-pred: Private generic functions
Generic Function, update-dfs-order: Private generic functions
Generic Function, update-subtree-index: Private generic functions
Generic Function, var: Private generic functions
get-/m: Private ordinary functions
get-/n: Private ordinary functions
get-binding: Private ordinary functions
get-matches: Private ordinary functions
get-op: Private ordinary functions
get-pred-fn: Private ordinary functions
get-pred-instance: Private ordinary functions
get-var: Private ordinary functions

H
h-state-binds: Private ordinary functions
h-state-p: Private ordinary functions
h-state-pseq: Private ordinary functions
h-state-tseq: Private ordinary functions
height: Private generic functions
height: Private generic functions
hide-ttt-ops: Public ordinary functions

I
index: Private generic functions
index: Private generic functions
initialized?: Private generic functions
initialized?: Private generic functions

J
join-with-dash!: Private ordinary functions

K
keys: Private generic functions
keys: Private generic functions
keys: Private generic functions
keys-to-filter-ops: Private ordinary functions

L
leaf?: Private generic functions
leaf?: Private generic functions
lhs: Private generic functions
lhs: Private generic functions
lispify-parser-output: Private ordinary functions
listify: Private ordinary functions
literal?: Private ordinary functions

M
make-d-state: Private ordinary functions
make-h-state: Private ordinary functions
make-index: Private ordinary functions
make-rs-state: Private ordinary functions
make-t-bind: Private ordinary functions
make-v-state: Private ordinary functions
match: Private generic functions
match: Private generic functions
match: Private generic functions
match-encap: Private ordinary functions
match-expr: Public ordinary functions
match-fn: Private generic functions
match-fn: Private generic functions
max-depth: Private generic functions
max-depth: Private generic functions
max-height: Private generic functions
max-height: Private generic functions
max-iter: Private generic functions
max-iter: Private generic functions
max-width: Private generic functions
max-width: Private generic functions
Method, (setf children): Private generic functions
Method, (setf compiled?): Private generic functions
Method, (setf dfs-order): Private generic functions
Method, (setf height): Private generic functions
Method, (setf index): Private generic functions
Method, (setf initialized?): Private generic functions
Method, (setf keys): Private generic functions
Method, (setf keys): Private generic functions
Method, (setf lhs): Private generic functions
Method, (setf match-fn): Private generic functions
Method, (setf max-depth): Private generic functions
Method, (setf max-height): Private generic functions
Method, (setf max-iter): Private generic functions
Method, (setf max-width): Private generic functions
Method, (setf min-depth): Private generic functions
Method, (setf min-height): Private generic functions
Method, (setf min-iter): Private generic functions
Method, (setf min-width): Private generic functions
Method, (setf nchildren): Private generic functions
Method, (setf neg-args): Private generic functions
Method, (setf parent): Private generic functions
Method, (setf parent-idx): Private generic functions
Method, (setf patt): Private generic functions
Method, (setf pos-args): Private generic functions
Method, (setf rhs): Private generic functions
Method, (setf to-expr): Private generic functions
Method, (setf to-expr): Private generic functions
Method, (setf to-subtrees): Private generic functions
Method, (setf ttt-pred): Private generic functions
Method, (setf var): Private generic functions
Method, children: Private generic functions
Method, compile-pattern: Private generic functions
Method, compile-pattern: Private generic functions
Method, compile-pattern: Private generic functions
Method, compile-pattern: Private generic functions
Method, compile-pattern: Private generic functions
Method, compile-pattern: Private generic functions
Method, compile-pattern: Private generic functions
Method, compile-pattern: Private generic functions
Method, compile-pattern: Private generic functions
Method, compile-pattern: Private generic functions
Method, compile-pattern: Private generic functions
Method, compiled?: Private generic functions
Method, deep-match: Private generic functions
Method, deepest-matches: Private generic functions
Method, dfs-order: Private generic functions
Method, height: Private generic functions
Method, index: Private generic functions
Method, initialized?: Private generic functions
Method, keys: Private generic functions
Method, keys: Private generic functions
Method, leaf?: Private generic functions
Method, lhs: Private generic functions
Method, match: Private generic functions
Method, match: Private generic functions
Method, match-fn: Private generic functions
Method, max-depth: Private generic functions
Method, max-height: Private generic functions
Method, max-iter: Private generic functions
Method, max-width: Private generic functions
Method, min-depth: Private generic functions
Method, min-height: Private generic functions
Method, min-iter: Private generic functions
Method, min-width: Private generic functions
Method, nchildren: Private generic functions
Method, neg-args: Private generic functions
Method, parent: Private generic functions
Method, parent-idx: Private generic functions
Method, patt: Private generic functions
Method, pos-args: Private generic functions
Method, rhs: Private generic functions
Method, to-expr: Private generic functions
Method, to-expr: Private generic functions
Method, to-subtrees: Private generic functions
Method, ttt-pred: Private generic functions
Method, update-dfs-order: Private generic functions
Method, update-subtree-index: Private generic functions
Method, var: Private generic functions
min-depth: Private generic functions
min-depth: Private generic functions
min-height: Private generic functions
min-height: Private generic functions
min-iter: Private generic functions
min-iter: Private generic functions
min-width: Private generic functions
min-width: Private generic functions
mk-binding: Private ordinary functions
mk-pred-ttt: Private ordinary functions
mk-tmp: Private ordinary functions
mk-var: Private ordinary functions

N
nadd-binding: Private ordinary functions
nchildren: Private generic functions
nchildren: Private generic functions
neg-args: Private generic functions
neg-args: Private generic functions
next-v-states: Private ordinary functions

O
op-is-pred?: Private ordinary functions
op-requires-args?: Private ordinary functions

P
parent: Private generic functions
parent: Private generic functions
parent-idx: Private generic functions
parent-idx: Private generic functions
patt: Private generic functions
patt: Private generic functions
patt-expr-get-op: Private ordinary functions
patt-expr-get-var: Private ordinary functions
patt-expr-max-width: Private ordinary functions
patt-expr-min-width: Private ordinary functions
patt-expr-neg-args: Private ordinary functions
patt-expr-pos-args: Private ordinary functions
pos-args: Private generic functions
pos-args: Private generic functions
pred-sym-p: Private ordinary functions
preslash-unsafe-chars: Private ordinary functions
process-tb: Private ordinary functions
purge-op: Private ordinary functions

R
rhs: Private generic functions
rhs: Private generic functions
rs-state-a: Private ordinary functions
rs-state-binds: Private ordinary functions
rs-state-m: Private ordinary functions
rs-state-n: Private ordinary functions
rs-state-p: Private ordinary functions
rs-state-tseq: Private ordinary functions

S
satisfies-constraints: Private ordinary functions
search-tb: Private ordinary functions
sticky?: Private ordinary functions
store-pred: Public ordinary functions
subst-new!: Private ordinary functions

T
t-bind-p: Private ordinary functions
t-bind-parent: Private ordinary functions
t-bind-parent-idx: Private ordinary functions
t-bind-template-expr: Private ordinary functions
template-to-tree: Private ordinary functions
to-expr: Private generic functions
to-expr: Private generic functions
to-expr: Private generic functions
to-subtrees: Private generic functions
to-subtrees: Private generic functions
ttt-all-rule-results: Public ordinary functions
ttt-apply-rule-possibilities: Public ordinary functions
ttt-pred: Private generic functions
ttt-pred: Private generic functions

U
unhide-ttt-ops: Public ordinary functions
update-dfs-order: Private generic functions
update-dfs-order: Private generic functions
update-subtree-index: Private generic functions
update-subtree-index: Private generic functions

V
v-state-binds: Private ordinary functions
v-state-leading-vars: Private ordinary functions
v-state-p: Private ordinary functions
v-state-pargs: Private ordinary functions
v-state-tseq: Private ordinary functions
valid-op-suffix: Private ordinary functions
var: Private generic functions
var: Private generic functions
variable?: Private ordinary functions

W
wrap-sticky-check: Private ordinary functions


A.3 Variables

Jump to:   *  
A   B   C   D   H   I   K   L   M   N   P   R   S   T   V  
Index Entry  Section

*
*built-patterns*: Private special variables
*invalid-suffix-chars*: Private special variables
*next-int-lock*: Private special variables
*operation-table*: Private special variables
*operator-lock*: Private special variables
*pattern-lock*: Private special variables
*predicate-lock*: Private special variables
*predicate-table*: Private special variables
*subst-new-next-int*: Private special variables
*ttt-debug-level*: Private special variables

A
a: Private structures

B
binds: Private structures
binds: Private structures
binds: Private structures

C
children: Private classes
compiled?: Private classes

D
depth: Private structures
dfs-order: Private classes

H
height: Private classes

I
index: Private classes
initialized?: Private classes

K
keys: Private classes
keys: Private classes

L
leading-vars: Private structures
lhs: Private classes

M
m: Private structures
match-fn: Private classes
max-depth: Private classes
max-height: Private classes
max-iter: Private classes
max-width: Private classes
min-depth: Private classes
min-height: Private classes
min-iter: Private classes
min-width: Private classes

N
n: Private structures
nchildren: Private classes
neg-args: Private classes
node: Private structures

P
parent: Private structures
parent: Private classes
parent-idx: Private structures
parent-idx: Private classes
pargs: Private structures
patt: Private classes
pos-args: Private classes
pseq: Private structures

R
rhs: Private classes

S
Slot, a: Private structures
Slot, binds: Private structures
Slot, binds: Private structures
Slot, binds: Private structures
Slot, children: Private classes
Slot, compiled?: Private classes
Slot, depth: Private structures
Slot, dfs-order: Private classes
Slot, height: Private classes
Slot, index: Private classes
Slot, initialized?: Private classes
Slot, keys: Private classes
Slot, keys: Private classes
Slot, leading-vars: Private structures
Slot, lhs: Private classes
Slot, m: Private structures
Slot, match-fn: Private classes
Slot, max-depth: Private classes
Slot, max-height: Private classes
Slot, max-iter: Private classes
Slot, max-width: Private classes
Slot, min-depth: Private classes
Slot, min-height: Private classes
Slot, min-iter: Private classes
Slot, min-width: Private classes
Slot, n: Private structures
Slot, nchildren: Private classes
Slot, neg-args: Private classes
Slot, node: Private structures
Slot, parent: Private structures
Slot, parent: Private classes
Slot, parent-idx: Private structures
Slot, parent-idx: Private classes
Slot, pargs: Private structures
Slot, patt: Private classes
Slot, pos-args: Private classes
Slot, pseq: Private structures
Slot, rhs: Private classes
Slot, template-expr: Private structures
Slot, to-expr: Private classes
Slot, to-expr: Private classes
Slot, to-subtrees: Private classes
Slot, tseq: Private structures
Slot, tseq: Private structures
Slot, tseq: Private structures
Slot, ttt-pred: Private classes
Slot, var: Private classes
Special Variable, *built-patterns*: Private special variables
Special Variable, *invalid-suffix-chars*: Private special variables
Special Variable, *next-int-lock*: Private special variables
Special Variable, *operation-table*: Private special variables
Special Variable, *operator-lock*: Private special variables
Special Variable, *pattern-lock*: Private special variables
Special Variable, *predicate-lock*: Private special variables
Special Variable, *predicate-table*: Private special variables
Special Variable, *subst-new-next-int*: Private special variables
Special Variable, *ttt-debug-level*: Private special variables

T
template-expr: Private structures
to-expr: Private classes
to-expr: Private classes
to-subtrees: Private classes
tseq: Private structures
tseq: Private structures
tseq: Private structures
ttt-pred: Private classes

V
var: Private classes


A.4 Data types

Jump to:   B   C   D   E   F   G   H   I   K   L   O   P   R   S   T   U   V  
Index Entry  Section

B
bindings.lisp: The ttt/bindings․lisp file

C
Class, descendant-patt: Private classes
Class, free-seq: Private classes
Class, general-patt: Private classes
Class, has-depth-constraints: Private classes
Class, has-iter-constraints: Private classes
Class, has-neg-args: Private classes
Class, has-pos-args: Private classes
Class, index: Private classes
Class, literal-patt: Private classes
Class, pattern: Private classes
Class, permuted-seq: Private classes
Class, point-of-attachment: Private classes
Class, predicate-patt: Private classes
Class, restricted-seq: Private classes
Class, stuck-patt: Private classes
Class, transduction: Private classes
Class, tree: Private classes
Class, unrestricted-seq: Private classes
Class, vertical-patt: Private classes

D
d-state: Private structures
descendant-patt: Private classes

E
expressions.lisp: The ttt/expressions․lisp file

F
File, bindings.lisp: The ttt/bindings․lisp file
File, expressions.lisp: The ttt/expressions․lisp file
File, keys.lisp: The ttt/keys․lisp file
File, operators.lisp: The ttt/operators․lisp file
File, operators/descendant.lisp: The ttt/operators/descendant․lisp file
File, operators/fpseq-gen.lisp: The ttt/operators/fpseq-gen․lisp file
File, operators/literal.lisp: The ttt/operators/literal․lisp file
File, operators/restricted-seq.lisp: The ttt/operators/restricted-seq․lisp file
File, operators/unrestricted-seq.lisp: The ttt/operators/unrestricted-seq․lisp file
File, operators/vertical.lisp: The ttt/operators/vertical․lisp file
File, package.lisp: The ttt/package․lisp file
File, patterns.lisp: The ttt/patterns․lisp file
File, predicates.lisp: The ttt/predicates․lisp file
File, process-tb.lisp: The ttt/process-tb․lisp file
File, search-tb.lisp: The ttt/search-tb․lisp file
File, sticky.lisp: The ttt/sticky․lisp file
File, template-construction.lisp: The ttt/template-construction․lisp file
File, transductions.lisp: The ttt/transductions․lisp file
File, trees.lisp: The ttt/trees․lisp file
File, ttt.asd: The ttt/ttt․asd file
File, types.lisp: The ttt/types․lisp file
File, util.lisp: The ttt/util․lisp file
free-seq: Private classes

G
general-patt: Private classes

H
h-state: Private structures
has-depth-constraints: Private classes
has-iter-constraints: Private classes
has-neg-args: Private classes
has-pos-args: Private classes

I
index: Private classes

K
keys.lisp: The ttt/keys․lisp file

L
literal-patt: Private classes

O
operators.lisp: The ttt/operators․lisp file
operators/descendant.lisp: The ttt/operators/descendant․lisp file
operators/fpseq-gen.lisp: The ttt/operators/fpseq-gen․lisp file
operators/literal.lisp: The ttt/operators/literal․lisp file
operators/restricted-seq.lisp: The ttt/operators/restricted-seq․lisp file
operators/unrestricted-seq.lisp: The ttt/operators/unrestricted-seq․lisp file
operators/vertical.lisp: The ttt/operators/vertical․lisp file

P
Package, ttt: The ttt package
package.lisp: The ttt/package․lisp file
pattern: Private classes
patterns.lisp: The ttt/patterns․lisp file
permuted-seq: Private classes
point-of-attachment: Private classes
predicate-patt: Private classes
predicates.lisp: The ttt/predicates․lisp file
process-tb.lisp: The ttt/process-tb․lisp file

R
restricted-seq: Private classes
rs-state: Private structures

S
search-tb.lisp: The ttt/search-tb․lisp file
sticky.lisp: The ttt/sticky․lisp file
Structure, d-state: Private structures
Structure, h-state: Private structures
Structure, rs-state: Private structures
Structure, t-bind: Private structures
Structure, v-state: Private structures
stuck-patt: Private classes
System, ttt: The ttt system

T
t-bind: Private structures
template-construction.lisp: The ttt/template-construction․lisp file
transduction: Private classes
transductions.lisp: The ttt/transductions․lisp file
tree: Private classes
tree-expr: Private types
trees.lisp: The ttt/trees․lisp file
ttt: The ttt system
ttt: The ttt package
ttt.asd: The ttt/ttt․asd file
Type, tree-expr: Private types
types.lisp: The ttt/types․lisp file

U
unrestricted-seq: Private classes
util.lisp: The ttt/util․lisp file

V
v-state: Private structures
vertical-patt: Private classes