Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the functional-trees Reference Manual, version 0.0.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Fri Jun 26 11:06:49 2020 GMT+0.
| • Introduction | What functional-trees is all about | |
| • Systems | The systems documentation | |
| • Files | The files documentation | |
| • Packages | The packages documentation | |
| • Definitions | The symbols documentation | |
| • Indexes | Concepts, functions, variables and data types |
A system that allows walking and rewriting of parts of trees in a functional manner, along with translation of references to internal nodes that can be carried from one tree to its successors.
Implemented in a manner that is compatible with and depends upon FSet.
To start, load this library (system name :functional-trees) using Quicklisp:
(ql:quickload :functional-trees)
This library defines one package, :functional-trees, which we will refer to by
its nickname :ft. The main thing provided by :ft is the node class, an
object of which represents a node in a tree. Here are its slots:
(describe (make-instance 'ft:node))
#<FUNCTIONAL-TREES:NODE 0 NIL>
[standard-object]
Slots with :CLASS allocation:
CHILD-SLOTS = NIL
Slots with :INSTANCE allocation:
SERIAL-NUMBER = 0
TRANSFORM = NIL
SIZE = #<unbound slot>
FINGER = NIL
The :class-allocated child-slots slot holds a list of the slots that
actually hold children. Thus, since it holds the value nil here, we see that
the raw ft:node class can only really represent leaf nodes. Next we'll address
this by defining our own node class that can hold children. Afterward, we'll
discuss the other ft:node slots.
node classIn most cases it is likely that one would subclass the node class
provided by this package. Any subclass of node can specify which of
its slots might hold subtrees by defining a child-slots slot which
should be initialized to hold the names of these fields and should be
allocated on the class itself. See the following example.
(ft:define-node-class if-then-else-node (ft:node)
((ft:child-slots :initform '((then . 1) else) :allocation :class)
(then :reader then :initarg :then :type ft:node)
(else :reader else :initarg :else :type '(list ft:node)))
(:documentation "An if-then-else subtree of a program AST."))
Note that we used ft:define-node-class instead of just defclass. The latter
would work, but the former also sets up some additional useful infrastructure
for our new node subclass. This infrastructure is already defined generically
for all nodes, but the ft:define-node-class macro defines it more efficiently
for a specific class of nodes.
Note also that the :initarg keywords for then and else are necessary, as
they are used by automatic tree-copying functions in this library. If they are
omitted, many functions (including the FSet generic sequence transformation
functions described below) will not work properly.
Each child slot should hold children nodes. Child slots may hold a
single node or multiple nodes. It is possible to specify the arity of
a child slot using the child-slots class-level field. This changes
the behavior of relevant generic functions. E.g., the then slot in
if-then-else-node above holds a single node child while the else
slot may hold a list of any number of children.
In addition to customizing the functional-tree generic functions to
traverse your tree appropriately, defining child-slots will cause
the generic children function to be defined to return all children
of a newly defined node subclass--this is done by hooking the MOP
sub-class finalization process for sub-classes of node.
Thus if we create a node using our new class and give values to its
child-slots, the children function will return the list of those children
according to the the order of the child-slots list:
(ft:children (make-instance 'if-then-else-node
:else '(:foo :bar)
:then :baz))
(:BAZ :FOO :BAR)
(In this particular example we eschewed the :type annotations on the child
slots, for simplicity.)
The word "functional" usually means multiple things:
(Note that the second condition implies the first.) This library satisfies the first condition but not the second, which is why we will sometimes use the word "applicative" instead of "functional". Also, we slightly relax our definition of immutability: because slots can be unbound, we do not consider an assignment to an unbound slot to be a mutation of the object. So rather than immutability meaning that the object never changes, it instead means that the object can only ever go upward in a lattice ordered by boundness of slots.
There is one exception to this definition of immutability: fingers. As shown by
our first node example, the finger slot is initially set to nil when a
node is created, and should only be set by the ft:populate-fingers function
(see below). Thus, a more accurate version of our definition of immutability
would replace "unbound" with "nil" in the case of the finger slot.
The reason we don't have referential transparency is that each newly created
node has a unique serial number:
(ft::serial-number (make-instance 'ft:node))
3
These serial numbers increase monotonically, and are used internally in the library for various algorithmic tasks. One important thing to note is that these serial numbers must be unique in any given tree in addition to being unique per node. That is, if you transform a tree by copying one of its subtrees to another location in the tree, you must clone that entire subtree to ensure that the new tree does not contain any duplicate serial numbers.
As the above examples show, make-instance is fairly barebones: it sets the
serial-number but not much else. Because this library incorporates FSet,
though, we can extend the generic convert function to provide an easier way to
construct our nodes (we will discuss ft:populate-fingers in the next section):
(defmethod fset:convert ((to-type (eql 'if-then-else-node)) (sequence list)
&key &allow-other-keys)
(labels ((construct (form)
(if (consp form)
(make-instance 'if-then-else-node
:then (construct (first form))
:else (mapcar #'construct (rest form)))
(make-instance 'ft:node))))
(ft:populate-fingers (construct sequence))))
Now we can round-trip from a list to an if-then-else-node and back, because
this library already defines an fset:convert method to convert from nodes to
lists, essentially a recursive version of ft:children:
(progn
(defvar my-node (fset:convert 'if-then-else-node '((nil) nil)))
(describe my-node)
(fset:convert 'list my-node))
#<IF-THEN-ELSE-NODE 7 ((NIL) NIL)>
[standard-object]
Slots with :CLASS allocation:
CHILD-SLOTS = ((THEN . 1) ELSE)
Slots with :INSTANCE allocation:
SERIAL-NUMBER = 7
TRANSFORM = NIL
SIZE = #<unbound slot>
FINGER = #<FUNCTIONAL-TREES:FINGER #<IF-THEN-ELSE-NODE 7 ((NIL) NIL)> NIL>
THEN = #<IF-THEN-ELSE-NODE 5 (NIL)>
ELSE = (#<FUNCTIONAL-TREES:NODE 6 NIL>)
((NIL) NIL)
In the previous example, we constructed a small tree and then called
ft:populate-fingers on it. Let's take a look at one of these fingers:
(progn
(defvar finger1 (ft:finger (then (then my-node))))
(describe finger1))
#<FUNCTIONAL-TREES:FINGER #<IF-THEN-ELSE-NODE 7 ((NIL) NIL)> (THEN THE..
[standard-object]
Slots with :INSTANCE allocation:
NODE = #<IF-THEN-ELSE-NODE 7 ((NIL) NIL)>
PATH = (:THEN :THEN)
RESIDUE = NIL
CACHE = #<unbound slot>
From this we can see that a finger includes a pointer to the root of a tree (in
node) and a path to another node in that tree. From these two pieces, it is
straightforward to follow path, starting from the root node, to find the
original node which held this finger; once this lookup has been computed once,
finger can store the resulting node in its cache slot. The residue relates
to path transformations, which we will discuss in the next section.
Now let's look at one more finger:
(progn
(defvar finger2 (ft:finger (first (else my-node))))
(describe finger2))
#<FUNCTIONAL-TREES:FINGER #<IF-THEN-ELSE-NODE 7 ((NIL) NIL)> (ELSE 0)>
[standard-object]
Slots with :INSTANCE allocation:
NODE = #<IF-THEN-ELSE-NODE 7 ((NIL) NIL)>
PATH = (ELSE 0)
RESIDUE = NIL
CACHE = #<unbound slot>
Because these two fingers were both created in the context of the same tree,
they both point to the same root node. However, this one has a different
path to it: we took the first node in the the else branch.
The ft:populate-fingers function produces fingers whose paths follow a
somewhat different format from the paths used in other parts of the library; see
the next section, for instance. Specifically, an ft:populate-fingers path is a
list where
:then) means to follow the child whose slot name is the same
as that keyword;Using the particular child-slots of our if-then-else-node class, we could
write a function to translate these ft:populate-fingers paths to simple lists
of child indices:
(defun simplify-path (path)
(mapcar (lambda (x)
(if (eq x :then)
0
(1+ x)))
(remove 'else path)))
We could then also write a function that transforms entire finger objects to use this alternate path format:
(defun simplify (finger)
(with-accessors ((node ft:node)
(path ft:path)
(residue ft:residue))
finger
(let ((simplified (make-instance 'ft:finger
:node node
:path (simplify-path path)
:residue residue)))
(when (slot-boundp finger 'ft::cache)
(setf (ft::cache simplified) (ft::cache finger)))
simplified)))
A couple examples, using our existing fingers:
(values-list (mapcar (alexandria:compose #'ft:path #'simplify)
(list finger1 finger2)))
(0 0)
(1)
Note of course that these functions would not work for ft:populate-fingers
paths in other node subclasses besides if-then-else-node.
This library provides ft:node implementations for the following generic
sequence functions from FSet:
reducefind-iffind-if-notfindcount-ifcount-if-notcountposition-ifposition-if-notpositionremove-ifremove-if-notremovesubstitute-ifsubstitute-if-notsubstituteIt also provides a couple additional generic methods, also with implementations
for ft:node:
mapc takes as arguments a function and a node, respectively. It calls the
given function on every node in the tree of the given node, and then returns
nil.
mapcar does the same thing as mapc, except that it constructs a new tree
from the results of all those function calls, and returns the newly
constructed tree.
For example, we could expand an if-then-else-node by adding an extra
ft:node to every else branch:
(progn
(defvar expanded
(ft:mapcar (lambda (n)
(if (typep n 'if-then-else-node)
(make-instance 'if-then-else-node
:then (then n)
:else (list* (make-instance 'ft:node)
(else n)))
n))
my-node))
(describe expanded))
#<IF-THEN-ELSE-NODE 9 ((NIL NIL) NIL NIL)>
[standard-object]
Slots with :CLASS allocation:
CHILD-SLOTS = ((THEN . 1) ELSE)
Slots with :INSTANCE allocation:
SERIAL-NUMBER = 9
TRANSFORM = #<IF-THEN-ELSE-NODE 7 ((NIL) NIL)>
SIZE = #<unbound slot>
FINGER = NIL
THEN = #<IF-THEN-ELSE-NODE 11 (NIL NIL)>
ELSE = (#<FUNCTIONAL-TREES:NODE 8 NIL> #<FUNCTIONAL-TREES:NODE 6 NIL>)
This library differs from a naive implementation of functional trees by efficiently handling the relationship between transformations on trees and transformations on paths.
When you transform a tree into another tree using this library, the latter
retains knowledge of the relationship to the former (its "predecessor") via its
transform slot:
(describe (ft:transform expanded))
#<FUNCTIONAL-TREES::PATH-TRANSFORM (((0 0) (0 0) LIVE) ((1) (2) LIVE))..
[standard-object]
Slots with :INSTANCE allocation:
FROM = #<IF-THEN-ELSE-NODE 7 ((NIL) NIL)>
TRANSFORMS = (((0 0) (0 0) :LIVE) ((1) (2) :LIVE))
Here we see that expanded knows which tree it originally came from (the
predecessor), and also stores some additional transforms information. Since
expanded shares some structure with my-node, these transforms enable us to
take a path (that is, a finger) to a node in the my-node tree and translate it
into a path (finger) to the same node in the expanded tree:
(defun show-expanded-finger (finger)
(describe (ft:transform-finger-to (simplify finger)
(ft:transform expanded)
expanded)))
Here's an example:
(show-expanded-finger finger1)
#<FUNCTIONAL-TREES:FINGER #<IF-THEN-ELSE-NODE 9 ((NIL NIL) NIL NIL)> (..
[standard-object]
Slots with :INSTANCE allocation:
NODE = #<IF-THEN-ELSE-NODE 9 ((NIL NIL) NIL NIL)>
PATH = (0 0)
RESIDUE = NIL
CACHE = #<unbound slot>
That example isn't particularly exciting, because the path to this node is the
same as it was before: it's still just the first child of the first child. We do
see that the root node of the finger was changed to our new tree, though. But
we can also translate other paths:
(show-expanded-finger finger2)
#<FUNCTIONAL-TREES:FINGER #<IF-THEN-ELSE-NODE 9 ((NIL NIL) NIL NIL)> (..
[standard-object]
Slots with :INSTANCE allocation:
NODE = #<IF-THEN-ELSE-NODE 9 ((NIL NIL) NIL NIL)>
PATH = (2)
RESIDUE = NIL
CACHE = #<unbound slot>
This path actually did change, because we added an extra ft:node in the else
branch right before it.
This library is able to very efficiently compute these path transform objects: it only takes time O(n log n), where n is the number of newly allocated nodes in the transformed tree.
cl:subst and friends.update-tree with map-treeconvert methods for subclasses of node.Next: Files, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
| • The functional-trees system | ||
| • The functional-trees/functional-trees system |
Next: The functional-trees/functional-trees system, Previous: Systems, Up: Systems [Contents][Index]
GrammaTech
MIT
Tree data structure supporting functional manipulation
Tree data structure supporting functional (or
applicative) manipulation. This system allows the walking and
rewriting of parts of trees in a functional manner, along with
translation of references to internal nodes that can be carried from
one tree to its successors.
0.0.0
asdf-package-system
functional-trees/functional-trees (system)
functional-trees.asd (file)
Previous: The functional-trees system, Up: Systems [Contents][Index]
GrammaTech
MIT
functional-trees.asd (file)
lisp.lisp (file)
Files are sorted by type and then listed depth-first from the systems components trees.
| • Lisp files |
| • The functional-trees.asd file | ||
| • The functional-trees/functional-trees/lisp.lisp file |
Next: The functional-trees/functional-trees/lisp․lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
functional-trees.asd
Previous: The functional-trees․asd file, Up: Lisp files [Contents][Index]
functional-trees/functional-trees (system)
functional-trees.lisp
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
| • The functional-trees package |
Prototype implementation of functional trees w. finger objects
lisp.lisp (file)
Definitions are sorted by export status, category, package, and then by lexicographic order.
| • Exported definitions | ||
| • Internal definitions |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
| • Exported macros | ||
| • Exported generic functions | ||
| • Exported classes | ||
| • Exported types |
Next: Exported generic functions, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
lisp.lisp (file)
lisp.lisp (file)
Generalized tree traversal used to implement common lisp sequence functions.
VALUE is the value to return upon completion. INDEX may hold a
variable bound in BODY to the *reversed* path leading to the current
node. If REBUILD then the body should return the new node that will
replace NODE, NODE itself if it is not to be replaced, and NIL if NODE
is to be deleted (from a variable arity list of children in its parent.
lisp.lisp (file)
Next: Exported classes, Previous: Exported macros, Up: Exported definitions [Contents][Index]
List of child slots with optional arity.
This field should be specified as :allocation :class if defined by a
subclass of ‘node’. List of either symbols specifying a slot holding
a list of children or a cons of (symbol . number) where number
specifies a specific number of children held in the slot.
lisp.lisp (file)
Return all children of NODE.
lisp.lisp (file)
Generic COPY method.
lisp.lisp (file)
A finger back to the root of the (a?) tree.
lisp.lisp (file)
Map FUNCTION over CONTAINER.
lisp.lisp (file)
Map FUNCTION over CONTAINER.
lisp.lisp (file)
The node to which this finger pertains, considered as the root of a tree.
lisp.lisp (file)
Check that two nodes are the same tree
lisp.lisp (file)
A list of nonnegative integer values giving a path from node down to another node.
lisp.lisp (file)
Walk tree, creating fingers back to root.
lisp.lisp (file)
If this finger was created from another
finger by a path-transform, some part of the path may not have been
translated. If so, this field is the part that could not be handled.
Otherwise, it is NIL.
lisp.lisp (file)
Swap the contents of LOCATION-1 and LOCATION-2 in TREE.
lisp.lisp (file)
Converts a finger from one tree to another.
lisp.lisp (file)
Copy method that descends into a tree and copies all its nodes.
lisp.lisp (file)
Next: Exported types, Previous: Exported generic functions, Up: Exported definitions [Contents][Index]
A wrapper for a path to get to a node
lisp.lisp (file)
standard-object (class)
The node to which this finger pertains, considered as the root of a tree.
functional-trees:node
:node
(alexandria:required-argument :node)
node (generic function)
A list of nonnegative integer values giving a path from node down to another node.
functional-trees:path
:path
(alexandria:required-argument :path)
path (generic function)
If this finger was created from another
finger by a path-transform, some part of the path may not have been
translated. If so, this field is the part that could not be handled.
Otherwise, it is NIL.
list
:residue
residue (generic function)
Internal slot used to cache the lookup of a node.
cache (generic function)
(setf cache) (generic function)
A node in a tree.
lisp.lisp (file)
identity-ordering-mixin (class)
If non-nil, is either a PATH-TRANSFORM object to this node, or the node that led to this node.
(or null functional-trees:node functional-trees::path-transform)
:transform
transform (generic function)
Number of nodes in tree rooted here.
(integer 1)
size (generic function)
List of child slots with optional arity.
This field should be specified as :allocation :class if defined by a
subclass of ‘node’. List of either symbols specifying a slot holding
a list of children or a cons of (symbol . number) where number
specifies a specific number of children held in the slot.
list
:class
child-slots (generic function)
A finger back to the root of the (a?) tree.
(or null functional-trees:node functional-trees:finger)
finger (generic function)
Previous: Exported classes, Up: Exported definitions [Contents][Index]
lisp.lisp (file)
Previous: Exported definitions, Up: Definitions [Contents][Index]
| • Internal special variables | ||
| • Internal macros | ||
| • Internal functions | ||
| • Internal generic functions | ||
| • Internal structures | ||
| • Internal classes | ||
| • Internal types |
Next: Internal macros, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
lisp.lisp (file)
Next: Internal functions, Previous: Internal special variables, Up: Internal definitions [Contents][Index]
lisp.lisp (file)
Define generic functions which descend (and return) through functional trees.
This is useful to define standard FSet functions such as ‘with’,
‘less’, etc... Keyword arguments control specifics of how the
recursion works and how the generic functions are defined. OTHER-ARGS
specifies additional arguments that are used. EXTRA-ARGS defines
additional arguments that are not used. REPLACE is a boolean flagging
if NEW replaces the target or is added alongside the target. SPLICE
is a boolean flagging if NEW is inserted or spliced. CHECKS allows
for the specification of checks to run at the beginning of the
functions.
lisp.lisp (file)
lisp.lisp (file)
This macro is an idiom that occurs in many methods. It handles checking and normalization of :TEST and :TEST-NOT arguments.
lisp.lisp (file)
lisp.lisp (file)
Next: Internal generic functions, Previous: Internal macros, Up: Internal definitions [Contents][Index]
lisp.lisp (file)
lisp.lisp (file)
Apply REWRITE-FN to TREE, producing a new tree. The new tree has its predecessor set to TREE.
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
Lexicographic comparison of lists of reals or symbols Symbols are considered to be less than reals, and symbols are compared with each other using fset:compare
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
Internal function used to remove redundancy from a set of path mappings.
lisp.lisp (file)
True if list P1 is a prefix of P2
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
lisp.lisp (file)
Construct a trie for TRANSFORMS, which is a list as described in the transforms slot of PATH-TRANSFORMS objects.
lisp.lisp (file)
Next: Internal structures, Previous: Internal functions, Up: Internal definitions [Contents][Index]
Internal slot used to cache the lookup of a node.
lisp.lisp (file)
Data for segments that end at this trie node, or NIL if no such segments end here.
lisp.lisp (file)
Call FN on each child of NODE, along with the INDEX augmented by the label of that child.
lisp.lisp (file)
Apply traverse-children recursively to children of NODE, returning a plist suitable for passing to COPY
lisp.lisp (file)
Check if new-node can the subtree rooted at at-node below ROOT and produce a valid tree.
lisp.lisp (file)
True if the tree rooted at NODE have EQL unique
serial-numbers, and no node occurs on two different paths in the tree
lisp.lisp (file)
Returns multiple values that are used by
CONVERT ’LIST to append to the beginning of the list representation
of a node.
lisp.lisp (file)
Return true if NODE1 and NODE2 do not share any serial-number
lisp.lisp (file)
Produce a path transform that maps FROM-NODE to TO-NODE
lisp.lisp (file)
Traverse tree at and below NODE in preorder, calling FN on each node.
lisp.lisp (file)
Traverse tree below NODE in preorder, calling
FN on each node (and with the reversed path INDEX to that node).
lisp.lisp (file)
If TREE is a cons, this simply calls ‘cl:subst’. Also works on a functional tree node.
lisp.lisp (file)
If TREE is a cons, this simply calls ‘cl:subst-if’. Also works on a functional tree node.
lisp.lisp (file)
If TREE is a cons, this simply calls ‘cl:subst-if’. Also works on a functional tree node.
lisp.lisp (file)
Transforms FINGER, producing a new finger that
points through the root NODE. NODE must be derived from the tree
that FINGER is pointed through.
lisp.lisp (file)
lisp.lisp (file)
A list of (<path-set> <path> <status>) triples
where <path-set> is a path set, <path> is the mapping of the initial path
in that <path-set>, and <status> is one of :live :dead. These should be
sorted into non-increasing order of length of <path>. If missing, compute
from the source/target node pair, if possible.
lisp.lisp (file)
Traverse tree rooted at NODE in preorder.
At each node, call FN. If the first value returned is true,
replaced node by the second returned value and continued the
traversal. If any child is replaced also replace the parent
node (as the trees are applicative.)
lisp.lisp (file)
lisp.lisp (file)
Alist mapping indices to trie nodes
lisp.lisp (file)
Sets the back pointer of NEW-TREE to be OLD-TREE, if NEW-TREE lacks a back pointer. Returns NEW-TREE.
lisp.lisp (file)
Next: Internal classes, Previous: Internal generic functions, Up: Internal definitions [Contents][Index]
lisp.lisp (file)
structure-object (structure)
node-heap-data-node (function)
(setf node-heap-data-node) (function)
0
node-heap-data-size (function)
(setf node-heap-data-size) (function)
node-heap-data-path (function)
(setf node-heap-data-path) (function)
0
node-heap-data-sn (function)
(setf node-heap-data-sn) (function)
Next: Internal types, Previous: Internal structures, Up: Internal definitions [Contents][Index]
Max heaps for path-transform computation
lisp.lisp (file)
standard-object (class)
simple-vector
(make-array (quote (10)))
node-heap/heap (generic function)
(setf node-heap/heap) (generic function)
(integer 0)
0
node-heap/count (generic function)
(setf node-heap/count) (generic function)
An object used to rewrite fingers from one tree to another.
lisp.lisp (file)
standard-object (class)
functional-trees:node
:from
(alexandria:required-argument :from)
from (generic function)
A list of (<path-set> <path> <status>) triples
where <path-set> is a path set, <path> is the mapping of the initial path
in that <path-set>, and <status> is one of :live :dead. These should be
sorted into non-increasing order of length of <path>. If missing, compute
from the source/target node pair, if possible.
list
:transforms
transforms (generic function)
lisp.lisp (file)
standard-object (class)
functional-trees::trie-node
:root
root (generic function)
(setf root) (generic function)
lisp.lisp (file)
standard-object (class)
Data for segments that end at this trie node, or NIL if no such segments end here.
:data
data (generic function)
(setf data) (generic function)
Alist mapping indices to trie nodes
list
:map
trie-map (generic function)
(setf trie-map) (generic function)
Previous: Internal classes, Up: Internal definitions [Contents][Index]
lisp.lisp (file)
Previous: Definitions, Up: Top [Contents][Index]
| • Concept index | ||
| • Function index | ||
| • Variable index | ||
| • Data type index |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
| Jump to: | F L |
|---|
| Jump to: | F L |
|---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
| Jump to: | (
A C D E F G L M N P R S T U W |
|---|
| Jump to: | (
A C D E F G L M N P R S T U W |
|---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
| Jump to: | *
C D F H M N P R S T |
|---|
| Jump to: | *
C D F H M N P R S T |
|---|
Previous: Variable index, Up: Indexes [Contents][Index]
| Jump to: | C F N P S T |
|---|
| Jump to: | C F N P S T |
|---|