The rte Reference Manual

This is the rte Reference Manual, version 1.1.14, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Feb 15 07:21:40 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 rte

Regular type expressions implementation

Author

Jim Newton

License

MIT

Version

1.1.14

Dependencies
  • ndfa (system).
  • adjuvant (system).
  • lisp-types (system).
Source

rte.asd.

Child Component

src (module).


3 Modules

Modules are listed depth-first from the system components tree.


3.1 rte/src

Source

rte.asd.

Parent Component

rte (system).

Child Components

4 Files

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


4.1 Lisp


4.1.1 rte/rte.asd

Source

rte.asd.

Parent Component

rte (system).

ASDF Systems

rte.


4.1.2 rte/src/rte.lisp

Source

rte.asd.

Parent Component

src (module).

Packages

regular-type-expression.

Internals

4.1.3 rte/src/asdf.lisp

Dependency

rte.lisp (file).

Source

rte.asd.

Parent Component

src (module).


4.1.4 rte/src/expand-typedef.lisp

Dependency

rte.lisp (file).

Source

rte.asd.

Parent Component

src (module).

Internals

expand-my-typedef (function).


4.1.5 rte/src/list-of.lisp

Dependencies
Source

rte.asd.

Parent Component

src (module).

Public Interface

list-of (type).

Internals

car*-cdr-of (type).


4.1.6 rte/src/dependents.lisp

Dependency

rte.lisp (file).

Source

rte.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.7 rte/src/derivative.lisp

Dependency

rte.lisp (file).

Source

rte.asd.

Parent Component

src (module).

Public Interface

canonicalize-pattern (function).

Internals

4.1.8 rte/src/rte-state-machine.lisp

Dependency

rte.lisp (file).

Source

rte.asd.

Parent Component

src (module).

Public Interface
Internals

rte-state-machine (class).


4.1.9 rte/src/dump-code.lisp

Dependencies
Source

rte.asd.

Parent Component

src (module).

Internals

4.1.10 rte/src/strategy-inline.lisp

Dependencies
Source

rte.asd.

Parent Component

src (module).

Internals

4.1.11 rte/src/strategy-goto.lisp

Dependencies
Source

rte.asd.

Parent Component

src (module).

Internals

4.1.12 rte/src/strategy-tail-call.lisp

Dependencies
Source

rte.asd.

Parent Component

src (module).

Internals

4.1.13 rte/src/strategy-trampoline.lisp

Dependencies
Source

rte.asd.

Parent Component

src (module).

Internals

4.1.14 rte/src/strategy-jump-table.lisp

Dependencies
Source

rte.asd.

Parent Component

src (module).

Internals

strategy-jump-table (class).


4.1.15 rte/src/re-pattern.lisp

Dependencies
Source

rte.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.16 rte/src/rte-case.lisp

Dependency

rte.lisp (file).

Source

rte.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.17 rte/src/destructuring-case.lisp

Dependency

re-pattern.lisp (file).

Source

rte.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.18 rte/src/prolog.lisp

Dependency

rte.lisp (file).

Source

rte.asd.

Parent Component

src (module).

Internals

5 Packages

Packages are listed by definition order.


5.1 regular-type-expression

Source

rte.lisp.

Nickname

rte

Use List
  • adjuvant.
  • common-lisp.
  • lisp-types.
  • non-deterministic-finite-automata.
Public Interface
Internals

6 Definitions

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


6.1 Public Interface


6.1.1 Macros

Macro: defrte (rte-name pattern)

Declare a given RTE pattern so that that it can be used when loaded from fasl or referenced symbolically be another rte.

Package

regular-type-expression.

Source

re-pattern.lisp.

Macro: destructuring-case (object-form &body clauses)

Similar to CASE except that the object is matched against destructuring-lambda-lists and declared type constraints. The first clauses matching the structure and types is evaluated. Each clause is of the form (destructuring-lambda-lists &body BODY).
Where BODY may have docstring and declarations. The type constraints will
be extracted from the (declare ... (type ...)) forms.
E.g.,
(destructuring-case ’(1 2 :x 3)
((a b c)
(declare (integer a b) (symbol c))
:first)
((a &optional (b 0) &key (x 0) (y 0))
(declare (integer a b x y))
:second))
==> :second

Package

regular-type-expression.

Source

destructuring-case.lisp.

