The rte Reference Manual

Table of Contents

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

The rte Reference Manual

This is the rte Reference Manual, version 1.1.12, generated automatically by Declt version 2.4 patchlevel 1 "Will Decker" on Mon Apr 08 14:54:44 2019 GMT+0.


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

1 Introduction

RTE - Rational Type Expressions

Synopsis

Definition of the RTE CL type. A type (and supporting functions) which implement rational type expressions. For information about this project and related publications , see Efficient dynamic type checking of heterogeneous sequences

API

(the (list-of (or string integer)) my-list)

  (destructuring-case '(1 2 :x 3)
    ((a b c) 
     (declare (type integer a b) (type symbol c))
     :first)
    ((a &optional (b 0) &key (x 0) (y 0)) 
     (declare (type integer a b x y))
     :second))
==> :second
(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))
(canonicalize-pattern '(:and (:or A B C) D E (:or F G)))
==> (:OR (:AND A D E F)
         (:AND A D E G)
         (:AND B D E F)
         (:AND B D E G)
         (:AND C D E F)
         (:AND C D E G))
(defrte (:cat number number number))
(defrte (:+ (:cat keyword number)))

Syntax of regular type expressions

Code Examples

(defun F4 (obj)
  (destructuring-case obj
    ((name &key count)
     (declare (type symbol name)
              (type integer count))
     ...)
    ((name data &rest strings)
     (declare (type symbol name)
              (type list data)
              (type (rte (:* string)) strings))
     ...)))
(defun F (X Y)
  (declare
     (type (rte (:* (cons number)))
           Y))
  ...)

ASDF

The ASDF :file designator is not sufficient for loading a lisp file which contains rte type specifiers. You must use :rte-file instead, and include :defsystem-depends-on (:rte) Here is an example.

(asdf:defsystem :rte-test
  ...
  :defsystem-depends-on (:rte)
  :components
  ((:module "src"
    :components
    ((:file "test-rte")
     (:file "test-list-of")
     (:rte-file "test-re-pattern")
     (:rte-file "test-destructuring-case-1")
     (:rte-file "test-destructuring-case-2")
     (:rte-file "test-destructuring-case")
     (:rte-file "test-ordinary-lambda-list")
     (:rte-file "test-rte-case")))))

License

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation
files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of the Software,
and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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 rte

Author

Jim Newton

License

MIT

Description

Regular type expressions implementation

Version

1.1.12

Dependencies
Source

rte.asd (file)

Component

src (module)


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

3 Modules

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


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

3.1 rte/src

Parent

rte (system)

Location

src/

Components

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

4 Files

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


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

4.1 Lisp


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

4.1.1 rte.asd

Location

rte.asd

Systems

rte (system)


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

4.1.2 rte/src/rte.lisp

Parent

src (module)

Location

src/rte.lisp

Packages

regular-type-expression

Internal Definitions

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

4.1.3 rte/src/asdf.lisp

Dependency

rte.lisp (file)

Parent

src (module)

Location

src/asdf.lisp


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

4.1.4 rte/src/expand-typedef.lisp

Dependency

rte.lisp (file)

Parent

src (module)

Location

src/expand-typedef.lisp

Internal Definitions

expand-my-typedef (function)


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

4.1.5 rte/src/list-of.lisp

Dependencies
Parent

src (module)

Location

src/list-of.lisp

Exported Definitions

list-of (type)

Internal Definitions

car*-cdr-of (type)


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

4.1.6 rte/src/dependents.lisp

Dependency

rte.lisp (file)

Parent

src (module)

Location

src/dependents.lisp

Internal Definitions

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

4.1.7 rte/src/re-pattern.lisp

Dependencies
Parent

src (module)

Location

src/re-pattern.lisp

Exported Definitions
Internal Definitions

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

4.1.8 rte/src/rte-case.lisp

Dependency

rte.lisp (file)

Parent

src (module)

Location

src/rte-case.lisp

Exported Definitions
Internal Definitions

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

4.1.9 rte/src/destructuring-case.lisp

Dependency

re-pattern.lisp (file)

Parent

src (module)

Location

src/destructuring-case.lisp

Exported Definitions
Internal Definitions

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

4.1.10 rte/src/prolog.lisp

Dependency

rte.lisp (file)

Parent

src (module)

Location

src/prolog.lisp

Internal Definitions

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

5 Packages

Packages are listed by definition order.


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

5.1 regular-type-expression

Source

rte.lisp (file)

Nickname

rte

Use List
Exported Definitions
Internal Definitions

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

6 Definitions

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


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

6.1 Exported definitions


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

6.1.1 Macros

Macro: defrte PATTERN

Declare a given RTE patter so that that it can be used when loaded from fasl.

Package

regular-type-expression

Source

re-pattern.lisp (file)

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

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

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

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


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

6.1.2 Functions

Function: canonicalize-pattern RE

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

Package

regular-type-expression

Source

re-pattern.lisp (file)

Function: rte-reset ()

Forget all regular type expressions.

Package

regular-type-expression

Source

re-pattern.lisp (file)


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

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

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


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

6.2 Internal definitions


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

6.2.1 Special variables

Special Variable: *rte-pattern-functions*

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

Package

regular-type-expression

Source

re-pattern.lisp (file)

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

Special Variable: *state-machines*

Hash table mapping rte pattern to state-machine object.

Package

regular-type-expression

Source

rte.lisp (file)

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


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

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


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

6.2.3 Functions

Function: alphabetize PATTERNS

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

Package

regular-type-expression

Source

re-pattern.lisp (file)

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

re-pattern.lisp (file)

Function: cmp-objects A B
Package

regular-type-expression

Source

re-pattern.lisp (file)

Function: compile-and-serialize PATHNAME COMPILE
Package

regular-type-expression

Source

prolog.lisp (file)

Function: complexity OBJECT

Returns the number of cons cells in the given hierarchical list

Package

regular-type-expression

Source

prolog.lisp (file)

Function: define-rte PATTERN
Package

regular-type-expression

Source

re-pattern.lisp (file)

Function: derivative PATTERN WRT-TYPE
Package

regular-type-expression

Source

re-pattern.lisp (file)

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

Function: equivalent-patterns RTE1 RTE2
Package

regular-type-expression

Source

re-pattern.lisp (file)

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

Function: expand-destructuring-methods OBJECT-FORM CLAUSES CALL-NEXT-METHOD
Package

regular-type-expression

Source

destructuring-case.lisp (file)

Function: expand-my-typedef TYPE ARGS UNARY-FUNCTION &key FUNCTION-NAME
Package

regular-type-expression

Source

expand-typedef.lisp (file)

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

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

Function: find-state-machine PATTERN
Package

regular-type-expression

Source

re-pattern.lisp (file)

Function: first-types PATTERN
Package

regular-type-expression

Source

re-pattern.lisp (file)

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

Function: get-patterns ()
Package

regular-type-expression

Source

prolog.lisp (file)

Function: make-rte-function-name PATTERN
Package

regular-type-expression

Source

re-pattern.lisp (file)

Function: nullable RE
Package

regular-type-expression

Source

re-pattern.lisp (file)

Function: partition-by-predicate PREDICATE DATA
Package

regular-type-expression

Source

re-pattern.lisp (file)

Function: register-dependents SM
Package

regular-type-expression

Source

dependents.lisp (file)

Function: remember-state-machine SM PATTERN
Package

regular-type-expression

Source

re-pattern.lisp (file)

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

Function: rte-case-clauses-to-dfa ()

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

Function: rte-case-expander OBJECT-FORM CLAUSES &key COMPLAIN-REMAINDER VIEW
Package

regular-type-expression

Source

rte-case.lisp (file)

Function: rte-synchronized-product ()
Package

regular-type-expression

Source

rte-case.lisp (file)

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

Function: serialize-functions STREAM &optional PATTERNS
Package

regular-type-expression

Source

prolog.lisp (file)

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

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

Function: test-illustrate-dfas PATTERN PREVIOUS-PATTERNS DERIVED-PATTERN
Package

regular-type-expression

Source

destructuring-case.lisp (file)

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

Function: uniquify OBJECTS
Package

regular-type-expression

Source

re-pattern.lisp (file)


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

6.2.4 Generic functions

Generic Function: dump-code OBJECT &key VAR
Package

regular-type-expression

Source

re-pattern.lisp (file)

Methods
Method: dump-code (NDFA rte-state-machine) &key VAR
Method: dump-code (PATTERN list) &key VAR
Generic Function: match-sequence INPUT-SEQUENCE PATTERN
Package

regular-type-expression

Source

re-pattern.lisp (file)

Methods
Method: match-sequence INPUT-SEQUENCE (PATTERN list)
Method: match-sequence INPUT-SEQUENCE (SM state-machine)
Method: match-sequence INPUT-SEQUENCE PATTERN
Generic Function: ndfa OBJECT
Package

regular-type-expression

Methods
Method: ndfa (DEPENDENT dependent)

automatically generated reader method

Source

dependents.lisp (file)


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

6.2.5 Classes

Class: dependent ()
Package

regular-type-expression

Source

dependents.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
  • update-dependent (method)
  • print-object (method)
  • ndfa (method)
Direct slots
Slot: ndfa
Initargs

:ndfa

Readers

ndfa (generic function)

Class: rte-state-machine ()
Package

regular-type-expression

Source

re-pattern.lisp (file)

Direct superclasses

state-machine (class)

Direct methods
  • perform-some-transitions (method)
  • dump-code (method)
  • populate-synchronized-product (method)
  • print-object (method)
Direct slots
Slot: test
Initform

(function typep)

Slot: deterministicp
Initform

t

Slot: transition-label-combine
Initform

(lambda (regular-type-expression::a regular-type-expression::b) (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-equal
Initform

(lambda (regular-type-expression::a regular-type-expression::b) (and (subtypep regular-type-expression::a regular-type-expression::b) (subtypep regular-type-expression::b regular-type-expression::a)))


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

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

Type: rte-keyword ()
Package

regular-type-expression

Source

rte.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   M   R  
Index Entry  Section

F
File, Lisp, rte.asd: The rte<dot>asd file
File, Lisp, rte/src/asdf.lisp: The rte/src/asdf<dot>lisp file
File, Lisp, rte/src/dependents.lisp: The rte/src/dependents<dot>lisp file
File, Lisp, rte/src/destructuring-case.lisp: The rte/src/destructuring-case<dot>lisp file
File, Lisp, rte/src/expand-typedef.lisp: The rte/src/expand-typedef<dot>lisp file
File, Lisp, rte/src/list-of.lisp: The rte/src/list-of<dot>lisp file
File, Lisp, rte/src/prolog.lisp: The rte/src/prolog<dot>lisp file
File, Lisp, rte/src/re-pattern.lisp: The rte/src/re-pattern<dot>lisp file
File, Lisp, rte/src/rte-case.lisp: The rte/src/rte-case<dot>lisp file
File, Lisp, rte/src/rte.lisp: The rte/src/rte<dot>lisp file

L
Lisp File, rte.asd: The rte<dot>asd file
Lisp File, rte/src/asdf.lisp: The rte/src/asdf<dot>lisp file
Lisp File, rte/src/dependents.lisp: The rte/src/dependents<dot>lisp file
Lisp File, rte/src/destructuring-case.lisp: The rte/src/destructuring-case<dot>lisp file
Lisp File, rte/src/expand-typedef.lisp: The rte/src/expand-typedef<dot>lisp file
Lisp File, rte/src/list-of.lisp: The rte/src/list-of<dot>lisp file
Lisp File, rte/src/prolog.lisp: The rte/src/prolog<dot>lisp file
Lisp File, rte/src/re-pattern.lisp: The rte/src/re-pattern<dot>lisp file
Lisp File, rte/src/rte-case.lisp: The rte/src/rte-case<dot>lisp file
Lisp File, rte/src/rte.lisp: The rte/src/rte<dot>lisp file

M
Module, rte/src: The rte/src module

R
rte.asd: The rte<dot>asd file
rte/src: The rte/src module
rte/src/asdf.lisp: The rte/src/asdf<dot>lisp file
rte/src/dependents.lisp: The rte/src/dependents<dot>lisp file
rte/src/destructuring-case.lisp: The rte/src/destructuring-case<dot>lisp file
rte/src/expand-typedef.lisp: The rte/src/expand-typedef<dot>lisp file
rte/src/list-of.lisp: The rte/src/list-of<dot>lisp file
rte/src/prolog.lisp: The rte/src/prolog<dot>lisp file
rte/src/re-pattern.lisp: The rte/src/re-pattern<dot>lisp file
rte/src/rte-case.lisp: The rte/src/rte-case<dot>lisp file
rte/src/rte.lisp: The rte/src/rte<dot>lisp file

Jump to:   F   L   M   R  

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

A.2 Functions

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

A
alphabetize: Internal functions

C
canonicalize-pattern: Exported functions
canonicalize-pattern-once: Internal functions
cmp-objects: Internal functions
compile-and-serialize: Internal functions
complexity: Internal functions

D
define-rte: Internal functions
defrte: Exported macros
derivative: Internal functions
destructuring-case: Exported macros
destructuring-case-alt: Internal macros
destructuring-lambda-list-to-rte: Internal functions
destructuring-methods: Exported macros
dump-code: Internal generic functions
dump-code: Internal generic functions
dump-code: Internal generic functions

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

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

G
gather-type-declarations: Internal functions
Generic Function, dump-code: Internal generic functions
Generic Function, match-sequence: Internal generic functions
Generic Function, ndfa: Internal generic functions
get-patterns: Internal functions

M
Macro, defrte: Exported macros
Macro, destructuring-case: Exported macros
Macro, destructuring-case-alt: Internal macros
Macro, destructuring-methods: Exported macros
Macro, rte-case: Exported macros
Macro, rte-ecase: Exported macros
make-rte-function-name: Internal functions
match-sequence: Internal generic functions
match-sequence: Internal generic functions
match-sequence: Internal generic functions
match-sequence: Internal generic functions
Method, dump-code: Internal generic functions
Method, dump-code: Internal generic functions
Method, match-sequence: Internal generic functions
Method, match-sequence: Internal generic functions
Method, match-sequence: Internal generic functions
Method, ndfa: Internal generic functions

N
ndfa: Internal generic functions
ndfa: Internal generic functions
nullable: Internal functions

P
partition-by-predicate: Internal functions

R
register-dependents: Internal functions
remember-state-machine: Internal functions
remove-redundant-types: Internal functions
rte-case: Exported macros
rte-case-clauses-to-dfa: Internal functions
rte-case-expander: Internal functions
rte-ecase: Exported macros
rte-reset: Exported functions
rte-synchronized-product: Internal functions
rte-to-dfa: Internal functions

S
serialize-functions: Internal functions
sort-patterns: Internal functions
swap-type-specifier-alist: Internal functions

T
test-illustrate-dfas: Internal functions
traverse-pattern: Internal functions

U
uniquify: Internal functions

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

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

A.3 Variables

Jump to:   *  
D   N   S   T  
Index Entry  Section

*
*rte-pattern-functions*: Internal special variables
*rte-types*: Internal special variables
*state-machines*: Internal special variables
*type-functions*: Internal special variables

D
deterministicp: Internal classes

N
ndfa: Internal classes

S
Slot, deterministicp: Internal classes
Slot, ndfa: Internal classes
Slot, test: Internal classes
Slot, transition-label-combine: Internal classes
Slot, transition-label-equal: Internal classes
Special Variable, *rte-pattern-functions*: Internal special variables
Special Variable, *rte-types*: Internal special variables
Special Variable, *state-machines*: Internal special variables
Special Variable, *type-functions*: Internal special variables

T
test: Internal classes
transition-label-combine: Internal classes
transition-label-equal: Internal classes

Jump to:   *  
D   N   S   T  

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

A.4 Data types

Jump to:   C   D   L   P   R   S   T  
Index Entry  Section

C
car*-cdr-of: Internal types
Class, dependent: Internal classes
Class, rte-state-machine: Internal classes

D
dependent: Internal classes

L
list-of: Exported types

P
Package, regular-type-expression: The regular-type-expression package

R
regular-type-expression: The regular-type-expression package
rte: The rte system
rte: Exported types
rte-keyword: Internal types
rte-state-machine: Internal classes

S
System, rte: The rte system

T
Type, car*-cdr-of: Internal types
Type, list-of: Exported types
Type, rte: Exported types
Type, rte-keyword: Internal types

Jump to:   C   D   L   P   R   S   T