The ttt Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The ttt Reference Manual

This is the ttt Reference Manual, version 2.0.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Tue Dec 22 15:22:43 2020 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

TTT (Tree-to-Tree Transduction Language)

Build Status Coverage Status License: GPL v3

TTT is a language for transparently mapping between tree structures expressed in s-expressions. At a high-level it fills same role for trees as regex for strings. This is the copy of TTT maintained by Gene Louis Kim (gkim21@cs.rochester.edu), primarily for SBCL. The library was originally written by Adam Purtee, accompanied by the paper TTT: A tree transduction language for syntactic and semantic processing. Being the primary user of this library, I now maintain it and make extensions as I see fit. See a segment of the original README(below) for how to use it. The API has not changed save for a few additional keyword arguments and some new utility functions. First, load the library with Quicklisp (ql:quickload :ttt).

Quick Summary of TTT features 
-----------------------------
Switch to the package:
(in-package :ttt)

To match a single pattern expression against a single tree expression, do: 
(match-expr pattern-expression tree-expression)

To apply a rule to a tree-expression until converged, do: 
(apply-rule rule-expr tree-expr)

To apply a list of rules, do: 
(apply-rules rule-expr-list  tree-expr)

Both apply-rules and apply-rule have the keyword arguments:

:shallow   - when t, only apply rules to the root of tree-expr (default nil)
:max-n     - when supplied, limit the rule application to n iterations. 
             E.g, to apply a rule at most once, do 
             (apply-rule rule-expr tree-expr :max-n 1)
             or
             (apply-rules (list rule-expr) tree-expr :max-n 1)

:trace     - when t, displays debugging info to stdout
             otherwise, when non-nil write debugging info to a specified file, 
	     appending to the file if it already exists
              
             trace format is a tuple of lines per transduction:
              <rule expression>
              <tree before transduction>
              <tree after transduction>
              <blank line>
             
             apply-rule does not include the rule expression in the trace 
	     output, since the rule is determined at function call time.


apply-rules additionally supports the keyword argument :rule-order, with values
chosen among:

: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


The exported symbols are:
 match-expr, 
 apply-rule,
 apply-rules, and 
 store-pred. 

You can use these without being in the TTT package in your repl by prefixing the functions with ttt:. 
For example,  (ttt:match-expr '(a (! pattern tree)) '(a tree)). 
	   
To define a predicate which is a named TTT pattern, do: 
(mk-pred-ttt pred-name patt-expr)
<See pred-defs.lisp for examples>

To define a predicate name the predicate with ending 
symbol "?" and define it to accept a single tree 
expression as input.
Example: 
(defun binary? (tree)
  (if (atom tree)  ;; a leaf is a binary tree
      t
      (and (= (length tree) 2) ;; two children
	   (binary? (nth 0 tree))
	   (binary? (nth 1 tree)))))
(match-expr 'binary? '(X Y))
 => T
(match-expr 'binary? '(X Y Z))
 => nil
(match-expr '(H binary? K) (H (X (Y Z)) K))
 => T

If you define a predicate outside the TTT package, you must explictly 
call ttt:store-pred afterward in order for TTT to be aware of it. 


Ruleset syntax and example (for applying sets of rules):
(defparameter *rulset-name*
  (list
   rule-1
   rule-2
   ..
   rule-n
   ))

(defparameter *example-ruleset*
  '(
    (/ 
     (_* (NP _+ (PP _+1)) _*1)
     (_* (NP _+) (PP _+1) _*1))
    (/ 
     (_* (PP _+ (PP _+1)) _*1)
     (_* (PP _+) (PP _+1) _*1))
    (/ 
     (_* (VP _+ (PP _+1)) _*1)
     (_* (VP _+) (PP _+1) _*1))
    (/ 
     (_* (ADJP _+ (PP _+1)) _*1)
     (_* (ADJP _+) (PP _+1) _*1))
    (/ 
     (_* (WHNP _+ (PP _+1)) _*1)
     (_* (WHNP _+) (PP _+1) _*1))
    (/ 
     (_* ((! ~ NP PP VP ADJP WHNP) _+ (PP _+1)) _*1)
     (_* (! _+) (PP _+1) _*1))
    ))

Tests

Run tests with the ttt/tests package.

* (ql:quickload :ttt/tests)
* (in-package :ttt/tests)
* (run)

Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

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


Previous: , Up: Systems   [Contents][Index]

2.1 ttt

Author

Adam Purtee and Gene Louis Kim <gkim21@cs.rochester.edu>

License

GPLv3

Description

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

Version

2.0.0

Source

ttt.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

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


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 ttt.asd

Location

ttt.asd

Systems