Macro: destructuring-methods (object-form (&key call-next-method) &body clauses)

A variant of DESTRUCTURING-CASE, but allows a call-next-method feature.
The first matching clause is executed, if it calls the call-next-method function then the next matching method is executed.
The call-next-method function defaults to CALL-NEXT-METHOD, but may be renamed using the :CALL-NEXT-METHOD keyword argument.
E.g.
(destructuring-methods ’(1 2 3) (:call-next-method cnm)
((a b c)
(declare (type number a b c))
(* 2 (or (cnm) 1)))
((a b c)
(declare (type fixnum a b c))
3))

Package

regular-type-expression.

Source

destructuring-case.lisp.

Macro: rte-case (object-form &body clauses)

OBJECT-FORM is the form to be evaluated,
CLAUSES is a list of sublists, each sublist can be destructured as: (RATIONAL-TYPE-EXPRESSION &REST BODY)

Package

regular-type-expression.

Source

rte-case.lisp.

Macro: rte-ecase (object-form &body clauses)

OBJECT-FORM is the form to be evaluated,
CLAUSES is a list of sublists, each sublist can be destructured as: (RATIONAL-TYPE-EXPRESSION &REST BODY)

Package

regular-type-expression.

Source

rte-case.lisp.


6.1.2 Ordinary functions

Function: canonicalize-pattern (re)

Given a regular-type-expression, return a canonical form.

Package

regular-type-expression.

Source

derivative.lisp.

Function: rte-reset ()

Forget all regular type expressions.

Package

regular-type-expression.

Source

re-pattern.lisp.


6.1.3 Standalone methods

Method: calc-sticky-states ((sm rte-state-machine))
Package

non-deterministic-finite-automata.

Source

re-pattern.lisp.

Method: perform-some-transitions ((ndfa rte-state-machine) starting-states input-sequence)
Package

non-deterministic-finite-automata.

Source

re-pattern.lisp.

Method: populate-synchronized-product ((sm-product rte-state-machine) (sm1 rte-state-machine) (sm2 rte-state-machine) &key boolean-function minimize complement-transition-label merge-transition-labels final-state-callback)
Package

non-deterministic-finite-automata.

Source

rte-state-machine.lisp.

Method: print-object ((dep dependent) stream)
Source

dependents.lisp.

Method: print-object ((rte rte-state-machine) stream)
Source

rte-state-machine.lisp.

Method: update-dependent ((class standard-class) (dep dependent) &rest init-args)
Package

sb-mop.

Source

dependents.lisp.


6.1.4 Types

Type: list-of (element-type)

Matches possibly empty list such that each element matches ELEMENT-TYPE

Package

regular-type-expression.

Source

list-of.lisp.

Type: rte (pattern)

Matches a list whose types constitute ’words’ in a rational
language described by the given rational expression. The PATTERN must either be a valid lisp type specifier or a list whose (car PATTERN) is a keyword of type RTE-KEYWORD, and each element of (cdr PATTERN) is a valid regular type expression.

:0-* – matches the types of zero or more successive list elements, E.g, :1-* – matches the types of one or more successive list elements :0-1 – matches the type optionally (zero or one) list element
:or – specifies a logical disjunction of rational expressions
:and – specifies a logical conjunction of rational expressions
:cat – in order concatenation of rational expressions
:permute – specifies any-order concatenation of rational expressions

(typep ’(nil x 1 y 2 z 3 (x) nil (y) nil)
’(rte (:0-1 null)
(:1-* symbol number)
(:0-* list null)))

(typep ’(nil x 1 11 y 2 22 z 3 33 (x) nil (y) nil)
’(rte (:0-1 null)
(:or (:1-* symbol number)
(:1-* symbol number number))
(:0-* list null)))

Package

regular-type-expression.

Source

re-pattern.lisp.


6.2 Internals


6.2.1 Special variables

Special Variable: *dump-code-strategy*
Package

regular-type-expression.

Source

re-pattern.lisp.

Special Variable: *rte-hash*

Hash table storing named rte’s for reuse by (:rte ...) within an rte pattern

Package

regular-type-expression.

Source

re-pattern.lisp.

Special Variable: *rte-pattern-functions*

List of function names created by MAKE-RTE-FUNCTION-NAME

Package

regular-type-expression.

Source

re-pattern.lisp.

Special Variable: *rte-types*

Hash table mapping rte-pattern to lisp-type:
E.g., ((1-* SYMBOL NUMBER)) –> (AND SEQUENCE (SATISFIES " "((:1-* SYMBOL NUMBER))))

Package

regular-type-expression.

Source

rte.lisp.

Special Variable: *state-machines*

Hash table mapping rte pattern to state-machine object.

Package

regular-type-expression.

Source

rte.lisp.

Special Variable: *type-functions*

Hash tble mapping parameterized type name to function which can be used with (SATISFIES ...)

Package

regular-type-expression.

Source

rte.lisp.


6.2.2 Macros

Macro: destructuring-case-alt (object-form &body clauses)

Symantically similar to CASE except that the object is matched against destructuring-lambda-lists and optional type constraints. The first clauses matching the structure and types is evaluated. Each clause is of the form (destructuring-lambda-lists constraint-alist &body body)
Where constraint-alist is an car/cdr alist mapping a type specifier to a list of variable
names of that type. The variables will be implicitly declared in the body.
E.g.,
(destructuring-case-alt ’(1 2 :x 3)
((a b c) ((integer a b) (symbol c))
:first)
((a &optional (b 0) &key (x 0) (y 0)) ((integer a b x y))
:second))
==> :second

Package

regular-type-expression.

Source

destructuring-case.lisp.


6.2.3 Ordinary functions

Function: alphabetize (patterns)

non-descructively sort a list of patterns into a canonical order.

Package

regular-type-expression.

Source

re-pattern.lisp.

Function: canonicalize-pattern-once (re)

Given a regular-type-expression, return a more canonical form. This attempts to create an (:or ..) of (:and ...)’s, and removing or resolving redundant or trivial type designators. CANONICALIZE-PATTERN calls this function multiple times until a fixed point is found.

Package

regular-type-expression.

Source

derivative.lisp.

Function: compile-and-serialize (pathname compile)
Package

regular-type-expression.

Source

prolog.lisp.

Function: complexity (object)

Returns the number of cons cells in the given hierarchical list

Package

regular-type-expression.

Source

prolog.lisp.

Function: define-rte (pattern)
Package

regular-type-expression.

Source

re-pattern.lisp.

Function: derivative (pattern wrt-type)

Calculate the rational derivate of the given pattern.

Package

regular-type-expression.

Source

derivative.lisp.

Function: destructuring-lambda-list-to-rte (lambda-list &key type-specifiers)

Generate an RTE (regular type expression) given a destructuring-lambda-list.
If TYPE-SPECIFIERS is given it should be an alist (car/cadr) mapping variables
in the lambda list to cl type specifiers. Such a list can be computed by calling
the function GATHER-TYPE-DECLARATIONS given a list whose leading elements are
zero or more (declare ...) forms some of which contain type declarations.

A destructuring lambda list has the following syntax:

reqvars::= var*
optvars::= [&optional {var | (var [init-form [supplied-p-parameter]])}*]
restvar::= [{&rest | &body} var]
keyvars::= [&key {var | ({var | (keyword-name var)} [init-form [supplied-p-parameter]])}* [&allow-other-keys]]
auxvars::= [&aux {var | (var [init-form])}*]
wholevar::= [&whole var]
lambda-list::= (wholevar reqvars optvars restvar keyvars auxvars)

Not supporting this syntax -> (wholevar reqvars optvars . var)

Package

regular-type-expression.

Source

destructuring-case.lisp.

Function: equivalent-patterns (rte1 rte2)
Package

regular-type-expression.

Source

re-pattern.lisp.

Function: expand-destructuring-case-alt (object-form clauses)

OBJECT-FORM is the form to be evaluated,
CLAUSES is a list of sublists, each sublist can be destructured as: (LAMBDA-LIST CONSTRAINTS &REST BODY) where CONSTRAINTS is a car/cdr alist mapping each type specifiers to a list of
variable names. e.g., ((number a b c) ((or string symbol) x y z))

Package

regular-type-expression.

Source

destructuring-case.lisp.

Function: expand-destructuring-methods (object-form clauses call-next-method)
Package

regular-type-expression.

Source

destructuring-case.lisp.

Function: expand-my-typedef (type args unary-function &key function-name)
Package

regular-type-expression.

Source