ttt (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 ttt/package.lisp

Parent

ttt (system)

Location

package.lisp

Packages

ttt


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.3 ttt/types.lisp

Dependency

package.lisp (file)

Parent

ttt (system)

Location

types.lisp

Internal Definitions

tree-expr (type)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.4 ttt/operators.lisp

Dependency

types.lisp (file)

Parent

ttt (system)

Location

operators.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.5 ttt/expressions.lisp

Dependency

operators.lisp (file)

Parent

ttt (system)

Location

expressions.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.6 ttt/keys.lisp

Dependency

expressions.lisp (file)

Parent

ttt (system)

Location

keys.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.7 ttt/bindings.lisp

Dependency

keys.lisp (file)

Parent

ttt (system)

Location

bindings.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.8 ttt/trees.lisp

Dependency

bindings.lisp (file)

Parent

ttt (system)

Location

trees.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.9 ttt/patterns.lisp

Dependency

trees.lisp (file)

Parent

ttt (system)

Location

patterns.lisp

Exported Definitions

match-expr (function)

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.10 ttt/operators/unrestricted-seq.lisp

Dependency

patterns.lisp (file)

Parent

ttt (system)

Location

operators/unrestricted-seq.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.11 ttt/operators/restricted-seq.lisp

Dependency

operators/unrestricted-seq.lisp (file)

Parent

ttt (system)

Location

operators/restricted-seq.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.12 ttt/operators/fpseq-gen.lisp

Dependency

operators/restricted-seq.lisp (file)

Parent

ttt (system)

Location

operators/fpseq-gen.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.13 ttt/operators/descendant.lisp

Dependency

operators/fpseq-gen.lisp (file)

Parent

ttt (system)

Location

operators/descendant.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.14 ttt/operators/vertical.lisp

Dependency

operators/descendant.lisp (file)

Parent

ttt (system)

Location

operators/vertical.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.15 ttt/operators/literal.lisp

Dependency

operators/vertical.lisp (file)

Parent

ttt (system)

Location

operators/literal.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.16 ttt/sticky.lisp

Dependency

operators/literal.lisp (file)

Parent

ttt (system)

Location

sticky.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.17 ttt/predicates.lisp

Dependency

sticky.lisp (file)

Parent

ttt (system)

Location

predicates.lisp

Exported Definitions

store-pred (function)

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.18 ttt/template-construction.lisp

Dependency

predicates.lisp (file)

Parent

ttt (system)

Location

template-construction.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.19 ttt/transductions.lisp

Dependency

template-construction.lisp (file)

Parent

ttt (system)

Location

transductions.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.20 ttt/util.lisp

Dependency

transductions.lisp (file)

Parent

ttt (system)

Location

util.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.21 ttt/process-tb.lisp

Dependency

util.lisp (file)

Parent

ttt (system)

Location

process-tb.lisp

Internal Definitions

process-tb (function)


Previous: , Up: Lisp files   [Contents][Index]

3.1.22 ttt/search-tb.lisp

Dependency

process-tb.lisp (file)

Parent

ttt (system)

Location

search-tb.lisp

Internal Definitions

search-tb (function)


Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

4.1 ttt

the TTT (template to template transduction) package!

Source

package.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

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


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Functions

Function: apply-rule ()

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 (file)

Function: apply-rules ()

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 (file)

Function: hide-ttt-ops ()
Package

ttt

Source

util.lisp (file)

Function: match-expr ()

Added because the suffix expr is more meaningful than encap.

Package

ttt

Source

patterns.lisp (file)

Function: store-pred ()
Package

ttt

Source

predicates.lisp (file)

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

ttt

Source

util.lisp (file)

Function: ttt-apply-rule-possibilities ()
Package

ttt

Source

util.lisp (file)

Function: unhide-ttt-ops ()
Package

ttt

Source

util.lisp (file)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Special variables

Special Variable: *built-patterns*
Package

ttt

Source

patterns.lisp (file)

Special Variable: *invalid-suffix-chars*
Package

ttt

Source

operators.lisp (file)

Special Variable: *operation-table*
Package

ttt

Source

operators.lisp (file)

Special Variable: *predicate-table*
Package

ttt

Source

predicates.lisp (file)

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

ttt

Source

template-construction.lisp (file)

Special Variable: *ttt-debug-level*
Package

ttt

Source

patterns.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Functions

Function: add-binding ()

Nondestructively add the binding to bindings.

Package

ttt

Source

bindings.lisp (file)

Function: add-op ()

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 (file)

Function: add-to-index ()

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 (file)

Function: apply! ()

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 (file)

Function: bind-seq ()
Package

ttt

Source

bindings.lisp (file)

Function: bind-var ()
Package

ttt

Source

bindings.lisp (file)

Function: bound? ()

Return t if variable is bound, nil otherwise.

Package

ttt

Source

bindings.lisp (file)

Function: build-pattern ()

Builds a pattern object according to expression.

Package

ttt

Source

patterns.lisp (file)

Function: build-tree ()

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 (file)

Function: compile-helper ()

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

Package

ttt

Source

operators/fpseq-gen.lisp (file)

Function: concatenate-syms! ()

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 (file)

Function: copy-d-state ()
Package

ttt

Source

operators/descendant.lisp (file)

Function: copy-h-state ()
Package

ttt

Source

operators/fpseq-gen.lisp (file)

Function: copy-rs-state ()
Package

ttt

Source

operators/restricted-seq.lisp (file)

Function: copy-t-bind ()
Package

ttt

Source

transductions.lisp (file)

Function: copy-v-state ()
Package

ttt

Source

operators/vertical.lisp (file)

Function: d-state-depth ()
Function: (setf d-state-depth) ()
Package

ttt

Source

operators/descendant.lisp (file)

Function: d-state-node ()
Function: (setf d-state-node) ()
Package

ttt

Source

operators/descendant.lisp (file)

Function: d-state-p ()
Package

ttt

Source

operators/descendant.lisp (file)

Function: deep-match-brute ()

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

Package

ttt

Source

patterns.lisp (file)

Function: deep-substitute ()

Recursively replace all occurences of olditem in sequence with newitem.

Package

ttt

Source

template-construction.lisp (file)

Function: deepest-matches-brute ()

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 (file)

Function: do-transduction ()

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

Package

ttt

Source

transductions.lisp (file)

Function: ensure-compiled ()
Package

ttt

Source

operators/vertical.lisp (file)

Function: expr-height ()
Package

ttt

Source

expressions.lisp (file)

Function: extract-keys ()

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 (file)

Function: fastmap ()

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

Package

ttt

Source

keys.lisp (file)

Function: filter-ops ()

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 (file)

Function: get-/m ()
Package

ttt

Source

operators.lisp (file)

Function: get-/n ()
Package

ttt

Source

operators.lisp (file)

Function: get-binding ()

Return the binding for variable bvar in bindings.

Package

ttt

Source

bindings.lisp (file)

Function: get-matches ()

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 (file)

Function: get-op ()

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 (file)

Function: get-pred-fn ()

Return the function for the base predicate symbol.

Package

ttt

Source

predicates.lisp (file)

Function: get-pred-instance ()
Package

ttt

Source

predicates.lisp (file)

Function: get-var ()

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 (file)

Function: h-state-binds ()
Function: (setf h-state-binds) ()
Package

ttt

Source

operators/fpseq-gen.lisp (file)

Function: h-state-p ()
Package

ttt

Source

operators/fpseq-gen.lisp (file)

Function: h-state-pseq ()
Function: (setf h-state-pseq) ()
Package

ttt

Source

operators/fpseq-gen.lisp (file)

Function: h-state-tseq ()
Function: (setf h-state-tseq) ()
Package

ttt

Source

operators/fpseq-gen.lisp (file)

Function: join-with-dash! ()

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 (file)

Function: keys-to-filter-ops ()

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 (file)

Function: lispify-parser-output ()
Package

ttt

Source

util.lisp (file)

Function: listify ()
Package

ttt

Source

expressions.lisp (file)

Function: literal? ()

return t if sym can only match itself

Package

ttt

Source

operators.lisp (file)

Function: make-d-state ()
Package

ttt

Source

operators/descendant.lisp (file)

Function: make-h-state ()
Package

ttt

Source

operators/fpseq-gen.lisp (file)

Function: make-index ()
Package

ttt

Source

keys.lisp (file)

Function: make-rs-state ()
Package

ttt

Source

operators/restricted-seq.lisp (file)

Function: make-t-bind ()
Package

ttt

Source

transductions.lisp (file)

Function: make-v-state ()
Package

ttt

Source

operators/vertical.lisp (file)

Function: match-encap ()

Match a pattern expression against a tree expression.

Package

ttt

Source

patterns.lisp (file)

Function: mk-binding ()
Package

ttt

Source

bindings.lisp (file)

Function: mk-pred-ttt ()

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 (file)

Function: mk-tmp ()
Package

ttt

Source

bindings.lisp (file)

Function: mk-var ()
Package

ttt

Source

operators.lisp (file)

Function: nadd-binding ()

Destructively add the binding to bindings.

Package

ttt

Source

bindings.lisp (file)

Function: next-v-states ()
Package

ttt

Source

operators/vertical.lisp (file)

Function: op-is-pred? ()

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

Package

ttt

Source

operators.lisp (file)

Function: op-requires-args? ()

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

Package

ttt

Source

operators.lisp (file)

Function: patt-expr-get-op ()

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 (file)

Function: patt-expr-get-var ()

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

Package

ttt

Source

expressions.lisp (file)

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

ttt

Source

expressions.lisp (file)

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

ttt

Source

expressions.lisp (file)

Function: patt-expr-neg-args ()

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

Package

ttt

Source

expressions.lisp (file)

Function: patt-expr-pos-args ()

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

Package

ttt

Source

expressions.lisp (file)

Function: pred-sym-p ()

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

Package

ttt

Source

operators.lisp (file)

Function: preslash-unsafe-chars ()
Package

ttt

Source

util.lisp (file)

Function: process-tb ()

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 (file)

Function: purge-op ()

Purge op from the operation table.

Package

ttt

Source

operators.lisp (file)

Function: rs-state-a ()
Function: (setf rs-state-a) ()
Package

ttt

Source

operators/restricted-seq.lisp (file)

Function: rs-state-binds ()
Function: (setf rs-state-binds) ()
Package

ttt

Source

operators/restricted-seq.lisp (file)

Function: rs-state-m ()
Function: (setf rs-state-m) ()
Package

ttt

Source

operators/restricted-seq.lisp (file)

Function: rs-state-n ()
Function: (setf rs-state-n) ()
Package

ttt

Source

operators/restricted-seq.lisp (file)

Function: rs-state-p ()
Package

ttt

Source

operators/restricted-seq.lisp (file)

Function: rs-state-tseq ()
Function: (setf rs-state-tseq) ()
Package

ttt

Source

operators/restricted-seq.lisp (file)

Function: satisfies-constraints ()

STUB

Package

ttt

Source

bindings.lisp (file)

Function: search-tb ()

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

Package

ttt

Source

search-tb.lisp (file)

Function: sticky? ()

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

Package

ttt

Source

operators.lisp (file)

Function: subst-new! ()

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 (file)

Function: t-bind-p ()
Package

ttt

Source

transductions.lisp (file)

Function: t-bind-parent ()
Function: (setf t-bind-parent) ()
Package

ttt

Source

transductions.lisp (file)

Function: t-bind-parent-idx ()
Function: (setf t-bind-parent-idx) ()
Package

ttt

Source

transductions.lisp (file)

Function: t-bind-template-expr ()
Function: (setf t-bind-template-expr) ()
Package

ttt

Source

transductions.lisp (file)

Function: template-to-tree ()

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 (file)

Function: v-state-binds ()
Function: (setf v-state-binds) ()
Package

ttt

Source

operators/vertical.lisp (file)

Function: v-state-leading-vars ()
Function: (setf v-state-leading-vars) ()
Package

ttt

Source

operators/vertical.lisp (file)

Function: v-state-p ()
Package

ttt

Source

operators/vertical.lisp (file)

Function: v-state-pargs ()
Function: (setf v-state-pargs) ()
Package

ttt

Source

operators/vertical.lisp (file)

Function: v-state-tseq ()
Function: (setf v-state-tseq) ()
Package

ttt

Source

operators/vertical.lisp (file)

Function: valid-op-suffix ()

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

Package

ttt

Source

operators.lisp (file)

Function: variable? ()

return t if sym is an operator with a variable

Package

ttt

Source

operators.lisp (file)

Function: wrap-sticky-check ()
Package

ttt

Source

sticky.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Generic functions

Generic Function: children OBJECT
Generic Function: (setf children) NEW-VALUE OBJECT
Package

ttt

Methods
Method: children (TREE tree)

automatically generated reader method

Source

trees.lisp (file)

Method: (setf children) NEW-VALUE (TREE tree)

automatically generated writer method

Source

trees.lisp (file)

Generic Function: compile-pattern PATT
Package

ttt

Methods
Method: compile-pattern (PATT transduction)
Source

transductions.lisp (file)

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

sticky.lisp (file)

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 (file)

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

operators/vertical.lisp (file)

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

operators/vertical.lisp (file)

Method: compile-pattern (PATT descendant-patt)

Compile patterns with operators ^ ^^ ^* ^n

Source

operators/descendant.lisp (file)

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

operators/fpseq-gen.lisp (file)

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

operators/fpseq-gen.lisp (file)

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

operators/fpseq-gen.lisp (file)

Method: compile-pattern (PATT restricted-seq)

Set the match-fn for restricted sequence pattern patt.

Source

operators/restricted-seq.lisp (file)

Method: compile-pattern (PATT unrestricted-seq)

Set the match-fn for unrestriced sequence pattern patt.

Source

operators/unrestricted-seq.lisp (file)

Generic Function: compiled? OBJECT
Generic Function: (setf compiled?) NEW-VALUE OBJECT
Package

ttt

Methods
Method: compiled? (PATTERN pattern)

automatically generated reader method

Source

patterns.lisp (file)

Method: (setf compiled?) NEW-VALUE (PATTERN pattern)

automatically generated writer method

Source

patterns.lisp (file)

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 (file)

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 (file)

Generic Function: dfs-order OBJECT
Generic Function: (setf dfs-order) NEW-VALUE OBJECT
Package

ttt

Methods
Method: dfs-order (TREE tree)

automatically generated reader method

Source

trees.lisp (file)

Method: (setf dfs-order) NEW-VALUE (TREE tree)

automatically generated writer method

Source

trees.lisp (file)

Generic Function: height OBJECT
Generic Function: (setf height) NEW-VALUE OBJECT
Package

ttt

Methods
Method: height (TREE tree)

automatically generated reader method

Source

trees.lisp (file)

Method: (setf height) NEW-VALUE (TREE tree)

automatically generated writer method

Source

trees.lisp (file)

Generic Function: index OBJECT
Generic Function: (setf index) NEW-VALUE OBJECT
Package

ttt

Methods
Method: index (INDEX index)

automatically generated reader method

Source

keys.lisp (file)

Method: (setf index) NEW-VALUE (INDEX index)

automatically generated writer method

Source

keys.lisp (file)

Generic Function: initialized? OBJECT
Generic Function: (setf initialized?) NEW-VALUE OBJECT
Package

ttt

Methods
Method: initialized? (PATTERN pattern)

automatically generated reader method

Source

patterns.lisp (file)

Method: (setf initialized?) NEW-VALUE (PATTERN pattern)

automatically generated writer method

Source

patterns.lisp (file)

Generic Function: keys OBJECT
Generic Function: (setf keys) NEW-VALUE OBJECT
Package

ttt

Methods
Method: keys (PATTERN pattern)

automatically generated reader method

Source

patterns.lisp (file)

Method: (setf keys) NEW-VALUE (PATTERN pattern)

automatically generated writer method

Source

patterns.lisp (file)

Method: keys (TREE tree)

automatically generated reader method

Source

trees.lisp (file)

Method: (setf keys) NEW-VALUE (TREE tree)

automatically generated writer method

Source

trees.lisp (file)

Generic Function: leaf? NODE
Package

ttt

Methods
Method: leaf? (NODE tree)
Source

trees.lisp (file)

Generic Function: lhs OBJECT
Generic Function: (setf lhs) NEW-VALUE OBJECT
Package

ttt

Methods
Method: lhs (TRANSDUCTION transduction)

automatically generated reader method

Source

transductions.lisp (file)

Method: (setf lhs) NEW-VALUE (TRANSDUCTION transduction)

automatically generated writer method

Source

transductions.lisp (file)

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 (file)

Method: match (PATT pattern) TREE-SEQ BINDINGS

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

Source

patterns.lisp (file)

Generic Function: match-fn OBJECT
Generic Function: (setf match-fn) NEW-VALUE OBJECT
Package

ttt

Methods
Method: match-fn (PATTERN pattern)

automatically generated reader method

Source

patterns.lisp (file)

Method: (setf match-fn) NEW-VALUE (PATTERN pattern)

automatically generated writer method

Source

patterns.lisp (file)

Generic Function: max-depth OBJECT
Generic Function: (setf max-depth) NEW-VALUE OBJECT
Package

ttt

Methods
Method: max-depth (HAS-DEPTH-CONSTRAINTS has-depth-constraints)

automatically generated reader method

Source

patterns.lisp (file)

Method: (setf max-depth) NEW-VALUE (HAS-DEPTH-CONSTRAINTS has-depth-constraints)

automatically generated writer method

Source

patterns.lisp (file)

Generic Function: max-height OBJECT
Generic Function: (setf max-height) NEW-VALUE OBJECT
Package

ttt

Methods
Method: max-height (PATTERN pattern)

automatically generated reader method

Source

patterns.lisp (file)

Method: (setf max-height) NEW-VALUE (PATTERN pattern)

automatically generated writer method

Source

patterns.lisp (file)

Generic Function: max-iter OBJECT
Generic Function: (setf max-iter) NEW-VALUE OBJECT
Package

ttt

Methods
Method: max-iter (HAS-ITER-CONSTRAINTS has-iter-constraints)

automatically generated reader method

Source

patterns.lisp (file)

Method: (setf max-iter) NEW-VALUE (HAS-ITER-CONSTRAINTS has-iter-constraints)

automatically generated writer method

Source

patterns.lisp (file)

Generic Function: max-width OBJECT
Generic Function: (setf max-width) NEW-VALUE OBJECT
Package

ttt

Methods
Method: max-width (PATTERN pattern)

automatically generated reader method

Source

patterns.lisp (file)

Method: (setf max-width) NEW-VALUE (PATTERN pattern)

automatically generated writer method

Source

patterns.lisp (file)

Generic Function: min-depth OBJECT
Generic Function: (setf min-depth) NEW-VALUE OBJECT
Package

ttt

Methods
Method: min-depth (HAS-DEPTH-CONSTRAINTS has-depth-constraints)

automatically generated reader method

Source

patterns.lisp (file)

Method: (setf min-depth) NEW-VALUE (HAS-DEPTH-CONSTRAINTS has-depth-constraints)

automatically generated writer method

Source

patterns.lisp (file)

Generic Function: min-height OBJECT
Generic Function: (setf min-height) NEW-VALUE OBJECT
Package

ttt

Methods
Method: min-height (PATTERN pattern)

automatically generated reader method

Source

patterns.lisp (file)

Method: (setf min-height) NEW-VALUE (PATTERN pattern)

automatically generated writer method

Source

patterns.lisp (file)

Generic Function: min-iter OBJECT
Generic Function: (setf min-iter) NEW-VALUE OBJECT
Package

ttt

Methods
Method: min-iter (HAS-ITER-CONSTRAINTS has-iter-constraints)

automatically generated reader method

Source

patterns.lisp (file)

Method: (setf min-iter) NEW-VALUE (HAS-ITER-CONSTRAINTS has-iter-constraints)

automatically generated writer method

Source

patterns.lisp (file)

Generic Function: min-width OBJECT
Generic Function: (setf min-width) NEW-VALUE OBJECT
Package

ttt

Methods
Method: min-width (PATTERN pattern)

automatically generated reader method

Source

patterns.lisp (file)

Method: (setf min-width) NEW-VALUE (PATTERN pattern)

automatically generated writer method

Source

patterns.lisp (file)

Generic Function: nchildren OBJECT
Generic Function: (setf nchildren) NEW-VALUE OBJECT
Package

ttt

Methods
Method: nchildren (TREE tree)

automatically generated reader method

Source

trees.lisp (file)

Method: (setf nchildren) NEW-VALUE (TREE tree)

automatically generated writer method

Source

trees.lisp (file)

Generic Function: neg-args OBJECT
Generic Function: (setf neg-args) NEW-VALUE OBJECT
Package

ttt

Methods
Method: neg-args (HAS-NEG-ARGS has-neg-args)

automatically generated reader method

Source

patterns.lisp (file)

Method: (setf neg-args) NEW-VALUE (HAS-NEG-ARGS has-neg-args)

automatically generated writer method

Source

patterns.lisp (file)

Generic Function: parent OBJECT
Generic Function: (setf parent) NEW-VALUE OBJECT
Package

ttt

Methods
Method: parent (TREE tree)

automatically generated reader method

Source

trees.lisp (file)

Method: (setf parent) NEW-VALUE (TREE tree)

automatically generated writer method

Source

trees.lisp (file)

Generic Function: parent-idx OBJECT
Generic Function: (setf parent-idx) NEW-VALUE OBJECT
Package

ttt

Methods
Method: parent-idx (TREE tree)

automatically generated reader method

Source

trees.lisp (file)

Method: (setf parent-idx) NEW-VALUE (TREE tree)

automatically generated writer method

Source

trees.lisp (file)

Generic Function: patt OBJECT
Generic Function: (setf patt) NEW-VALUE OBJECT
Package

ttt

Methods
Method: patt (PREDICATE-PATT predicate-patt)

automatically generated reader method

Source

predicates.lisp (file)

Method: (setf patt) NEW-VALUE (PREDICATE-PATT predicate-patt)

automatically generated writer method

Source

predicates.lisp (file)

Generic Function: pos-args OBJECT
Generic Function: (setf pos-args) NEW-VALUE OBJECT
Package

ttt

Methods
Method: pos-args (HAS-POS-ARGS has-pos-args)

automatically generated reader method

Source

patterns.lisp (file)

Method: (setf pos-args) NEW-VALUE (HAS-POS-ARGS has-pos-args)

automatically generated writer method

Source

patterns.lisp (file)

Generic Function: rhs OBJECT
Generic Function: (setf rhs) NEW-VALUE OBJECT
Package

ttt

Methods
Method: rhs (TRANSDUCTION transduction)

automatically generated reader method

Source

transductions.lisp (file)

Method: (setf rhs) NEW-VALUE (TRANSDUCTION transduction)

automatically generated writer method

Source

transductions.lisp (file)

Generic Function: to-expr OBJECT
Generic Function: (setf to-expr) NEW-VALUE OBJECT
Package

ttt

Methods
Method: to-expr (PATTERN pattern)

automatically generated reader method

Source

patterns.lisp (file)

Method: (setf to-expr) NEW-VALUE (PATTERN pattern)

automatically generated writer method

Source

patterns.lisp (file)

Method: to-expr (TREE tree)

automatically generated reader method

Source

trees.lisp (file)

Method: (setf to-expr) NEW-VALUE (TREE tree)

automatically generated writer method

Source

trees.lisp (file)

Generic Function: to-subtrees OBJECT
Generic Function: (setf to-subtrees) NEW-VALUE OBJECT
Package

ttt

Methods
Method: to-subtrees (TREE tree)

automatically generated reader method

Source

trees.lisp (file)

Method: (setf to-subtrees) NEW-VALUE (TREE tree)

automatically generated writer method

Source

trees.lisp (file)

Generic Function: ttt-pred OBJECT
Generic Function: (setf ttt-pred) NEW-VALUE OBJECT
Package

ttt

Methods
Method: ttt-pred (PREDICATE-PATT predicate-patt)

automatically generated reader method

Source

predicates.lisp (file)

Method: (setf ttt-pred) NEW-VALUE (PREDICATE-PATT predicate-patt)

automatically generated writer method

Source

predicates.lisp (file)

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 (file)

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 (file)

Generic Function: var OBJECT
Generic Function: (setf var) NEW-VALUE OBJECT
Package

ttt

Methods
Method: var (PATTERN pattern)

automatically generated reader method

Source

patterns.lisp (file)

Method: (setf var) NEW-VALUE (PATTERN pattern)

automatically generated writer method

Source

patterns.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Structures

Structure: d-state ()
Package

ttt

Source

operators/descendant.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: depth
Readers

d-state-depth (function)

Writers

(setf d-state-depth) (function)

Slot: node
Readers

d-state-node (function)

Writers

(setf d-state-node) (function)

Structure: h-state ()
Package

ttt

Source

operators/fpseq-gen.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: pseq
Readers

h-state-pseq (function)

Writers

(setf h-state-pseq) (function)

Slot: tseq
Readers

h-state-tseq (function)

Writers

(setf h-state-tseq) (function)

Slot: binds
Readers

h-state-binds (function)

Writers

(setf h-state-binds) (function)

Structure: rs-state ()
Package

ttt

Source

operators/restricted-seq.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: n
Readers

rs-state-n (function)

Writers

(setf rs-state-n) (function)

Slot: m
Readers

rs-state-m (function)

Writers

(setf rs-state-m) (function)

Slot: a
Readers

rs-state-a (function)

Writers

(setf rs-state-a) (function)

Slot: tseq
Readers

rs-state-tseq (function)

Writers

(setf rs-state-tseq) (function)

Slot: binds
Readers

rs-state-binds (function)

Writers

(setf rs-state-binds) (function)

Structure: t-bind ()
Package

ttt

Source

transductions.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: parent
Readers

t-bind-parent (function)

Writers

(setf t-bind-parent) (function)

Slot: parent-idx
Readers

t-bind-parent-idx (function)

Writers

(setf t-bind-parent-idx) (function)

Slot: template-expr
Readers

t-bind-template-expr (function)

Writers

(setf t-bind-template-expr) (function)

Structure: v-state ()
Package

ttt

Source

operators/vertical.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: pargs
Readers

v-state-pargs (function)

Writers

(setf v-state-pargs) (function)

Slot: tseq
Readers

v-state-tseq (function)

Writers

(setf v-state-tseq) (function)

Slot: binds
Readers

v-state-binds (function)

Writers

(setf v-state-binds) (function)

Slot: leading-vars
Readers

v-state-leading-vars (function)

Writers

(setf v-state-leading-vars) (function)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

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 (file)

Direct superclasses
Direct methods

compile-pattern (method)

Class: free-seq ()

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

Package

ttt

Source

operators/fpseq-gen.lisp (file)

Direct superclasses
Direct methods

compile-pattern (method)

Class: general-patt ()

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

Package

ttt

Source

operators/fpseq-gen.lisp (file)

Direct superclasses
Direct methods

compile-pattern (method)

Class: has-depth-constraints ()
Package

ttt

Source

patterns.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

descendant-patt (class)

Direct methods
Direct slots
Slot: min-depth
Type

fixnum

Initform

0

Readers

min-depth (generic function)

Writers

(setf min-depth) (generic function)

Slot: max-depth
Type

fixnum

Initform

most-positive-fixnum

Readers

max-depth (generic function)

Writers

(setf max-depth) (generic function)

Class: has-iter-constraints ()
Package

ttt

Source

patterns.lisp (file)

Direct superclasses

standard-object (class)

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

fixnum

Initargs

:min-iter

Readers

min-iter (generic function)

Writers

(setf min-iter) (generic function)

Slot: max-iter
Type

fixnum

Initargs

:max-iter

Readers

max-iter (generic function)

Writers

(setf max-iter) (generic function)

Class: has-neg-args ()
Package

ttt

Source

patterns.lisp (file)

Direct superclasses

standard-object (class)

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

list

Initargs

:neg-args

Readers

neg-args (generic function)

Writers

(setf neg-args) (generic function)

Class: has-pos-args ()
Package

ttt

Source

patterns.lisp (file)

Direct superclasses

standard-object (class)

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

list

Initargs

:pos-args

Readers

pos-args (generic function)

Writers

(setf pos-args) (generic function)

Class: index ()
Package

ttt

Source

keys.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
  • index (method)
  • index (method)
Direct slots
Slot: index
Type

(simple-array hash-table *)

Readers

index (generic function)

Writers

(setf index) (generic function)

Class: literal-patt ()

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

Package

ttt

Source

operators/literal.lisp (file)

Direct superclasses

pattern (class)

Direct methods

compile-pattern (method)

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 (file)

Direct superclasses

standard-object (class)

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

fixnum

Initargs

:min-width

Initform

0

Readers

min-width (generic function)

Writers

(setf min-width) (generic function)

Slot: max-width
Type

fixnum

Initargs

:max-width

Initform

most-positive-fixnum

Readers

max-width (generic function)

Writers

(setf max-width) (generic function)

Slot: min-height
Type

fixnum

Initform

0

Readers

min-height (generic function)

Writers

(setf min-height) (generic function)

Slot: max-height
Type

fixnum

Initform

most-positive-fixnum

Readers

max-height (generic function)

Writers

(setf max-height) (generic function)

Slot: keys
Type

list

Readers

keys (generic function)

Writers

(setf keys) (generic function)

Slot: compiled?
Readers

compiled? (generic function)

Writers

(setf compiled?) (generic function)

Slot: initialized?
Initargs

:initialized?

Readers

initialized? (generic function)

Writers

(setf initialized?) (generic function)

Slot: to-expr
Type

ttt::tree-expr

Readers

to-expr (generic function)

Writers

(setf to-expr) (generic function)

Slot: match-fn
Type

function

Readers

match-fn (generic function)

Writers

(setf match-fn) (generic function)

Slot: var
Initargs

:var

Readers

var (generic function)

Writers

(setf var) (generic function)

Class: permuted-seq ()

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

Package

ttt

Source

operators/fpseq-gen.lisp (file)

Direct superclasses
Direct methods

compile-pattern (method)

Class: point-of-attachment ()
Package

ttt

Source

operators/vertical.lisp (file)

Direct superclasses

pattern (class)

Direct methods

compile-pattern (method)

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 (file)

Direct superclasses

pattern (class)

Direct methods
Direct slots
Slot: patt
Readers

patt (generic function)

Writers

(setf patt) (generic function)

Slot: ttt-pred
Readers

ttt-pred (generic function)

Writers

(setf ttt-pred) (generic function)

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 (file)

Direct superclasses
Direct methods

compile-pattern (method)

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 (file)

Direct superclasses

pattern (class)

Direct methods

compile-pattern (method)

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 (file)

Direct superclasses

pattern (class)

Direct methods
Direct slots
Slot: lhs
Readers

lhs (generic function)

Writers

(setf lhs) (generic function)

Slot: rhs
Readers

rhs (generic function)

Writers

(setf rhs) (generic function)

Class: tree ()
Package

ttt

Source

trees.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: children
Type

ttt::tree-expr

Readers

children (generic function)

Writers

(setf children) (generic function)

Slot: to-expr
Type

ttt::tree-expr

Readers

to-expr (generic function)

Writers

(setf to-expr) (generic function)

Slot: nchildren
Type

fixnum

Readers

nchildren (generic function)

Writers

(setf nchildren) (generic function)

Slot: height
Type

fixnum

Readers

height (generic function)

Writers

(setf height) (generic function)

Slot: keys
Readers

keys (generic function)

Writers

(setf keys) (generic function)

Slot: to-subtrees
Readers

to-subtrees (generic function)

Writers

(setf to-subtrees) (generic function)

Slot: parent
Readers

parent (generic function)

Writers

(setf parent) (generic function)

Slot: parent-idx
Readers

parent-idx (generic function)

Writers

(setf parent-idx) (generic function)

Slot: dfs-order
Readers

dfs-order (generic function)

Writers

(setf dfs-order) (generic function)

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 (file)

Direct superclasses
Direct methods

compile-pattern (method)

Class: vertical-patt ()

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

Package

ttt

Source

operators/vertical.lisp (file)

Direct superclasses
Direct methods

compile-pattern (method)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.6 Types

Type: tree-expr ()
Package

ttt

Source

types.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   T  
Index Entry  Section

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

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

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

Jump to:   F   L   T  

Next: , Previous: , Up: Indexes   [Contents][Index]

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

A
add-binding: Internal functions
add-op: Internal functions
add-to-index: Internal functions
apply!: Internal functions
apply-rule: Exported functions
apply-rules: Exported functions

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

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

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

E
ensure-compiled: Internal functions
expr-height: Internal functions
extract-keys: Internal functions

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

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

H
h-state-binds: Internal functions
h-state-p: Internal functions
h-state-pseq: Internal functions
h-state-tseq: Internal functions
height: Internal generic functions
height: Internal generic functions
hide-ttt-ops: Exported functions

I
index: Internal generic functions
index: Internal generic functions
initialized?: Internal generic functions
initialized?: Internal generic functions

J
join-with-dash!: Internal functions

K
keys: Internal generic functions
keys: Internal generic functions
keys: Internal generic functions
keys-to-filter-ops: Internal functions

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

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

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

O
op-is-pred?: Internal functions
op-requires-args?: Internal functions

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

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

S
satisfies-constraints: Internal functions
search-tb: Internal functions
sticky?: Internal functions
store-pred: Exported functions
subst-new!: Internal functions

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

U
unhide-ttt-ops: Exported functions
update-dfs-order: Internal generic functions
update-dfs-order: Internal generic functions
update-subtree-index: Internal generic functions
update-subtree-index: Internal generic functions

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

W
wrap-sticky-check: Internal 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  

Next: , Previous: , Up: Indexes   [Contents][Index]

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*: Internal special variables
*invalid-suffix-chars*: Internal special variables
*operation-table*: Internal special variables
*predicate-table*: Internal special variables
*subst-new-next-int*: Internal special variables
*ttt-debug-level*: Internal special variables

A
a: Internal structures

B
binds: Internal structures
binds: Internal structures
binds: Internal structures

C
children: Internal classes
compiled?: Internal classes

D
depth: Internal structures
dfs-order: Internal classes

H
height: Internal classes

I
index: Internal classes
initialized?: Internal classes

K
keys: Internal classes
keys: Internal classes

L
leading-vars: Internal structures
lhs: Internal classes

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

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

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

R
rhs: Internal classes

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

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

V
var: Internal classes

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

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

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

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

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

F
free-seq: Internal classes

G
general-patt: Internal classes

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

I
index: Internal classes

L
literal-patt: Internal classes

P
Package, ttt: The ttt package
pattern: Internal classes
permuted-seq: Internal classes
point-of-attachment: Internal classes
predicate-patt: Internal classes

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

S
Structure, d-state: Internal structures
Structure, h-state: Internal structures
Structure, rs-state: Internal structures
Structure, t-bind: Internal structures
Structure, v-state: Internal structures
stuck-patt: Internal classes
System, ttt: The ttt system

T
t-bind: Internal structures
transduction: Internal classes
tree: Internal classes
tree-expr: Internal types
ttt: The ttt system
ttt: The ttt package
Type, tree-expr: Internal types

U
unrestricted-seq: Internal classes

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

Jump to:   C   D   F   G   H   I   L   P   R   S   T   U   V