expand-typedef.lisp.

Function: find-key-variable (keyvar lambda-list)

an &key argument in a lambda list can be declared in several different ways. FIND-KEY-VARIABLE finds and returns the variable (symbol or destructuring-list) associated with the given KEYVAR form

Package

regular-type-expression.

Source

destructuring-case.lisp.

Function: find-keyword (keyvar lambda-list)

an &key argument in a lambda list can be declared in several different ways. FIND-KEYWORD finds and returns the keyword (symbol from keyword package) associated with the given KEYVAR form

Package

regular-type-expression.

Source

destructuring-case.lisp.

Function: find-state-machine (pattern)
Package

regular-type-expression.

Source

re-pattern.lisp.

Function: first-types (pattern)
Package

regular-type-expression.

Source

re-pattern.lisp.

Function: gather-type-declarations (body)

BODY is the body of some destructuring-bind form. This function, gather-type-declaration, examines zero, one, or more declarations in the leading position of the body to find type declarations. An assoc list (car/cadr) is returned of the form
((var1 typespec1) (var2 typespec2)...)
If the same variable is declared more than once, the resulting type is the intersection of the individual types.

CL-SPEC> Declaration TYPE
...
CL-SPEC> If nested type declarations refer to the same variable, then the value of the CL-SPEC> variable must be a member of the intersection of the declared types.

Package

regular-type-expression.

Source

destructuring-case.lisp.

Function: get-patterns ()
Package

regular-type-expression.

Source

prolog.lisp.

Function: make-rte-function-name (pattern)
Package

regular-type-expression.

Source

re-pattern.lisp.

Function: nullable (re)
Package

regular-type-expression.

Source

re-pattern.lisp.

Function: partition-by-predicate (predicate data)
Package

regular-type-expression.

Source

re-pattern.lisp.

Function: register-dependents (sm)
Package

regular-type-expression.

Source

dependents.lisp.

Function: remember-state-machine (sm pattern)
Package

regular-type-expression.

Source

re-pattern.lisp.

Function: remove-redundant-types (patterns operator)

Given the operand list of either :or or :and, return a new operand list understand some basic logical reductions based on super-typeness.

Package

regular-type-expression.

Source

re-pattern.lisp.

Function: rte-case-clauses-to-dfa (clauses &key reduce disjoint-clauses view)

Helper function for rte-case. Parses the clauses to compute three objects:
1) the list of unreachable-bodys
2) the dfa
3) a pair (transit boolean), the boolean indicates whether there is a transit through the dfa which does correspond to one of the given clauses. If the boolean is TRUE then the transit indicates a list of type specifiers of such an object.

Package

regular-type-expression.

Source

rte-case.lisp.

Function: rte-case-expander (object-form clauses &key complain-remainder view)
Package

regular-type-expression.

Source

rte-case.lisp.

Function: rte-expand-type (type-name)
Package

regular-type-expression.

Source

re-pattern.lisp.

Function: rte-synchronized-product (dfas &key minimize boolean-function)
Package

regular-type-expression.

Source

rte-case.lisp.

Function: rte-to-dfa (pattern &key trim reduce final-body clause-index)

Create and return a finite state machine (ndfa) which can be used to determine if a given list consists of values whose types match PATTERN.

Package

regular-type-expression.

Source

re-pattern.lisp.

Function: serialize-functions (stream &optional patterns)
Package

regular-type-expression.

Source

prolog.lisp.

Function: sort-patterns (patterns)

Returns a sorted list of regular type expression patterns. The sorted order ensures that if pattern-B references pattern-A, then pattern-A appears earlier in the list than pattern-B. This sorting is done naively: If pattern-B references pattern-A, then the total number of cons cells of pattern-B must be larger than that of pattern-A, thus the list is sorted by complexity, otherwise the sort order is non-deterministic.

Package

regular-type-expression.

Source

prolog.lisp.

Function: swap-type-specifier-alist (constraint-alist)

constraint-alist is an car/cdr alist mapping each type specifiers to a list of variable names. e.g., ((number a b c) ((or string symbol) x y z)) RETURNS an alist mapping each variable name to its type specifier.
If any variable appears more than once in the given constraint-alist, the corresponding types are intersected in the return alist.

Package

regular-type-expression.

Source

destructuring-case.lisp.

Function: test-illustrate-dfas (pattern previous-patterns derived-pattern)
Package

regular-type-expression.

Source

destructuring-case.lisp.

Function: trampoline (xyzzy)
Package

regular-type-expression.

Source

strategy-trampoline.lisp.

Function: traverse-pattern (pattern &rest functions &key client f-0-* f-1-* f-0-1 f-and f-or f-not f-cat f-permutations f-empty-word f-empty-set f-type)

Walk a regular type expression, stopping at nodes which designate lisp types.
The given functions F-0-*, F-1-*, etc are called on each node to continue the traversal.
The default behavior is to walk to list and copy it, however the behavior and return value actuall depend on the choice of F-... function given.

Package

regular-type-expression.

Source

re-pattern.lisp.

Function: uniquify (objects)
Package

regular-type-expression.

Source

re-pattern.lisp.

Function: with-expanded-type (type-name f-original f-expanded)
Package

regular-type-expression.

Source

re-pattern.lisp.


6.2.4 Generic functions

Generic Function: dump-code (object strategy &key var)
Package

regular-type-expression.

Source

dump-code.lisp.

Methods
Method: dump-code ((ndfa rte-state-machine) strategy &key var)
Source

re-pattern.lisp.

Method: dump-code ((pattern list) strategy &key var)
Source

re-pattern.lisp.

Method: dump-code ((ndfa rte-state-machine) (strategy strategy-inline) &key var)
Source

strategy-inline.lisp.

Generic Function: dump-state (strategy state-name dumped-case)
Package

regular-type-expression.

Source

strategy-inline.lisp.

Methods
Method: dump-state ((strategy strategy-trampoline) state-name dumped-case)
Source

strategy-trampoline.lisp.

Method: dump-state ((strategy strategy-tail-call) state-name dumped-case)
Source

strategy-tail-call.lisp.

Method: dump-state ((strategy strategy-goto) state-name dumped-case)
Source

strategy-goto.lisp.

Generic Function: format-state-dispatch (strategy initial-state-name dumped-states)
Package

regular-type-expression.

Source

strategy-inline.lisp.

Methods
Method: format-state-dispatch ((strategy strategy-trampoline) initial-state-name dumped-states)
Source

strategy-trampoline.lisp.

Method: format-state-dispatch ((strategy strategy-tail-call) initial-state-name dumped-states)
Source

strategy-tail-call.lisp.

Method: format-state-dispatch ((strategy strategy-goto) initial-state-name dumped-states)
Source

strategy-goto.lisp.

Generic Function: goto-next-state (strategy state-name)
Package

regular-type-expression.

Source

strategy-inline.lisp.

Methods
Method: goto-next-state ((strategy strategy-trampoline) state-name)
Source

strategy-trampoline.lisp.

Method: goto-next-state ((strategy strategy-tail-call) state-name)
Source

strategy-tail-call.lisp.

Method: goto-next-state ((strategy strategy-goto) state-name)
Source

strategy-goto.lisp.

Generic Function: match-sequence (input-sequence pattern)
Package

regular-type-expression.

Source

re-pattern.lisp.

Methods
Method: match-sequence (input-sequence (pattern list))
Method: match-sequence (input-sequence (sm state-machine))
Method: match-sequence (input-sequence pattern)
Generic Reader: ndfa (object)
Package

regular-type-expression.

Methods
Reader Method: ndfa ((dependent dependent))

automatically generated reader method

Source

dependents.lisp.

Target Slot

ndfa.

Generic Function: state-assoc (strategy states exit-form-p)
Package

regular-type-expression.

Source

strategy-inline.lisp.

Methods
Method: state-assoc ((strategy strategy-trampoline) exit-form-p states)
Source

strategy-trampoline.lisp.

Method: state-assoc ((strategy strategy-tail-call) exit-form-p states)
Source

strategy-tail-call.lisp.

Method: state-assoc ((strategy strategy-goto) exit-form-p states)
Source

strategy-goto.lisp.


6.2.5 Classes

Class: dependent
Package

regular-type-expression.

Source

dependents.lisp.

Direct methods
Direct slots
Slot: ndfa
Initargs

:ndfa

Readers

ndfa.

Writers

This slot is read-only.

Class: dump-code-strategy
Package

regular-type-expression.

Source

dump-code.lisp.

Direct subclasses
Class: rte-state-machine
Package

regular-type-expression.

Source

rte-state-machine.lisp.

Direct superclasses

state-machine.

Direct methods
Direct slots
Slot: test
Package

non-deterministic-finite-automata.

Initform

(function typep)

Slot: deterministicp
Package

non-deterministic-finite-automata.

Initform

t

Slot: transition-label-combine
Package

non-deterministic-finite-automata.

Initform

(lambda (regular-type-expression::a regular-type-expression::b) (lisp-types:type-to-dnf-bottom-up (lisp-types:bdd-reduce-lisp-type (sb-int:quasiquote (or #s(sb-impl::comma :expr regular-type-expression::a :kind 0) #s(sb-impl::comma :expr regular-type-expression::b :kind 0))))))

Slot: transition-label-omit
Package

non-deterministic-finite-automata.

Initform

(lambda (regular-type-expression::label) (eq nil (lisp-types:type-to-dnf-bottom-up regular-type-expression::label)))

Slot: transition-label-equal
Package

non-deterministic-finite-automata.

Initform

(lambda (regular-type-expression::a regular-type-expression::b &aux (regular-type-expression::a-reduc (lisp-types:type-to-dnf-bottom-up regular-type-expression::a)) (regular-type-expression::b-reduc (lisp-types:type-to-dnf-bottom-up regular-type-expression::b))) (and (subtypep regular-type-expression::a-reduc regular-type-expression::b-reduc) (subtypep regular-type-expression::b-reduc regular-type-expression::a-reduc)))

Class: strategy-goto
Package

regular-type-expression.

Source

strategy-goto.lisp.

Direct superclasses

strategy-inline.

Direct methods
Class: strategy-inline
Package

regular-type-expression.

Source

strategy-inline.lisp.

Direct superclasses

dump-code-strategy.

Direct subclasses
Direct methods

dump-code.

Class: strategy-jump-table
Package

regular-type-expression.

Source

strategy-jump-table.lisp.

Direct superclasses

dump-code-strategy.

Class: strategy-tail-call
Package

regular-type-expression.

Source

strategy-tail-call.lisp.

Direct superclasses

strategy-inline.

Direct methods
Class: strategy-trampoline
Package

regular-type-expression.

Source

strategy-trampoline.lisp.

Direct superclasses

strategy-inline.

Direct methods

6.2.6 Types

Type: car*-cdr-of (&rest types)

Matches non-empty list whose leading elements respectively match the leading elements of TYPES, and thereafter the list of remaining elements matches the final element of types. E.g.,
(typep ’(1 hello nil 1 2 3 4 5) ’(car*-cdr-of number symbol null (list-of number)))
=> TRUE

Package

regular-type-expression.

Source

list-of.lisp.

Type: rte-keyword ()
Package

regular-type-expression.

Source

rte.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   A   C   D   E   F   G   M   N   P   R   S   T   U   W  
Index Entry  Section

A
alphabetize: Private ordinary functions

C
calc-sticky-states: Public standalone methods
canonicalize-pattern: Public ordinary functions
canonicalize-pattern-once: Private ordinary functions
compile-and-serialize: Private ordinary functions
complexity: Private ordinary functions

D
define-rte: Private ordinary functions
defrte: Public macros
derivative: Private ordinary functions
destructuring-case: Public macros
destructuring-case-alt: Private macros
destructuring-lambda-list-to-rte: Private ordinary functions
destructuring-methods: Public macros
dump-code: Private generic functions
dump-code: Private generic functions
dump-code: Private generic functions
dump-code: Private generic functions
dump-state: Private generic functions
dump-state: Private generic functions
dump-state: Private generic functions
dump-state: Private generic functions

E
equivalent-patterns: Private ordinary functions
expand-destructuring-case-alt: Private ordinary functions
expand-destructuring-methods: Private ordinary functions
expand-my-typedef: Private ordinary functions

F
find-key-variable: Private ordinary functions
find-keyword: Private ordinary functions
find-state-machine: Private ordinary functions
first-types: Private ordinary functions
format-state-dispatch: Private generic functions
format-state-dispatch: Private generic functions
format-state-dispatch: Private generic functions
format-state-dispatch: Private generic functions
Function, alphabetize: Private ordinary functions
Function, canonicalize-pattern: Public ordinary functions
Function, canonicalize-pattern-once: Private ordinary functions
Function, compile-and-serialize: Private ordinary functions
Function, complexity: Private ordinary functions
Function, define-rte: Private ordinary functions
Function, derivative: Private ordinary functions
Function, destructuring-lambda-list-to-rte: Private ordinary functions
Function, equivalent-patterns: Private ordinary functions
Function, expand-destructuring-case-alt: Private ordinary functions
Function, expand-destructuring-methods: Private ordinary functions
Function, expand-my-typedef: Private ordinary functions
Function, find-key-variable: Private ordinary functions
Function, find-keyword: Private ordinary functions
Function, find-state-machine: Private ordinary functions
Function, first-types: Private ordinary functions
Function, gather-type-declarations: Private ordinary functions
Function, get-patterns: Private ordinary functions
Function, make-rte-function-name: Private ordinary functions
Function, nullable: Private ordinary functions
Function, partition-by-predicate: Private ordinary functions
Function, register-dependents: Private ordinary functions
Function, remember-state-machine: Private ordinary functions
Function, remove-redundant-types: Private ordinary functions
Function, rte-case-clauses-to-dfa: Private ordinary functions
Function, rte-case-expander: Private ordinary functions
Function, rte-expand-type: Private ordinary functions
Function, rte-reset: Public ordinary functions
Function, rte-synchronized-product: Private ordinary functions
Function, rte-to-dfa: Private ordinary functions
Function, serialize-functions: Private ordinary functions
Function, sort-patterns: Private ordinary functions
Function, swap-type-specifier-alist: Private ordinary functions
Function, test-illustrate-dfas: Private ordinary functions
Function, trampoline: Private ordinary functions
Function, traverse-pattern: Private ordinary functions
Function, uniquify: Private ordinary functions
Function, with-expanded-type: Private ordinary functions

G
gather-type-declarations: Private ordinary functions
Generic Function, dump-code: Private generic functions
Generic Function, dump-state: Private generic functions
Generic Function, format-state-dispatch: Private generic functions
Generic Function, goto-next-state: Private generic functions
Generic Function, match-sequence: Private generic functions
Generic Function, ndfa: Private generic functions
Generic Function, state-assoc: Private generic functions
get-patterns: Private ordinary functions
goto-next-state: Private generic functions
goto-next-state: Private generic functions
goto-next-state: Private generic functions
goto-next-state: Private generic functions

M
Macro, defrte: Public macros
Macro, destructuring-case: Public macros
Macro, destructuring-case-alt: Private macros
Macro, destructuring-methods: Public macros
Macro, rte-case: Public macros
Macro, rte-ecase: Public macros
make-rte-function-name: Private ordinary functions
match-sequence: Private generic functions
match-sequence: Private generic functions
match-sequence: Private generic functions
match-sequence: Private generic functions
Method, calc-sticky-states: Public standalone methods
Method, dump-code: Private generic functions
Method, dump-code: Private generic functions
Method, dump-code: Private generic functions
Method, dump-state: Private generic functions
Method, dump-state: Private generic functions
Method, dump-state: Private generic functions
Method, format-state-dispatch: Private generic functions
Method, format-state-dispatch: Private generic functions
Method, format-state-dispatch: Private generic functions
Method, goto-next-state: Private generic functions
Method, goto-next-state: Private generic functions
Method, goto-next-state: Private generic functions
Method, match-sequence: Private generic functions
Method, match-sequence: Private generic functions
Method, match-sequence: Private generic functions
Method, ndfa: Private generic functions
Method, perform-some-transitions: Public standalone methods
Method, populate-synchronized-product: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, state-assoc: Private generic functions
Method, state-assoc: Private generic functions
Method, state-assoc: Private generic functions
Method, update-dependent: Public standalone methods

N
ndfa: Private generic functions
ndfa: Private generic functions
nullable: Private ordinary functions

P
partition-by-predicate: Private ordinary functions
perform-some-transitions: Public standalone methods
populate-synchronized-product: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods

R
register-dependents: Private ordinary functions
remember-state-machine: Private ordinary functions
remove-redundant-types: Private ordinary functions
rte-case: Public macros
rte-case-clauses-to-dfa: Private ordinary functions
rte-case-expander: Private ordinary functions
rte-ecase: Public macros
rte-expand-type: Private ordinary functions
rte-reset: Public ordinary functions
rte-synchronized-product: Private ordinary functions
rte-to-dfa: Private ordinary functions

S
serialize-functions: Private ordinary functions
sort-patterns: Private ordinary functions
state-assoc: Private generic functions
state-assoc: Private generic functions
state-assoc: Private generic functions
state-assoc: Private generic functions
swap-type-specifier-alist: Private ordinary functions

T
test-illustrate-dfas: Private ordinary functions
trampoline: Private ordinary functions
traverse-pattern: Private ordinary functions

U
uniquify: Private ordinary functions
update-dependent: Public standalone methods

W
with-expanded-type: Private ordinary functions


A.4 Data types

Jump to:   A   C   D   E   F   L   M   P   R   S   T  
Index Entry  Section

A
asdf.lisp: The rte/src/asdf․lisp file

C
car*-cdr-of: Private types
Class, dependent: Private classes
Class, dump-code-strategy: Private classes
Class, rte-state-machine: Private classes
Class, strategy-goto: Private classes
Class, strategy-inline: Private classes
Class, strategy-jump-table: Private classes
Class, strategy-tail-call: Private classes
Class, strategy-trampoline: Private classes

D
dependent: Private classes
dependents.lisp: The rte/src/dependents․lisp file
derivative.lisp: The rte/src/derivative․lisp file
destructuring-case.lisp: The rte/src/destructuring-case․lisp file
dump-code-strategy: Private classes
dump-code.lisp: The rte/src/dump-code․lisp file

E
expand-typedef.lisp: The rte/src/expand-typedef․lisp file

F
File, asdf.lisp: The rte/src/asdf․lisp file
File, dependents.lisp: The rte/src/dependents․lisp file
File, derivative.lisp: The rte/src/derivative․lisp file
File, destructuring-case.lisp: The rte/src/destructuring-case․lisp file
File, dump-code.lisp: The rte/src/dump-code․lisp file
File, expand-typedef.lisp: The rte/src/expand-typedef․lisp file
File, list-of.lisp: The rte/src/list-of․lisp file
File, prolog.lisp: The rte/src/prolog․lisp file
File, re-pattern.lisp: The rte/src/re-pattern․lisp file
File, rte-case.lisp: The rte/src/rte-case․lisp file
File, rte-state-machine.lisp: The rte/src/rte-state-machine․lisp file
File, rte.asd: The rte/rte․asd file
File, rte.lisp: The rte/src/rte․lisp file
File, strategy-goto.lisp: The rte/src/strategy-goto․lisp file
File, strategy-inline.lisp: The rte/src/strategy-inline․lisp file
File, strategy-jump-table.lisp: The rte/src/strategy-jump-table․lisp file
File, strategy-tail-call.lisp: The rte/src/strategy-tail-call․lisp file
File, strategy-trampoline.lisp: The rte/src/strategy-trampoline․lisp file

L
list-of: Public types
list-of.lisp: The rte/src/list-of․lisp file

M
Module, src: The rte/src module

P
Package, regular-type-expression: The regular-type-expression package
prolog.lisp: The rte/src/prolog․lisp file

R
re-pattern.lisp: The rte/src/re-pattern․lisp file
regular-type-expression: The regular-type-expression package
rte: The rte system
rte: Public types
rte-case.lisp: The rte/src/rte-case․lisp file
rte-keyword: Private types
rte-state-machine: Private classes
rte-state-machine.lisp: The rte/src/rte-state-machine․lisp file
rte.asd: The rte/rte․asd file
rte.lisp: The rte/src/rte․lisp file

S
src: The rte/src module
strategy-goto: Private classes
strategy-goto.lisp: The rte/src/strategy-goto․lisp file
strategy-inline: Private classes
strategy-inline.lisp: The rte/src/strategy-inline․lisp file
strategy-jump-table: Private classes
strategy-jump-table.lisp: The rte/src/strategy-jump-table․lisp file
strategy-tail-call: Private classes
strategy-tail-call.lisp: The rte/src/strategy-tail-call․lisp file
strategy-trampoline: Private classes
strategy-trampoline.lisp: The rte/src/strategy-trampoline․lisp file
System, rte: The rte system

T
Type, car*-cdr-of: Private types
Type, list-of: Public types
Type, rte: Public types
Type, rte-keyword: Private types