The functional-trees Reference Manual

Table of Contents

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

The functional-trees Reference Manual

This is the functional-trees Reference Manual, version 0.0.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Tue Apr 28 11:50:40 2020 GMT+0.


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

1 Introduction

Functional Trees

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.

Design and Usage

Sub-classing the node class

In 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.

(defclass if-then-else-node (node)
  ((child-slots :initform '((then . 1) else) :allocation :class)
   (then :reader then :type node)
   (else :reader else :type '(list node)))
  (:documentation "An if-then-else subtree of a program AST."))

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.

Tasks


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

2 Systems

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


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

2.1 functional-trees

Author

GrammaTech

License

MIT

Description

Tree data structure supporting functional manipulation

Long Description

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.

Version

0.0.0

Defsystem Dependency

asdf-package-system

Dependency

functional-trees/functional-trees (system)

Source

functional-trees.asd (file)


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

2.2 functional-trees/functional-trees

Author

GrammaTech

License

MIT

Dependencies
Source

functional-trees.asd (file)

Component

lisp.lisp (file)


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

3 Files

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


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

3.1 Lisp


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

3.1.1 functional-trees.asd

Location

functional-trees.asd

Systems

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

3.1.2 functional-trees/functional-trees/lisp.lisp

Parent

functional-trees/functional-trees (system)

Location

functional-trees.lisp

Packages

functional-trees

Exported Definitions
Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 functional-trees

Prototype implementation of functional trees w. finger objects

Source

lisp.lisp (file)

Nicknames
Use List
Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Macros

Macro: do-tree (VAR TREE &key INDEX REBUILD VALUE) &body BODY

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 return nodes are left on the stack and BODY should return two values (MODIFIEDP NEW-BLOCK) indicating if the node has been modified and if so, giving the new value to use (where NEW-BLOCK of NIL means to remove that block). If not REBUILD, then a non-nil return from body terminates recursion.

Package

functional-trees

Source

lisp.lisp (file)


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

5.1.2 Generic functions

Generic Function: child-slots OBJECT
Package

functional-trees

Methods
Method: child-slots (NODE node)

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.

Source

lisp.lisp (file)

Generic Function: children NODE

Return all children of NODE.

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: children (NODE node)
Generic Function: copy OBJ &key &allow-other-keys

Generic COPY method.

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: copy (NODE node) &rest KEYS
Method: copy OBJ &key &allow-other-keys
Method: copy (OBJ array) &key &allow-other-keys
Method: copy (OBJ hash-table) &key &allow-other-keys
Method: copy (OBJ list) &key &allow-other-keys
Method: copy (OBJ sequence) &key &allow-other-keys
Method: copy (OBJ symbol) &key &allow-other-keys
Generic Function: finger OBJECT
Package

functional-trees

Methods
Method: finger (NODE node)

A finger back to the root of the (a?) tree.

Source

lisp.lisp (file)

Generic Function: mapc FUNCTION CONTAINER &rest MORE

Map FUNCTION over CONTAINER.

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: mapc FUNCTION (TREE node) &rest MORE
Method: mapc FUNCTION (NOTHING null) &rest MORE
Method: mapc FUNCTION ANYTHING &rest MORE
Method: mapc FUNCTION (SEQUENCE sequence) &rest MORE
Generic Function: mapcar FUNCTION CONTAINER &rest MORE

Map FUNCTION over CONTAINER.

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: mapcar FUNCTION (TREE node) &rest MORE
Method: mapcar FUNCTION (NOTHING null) &rest MORE
Method: mapcar FUNCTION ANYTHING &rest MORE
Method: mapcar FUNCTION (SEQUENCE sequence) &rest MORE
Method: mapcar FUNCTION (SEQUENCE list) &rest MORE
Generic Function: node OBJECT
Package

functional-trees

Methods
Method: node (FINGER finger)

The node to which this finger pertains, considered as the root of a tree.

Source

lisp.lisp (file)

Generic Function: node-equalp NODE1 NODE2

Check that two nodes are the same tree

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: node-equalp (NODE1 node) (NODE2 node)
Method: node-equalp NODE1 NODE2
Generic Function: path OBJECT
Package

functional-trees

Methods
Method: path (FINGER finger)

A list of nonnegative integer values giving a path from node down to another node.

Source

lisp.lisp (file)

Generic Function: populate-fingers ROOT

Walk tree, creating fingers back to root.

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: populate-fingers (ROOT node)
Method: populate-fingers (ROOT null)
Generic Function: residue OBJECT
Package

functional-trees

Methods
Method: residue (FINGER finger)

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.

Source

lisp.lisp (file)

Generic Function: swap TREE LOCATION-1 LOCATION-2

Swap the contents of LOCATION-1 and LOCATION-2 in TREE.

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: swap (TREE node) (LOCATION-1 list) (LOCATION-2 list)
Method: swap (TREE node) (LOCATION-1 node) LOCATION-2
Method: swap (TREE node) LOCATION-1 (LOCATION-2 node)
Method: swap (TREE node) LOCATION-1 LOCATION-2 around
Generic Function: transform OBJECT
Package

functional-trees

Methods
Method: transform (N node) around
Source

lisp.lisp (file)

Method: transform (NODE node)

If non-nil, is either a PATH-TRANSFORM object to this node, or the node that led to this node.

Source

lisp.lisp (file)

Generic Function: transform-finger-to F P TO

Converts a finger from one tree to another.

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: transform-finger-to (F finger) (P path-transform) (TO node)
Method: transform-finger-to (F finger) (P path-transform) (TO node) around

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

5.1.3 Classes

Class: finger ()

A wrapper for a path to get to a node

Package

functional-trees

Source

lisp.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: node

The node to which this finger pertains, considered as the root of a tree.

Type

functional-trees:node

Initargs

:node

Initform

(alexandria:required-argument :node)

Readers

node (generic function)

Slot: path

A list of nonnegative integer values giving a path from node down to another node.

Type

functional-trees:path

Initargs

:path

Initform

(alexandria:required-argument :path)

Readers

path (generic function)

Slot: residue

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.

Type

list

Initargs

:residue

Readers

residue (generic function)

Slot: cache

Internal slot used to cache the lookup of a node.

Readers

cache (generic function)

Writers

(setf cache) (generic function)

Class: node ()

A node in a tree.

Package

functional-trees

Source

lisp.lisp (file)

Direct superclasses

identity-ordering-mixin (class)

Direct methods
  • subst-if (method)
  • subst (method)
  • substitute (method)
  • substitute-if-not (method)
  • substitute-if (method)
  • remove (method)
  • remove-if-not (method)
  • remove-if (method)
  • remove-if (method)
  • position (method)
  • position-if-not (method)
  • position-if (method)
  • count (method)
  • count-if-not (method)
  • count-if (method)
  • find (method)
  • find-if-not (method)
  • find-if (method)
  • reduce (method)
  • substitute-with (method)
  • substitute-with (method)
  • mapcar (method)
  • mapc (method)
  • convert (method)
  • convert (method)
  • node-values (method)
  • print-object (method)
  • swap (method)
  • swap (method)
  • swap (method)
  • swap (method)
  • insert (method)
  • insert (method)
  • insert (method)
  • insert (method)
  • insert (method)
  • splice (method)
  • splice (method)
  • splice (method)
  • splice (method)
  • splice (method)
  • less (method)
  • less (method)
  • less (method)
  • less (method)
  • less (method)
  • with (method)
  • with (method)
  • with (method)
  • with (method)
  • with (method)
  • lookup (method)
  • lookup (method)
  • lookup (method)
  • lookup (method)
  • node-equalp (method)
  • path-transform-of (method)
  • node-can-implant (method)
  • nodes-disjoint (method)
  • node-valid (method)
  • populate-fingers (method)
  • transform-finger (method)
  • transform-finger-to (method)
  • transform-finger-to (method)
  • copy (method)
  • slot-unbound (method)
  • transform (method)
  • initialize-instance (method)
  • children (method)
  • finger (method)
  • child-slots (method)
  • size (method)
  • transform (method)
Direct slots
Slot: transform

If non-nil, is either a PATH-TRANSFORM object to this node, or the node that led to this node.

Type

(or null functional-trees:node functional-trees::path-transform)

Initargs

:transform

Readers

transform (generic function)

Slot: size

Number of nodes in tree rooted here.

Type

(integer 1)

Readers

size (generic function)

Slot: child-slots

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.

Type

list

Allocation

:class

Readers

child-slots (generic function)

Slot: finger

A finger back to the root of the (a?) tree.

Type

(or null functional-trees:node functional-trees:finger)

Readers

finger (generic function)


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

5.1.4 Types

Type: path ()
Package

functional-trees

Source

lisp.lisp (file)


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

5.2 Internal definitions


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

5.2.1 Macros

Macro: assert &body BODY
Package

functional-trees

Source

lisp.lisp (file)

Macro: descend (NAME &key OTHER-ARGS EXTRA-ARGS REPLACE SPLICE CHECKS) &body NEW

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.

Package

functional-trees

Source

lisp.lisp (file)

Macro: dump &body FORMS
Package

functional-trees

Source

lisp.lisp (file)

Macro: test-handler FN

This macro is an idiom that occurs in many methods. It handles checking and normalization of :TEST and :TEST-NOT arguments.

Package

functional-trees

Source

lisp.lisp (file)

Macro: with-encapsulation TREE &body BODY
Package

functional-trees

Source

lisp.lisp (file)


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

5.2.2 Functions

Function: copy-node-heap-data INSTANCE
Package

functional-trees

Source

lisp.lisp (file)

Function: encapsulate TREE REWRITE-FN

Apply REWRITE-FN to TREE, producing a new tree. The new tree has its predecessor set to TREE.

Package

functional-trees

Source

lisp.lisp (file)

Function: expand-children-defmethod CLASS CHILD-SLOTS
Package

functional-trees

Source

lisp.lisp (file)

Function: expand-copying-setf-writers CLASS CHILD-SLOTS
Package

functional-trees

Source

lisp.lisp (file)

Function: expand-lookup-specialization CLASS CHILD-SLOTS
Package

functional-trees

Source

lisp.lisp (file)

Function: lexicographic-< LIST1 LIST2

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

Package

functional-trees

Source

lisp.lisp (file)

Function: make-node-heap ()
Package

functional-trees

Source

lisp.lisp (file)

Function: make-node-heap-data &key (NODE NODE) (SIZE SIZE) (PATH PATH) (SN SN)
Package

functional-trees

Source

lisp.lisp (file)

Function: make-trie ()
Package

functional-trees

Source

lisp.lisp (file)

Function: node-heap-add-children NH NODE PATH
Package

functional-trees

Source

lisp.lisp (file)

Function: node-heap-data-< ND1 ND2
Package

functional-trees

Source

lisp.lisp (file)

Function: node-heap-data-node INSTANCE
Function: (setf node-heap-data-node) VALUE INSTANCE
Package

functional-trees

Source

lisp.lisp (file)

Function: node-heap-data-p OBJECT
Package

functional-trees

Source

lisp.lisp (file)

Function: node-heap-data-path INSTANCE
Function: (setf node-heap-data-path) VALUE INSTANCE
Package

functional-trees

Source

lisp.lisp (file)

Function: node-heap-data-size INSTANCE
Function: (setf node-heap-data-size) VALUE INSTANCE
Package

functional-trees

Source

lisp.lisp (file)

Function: node-heap-data-sn INSTANCE
Function: (setf node-heap-data-sn) VALUE INSTANCE
Package

functional-trees

Source

lisp.lisp (file)

Function: node-heap-insert NH NODE PATH
Package

functional-trees

Source

lisp.lisp (file)

Function: node-heap-pop NH
Package

functional-trees

Source

lisp.lisp (file)

Function: node-heap-sift-down HEAP COUNT
Package

functional-trees

Source

lisp.lisp (file)

Function: node-heap-sift-up HEAP I
Package

functional-trees

Source

lisp.lisp (file)

Function: path-of-node ROOT NODE
Package

functional-trees

Source

lisp.lisp (file)

Function: path-p LIST
Package

functional-trees

Source

lisp.lisp (file)

Function: path-transform-compress-mapping MAPPING

Internal function used to remove redundancy from a set of path mappings.

Package

functional-trees

Source

lisp.lisp (file)

Function: prefix? P1 P2

True if list P1 is a prefix of P2

Package

functional-trees

Source

lisp.lisp (file)

Function: store-nodes NODE TABLE
Package

functional-trees

Source

lisp.lisp (file)

Function: transforms-to-trie TRANSFORMS

Construct a trie for TRANSFORMS, which is a list as described in the transforms slot of PATH-TRANSFORMS objects.

Package

functional-trees

Source

lisp.lisp (file)


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

5.2.3 Generic functions

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

functional-trees

Methods
Method: cache (FINGER finger)
Method: (setf cache) NEW-VALUE (FINGER finger)

Internal slot used to cache the lookup of a node.

Source

lisp.lisp (file)

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

functional-trees

Methods
Method: data (TRIE-NODE trie-node)
Method: (setf data) NEW-VALUE (TRIE-NODE trie-node)

Data for segments that end at this trie node, or NIL if no such segments end here.

Source

lisp.lisp (file)

Generic Function: from OBJECT
Package

functional-trees

Methods
Method: from (X null)
Source

lisp.lisp (file)

Method: from (PATH-TRANSFORM path-transform)

automatically generated reader method

Source

lisp.lisp (file)

Generic Function: node-can-implant ROOT AT-NODE NEW-NODE

Check if new-node can the subtree rooted at at-node below ROOT and produce a valid tree.

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: node-can-implant (ROOT node) (AT-NODE node) (NEW-NODE node)
Generic Function: node-heap/count OBJECT
Generic Function: (setf node-heap/count) NEW-VALUE OBJECT
Package

functional-trees

Methods
Method: node-heap/count (NODE-HEAP node-heap)

automatically generated reader method

Source

lisp.lisp (file)

Method: (setf node-heap/count) NEW-VALUE (NODE-HEAP node-heap)

automatically generated writer method

Source

lisp.lisp (file)

Generic Function: node-heap/heap OBJECT
Generic Function: (setf node-heap/heap) NEW-VALUE OBJECT
Package

functional-trees

Methods
Method: node-heap/heap (NODE-HEAP node-heap)

automatically generated reader method

Source

lisp.lisp (file)

Method: (setf node-heap/heap) NEW-VALUE (NODE-HEAP node-heap)

automatically generated writer method

Source

lisp.lisp (file)

Generic Function: node-valid NODE

True if the tree rooted at NODE have EQL unique
serial-numbers, and no node occurs on two different paths in the tree

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: node-valid (NODE node)
Generic Function: node-values NODE

Returns multiple values that are used by
CONVERT ’LIST to append to the beginning of the list representation of a node.

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: node-values (NODE node)
Generic Function: nodes-disjoint NODE1 NODE2

Return true if NODE1 and NODE2 do not share any serial-number

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: nodes-disjoint (NODE1 node) (NODE2 node)
Generic Function: path-transform-of FROM-NODE TO-NODE

Produce a path transform that maps FROM-NODE to TO-NODE

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: path-transform-of (ORIG-FROM node) (TO node)
Generic Function: root OBJECT
Generic Function: (setf root) NEW-VALUE OBJECT
Package

functional-trees

Methods
Method: root (TRIE trie)

automatically generated reader method

Source

lisp.lisp (file)

Method: (setf root) NEW-VALUE (TRIE trie)

automatically generated writer method

Source

lisp.lisp (file)

Generic Function: subst NEW OLD TREE &key KEY TEST TEST-NOT &allow-other-keys

If TREE is a cons, this simply calls ‘cl:subst’. Also works on a functional tree node.

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: subst NEW OLD (TREE cons) &key KEY TEST TEST-NOT
Method: subst NEW OLD (TREE node) &rest REST &key &allow-other-keys
Generic Function: subst-if NEW TEST TREE &key KEY &allow-other-keys

If TREE is a cons, this simply calls ‘cl:subst-if’. Also works on a functional tree node.

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: subst-if NEW TEST (TREE cons) &key KEY
Method: subst-if NEW TEST (TREE node) &rest REST &key &allow-other-keys
Generic Function: subst-if-not NEW TEST TREE &key KEY

If TREE is a cons, this simply calls ‘cl:subst-if’. Also works on a functional tree node.

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: subst-if-not NEW TEST TREE &key KEY
Generic Function: substitute-with PREDICATE SEQUENCE &key KEY &allow-other-keys

Substitute elements of SEQUENCE with result of PREDICATE when non-nil. If secondary return value of PREDICATE is non-nil force substitution with primary value even if it is nil.

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: substitute-with FUNCTION (NODE node) &key &allow-other-keys around
Method: substitute-with PREDICATE (SEQUENCE sequence) &key &allow-other-keys
Method: substitute-with PREDICATE (SEQ seq) &key &allow-other-keys &aux RESULT
Method: substitute-with FUNCTION (NODE node) &key KEY &allow-other-keys
Generic Function: transform-finger FINGER NODE &key ERROR-P

Transforms FINGER, producing a new finger that
points through the root NODE. NODE must be derived from the tree that FINGER is pointed through.

Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: transform-finger (F finger) (NODE node) &key ERROR-P
Generic Function: transform-path PATH TRANSFORMS
Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: transform-path (PATH list) (TRANSFORMS list)
Method: transform-path (ORIG-PATH list) (TRIE trie)
Generic Function: transforms OBJECT
Package

functional-trees

Methods
Method: transforms (PATH-TRANSFORM path-transform)

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.

Source

lisp.lisp (file)

Generic Function: trie-insert TRIE SEGMENT DATA
Package

functional-trees

Source

lisp.lisp (file)

Methods
Method: trie-insert (TRIE trie) (SEGMENT list) DATA
Generic Function: trie-map OBJECT
Generic Function: (setf trie-map) NEW-VALUE OBJECT
Package

functional-trees

Methods
Method: trie-map (TRIE-NODE trie-node)
Method: (setf trie-map) NEW-VALUE (TRIE-NODE trie-node)

Alist mapping indices to trie nodes

Source

lisp.lisp (file)


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

5.2.4 Structures

Structure: node-heap-data ()
Package

functional-trees

Source

lisp.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: node
Readers

node-heap-data-node (function)

Writers

(setf node-heap-data-node) (function)

Slot: size
Initform

0

Readers

node-heap-data-size (function)

Writers

(setf node-heap-data-size) (function)

Slot: path
Readers

node-heap-data-path (function)

Writers

(setf node-heap-data-path) (function)

Slot: sn
Initform

0

Readers

node-heap-data-sn (function)

Writers

(setf node-heap-data-sn) (function)


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

5.2.5 Classes

Class: node-heap ()

Max heaps for path-transform computation

Package

functional-trees

Source

lisp.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: heap
Type

simple-vector

Initform

(make-array (quote (10)))

Readers

node-heap/heap (generic function)

Writers

(setf node-heap/heap) (generic function)

Slot: count
Type

(integer 0)

Initform

0

Readers

node-heap/count (generic function)

Writers

(setf node-heap/count) (generic function)

Class: path-transform ()

An object used to rewrite fingers from one tree to another.

Package

functional-trees

Source

lisp.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: from
Type

functional-trees:node

Initargs

:from

Initform

(alexandria:required-argument :from)

Readers

from (generic function)

Slot: transforms

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.

Type

list

Initargs

:transforms

Readers

transforms (generic function)

Class: trie ()
Package

functional-trees

Source

lisp.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: root
Type

functional-trees::trie-node

Initargs

:root

Readers

root (generic function)

Writers

(setf root) (generic function)

Class: trie-node ()
Package

functional-trees

Source

lisp.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
  • trie-map (method)
  • trie-map (method)
  • data (method)
  • data (method)
Direct slots
Slot: data

Data for segments that end at this trie node, or NIL if no such segments end here.

Initargs

:data

Readers

data (generic function)

Writers

(setf data) (generic function)

Slot: map

Alist mapping indices to trie nodes

Type

list

Initargs

:map

Readers

trie-map (generic function)

Writers

(setf trie-map) (generic function)


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

5.2.6 Types

Type: node-heap-index ()
Package

functional-trees

Source

lisp.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L  
Index Entry  Section

F
File, Lisp, functional-trees.asd: The functional-trees․asd file
File, Lisp, functional-trees/functional-trees/lisp.lisp: The functional-trees/functional-trees/lisp․lisp file
functional-trees.asd: The functional-trees․asd file
functional-trees/functional-trees/lisp.lisp: The functional-trees/functional-trees/lisp․lisp file

L
Lisp File, functional-trees.asd: The functional-trees․asd file
Lisp File, functional-trees/functional-trees/lisp.lisp: The functional-trees/functional-trees/lisp․lisp file

Jump to:   F   L  

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

A.2 Functions

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

(
(setf cache): Internal generic functions
(setf cache): Internal generic functions
(setf data): Internal generic functions
(setf data): Internal generic functions
(setf node-heap-data-node): Internal functions
(setf node-heap-data-path): Internal functions
(setf node-heap-data-size): Internal functions
(setf node-heap-data-sn): Internal functions
(setf node-heap/count): Internal generic functions
(setf node-heap/count): Internal generic functions
(setf node-heap/heap): Internal generic functions
(setf node-heap/heap): Internal generic functions
(setf root): Internal generic functions
(setf root): Internal generic functions
(setf trie-map): Internal generic functions
(setf trie-map): Internal generic functions

A
assert: Internal macros

C
cache: Internal generic functions
cache: Internal generic functions
child-slots: Exported generic functions
child-slots: Exported generic functions
children: Exported generic functions
children: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy: Exported generic functions
copy-node-heap-data: Internal functions

D
data: Internal generic functions
data: Internal generic functions
descend: Internal macros
do-tree: Exported macros
dump: Internal macros

E
encapsulate: Internal functions
expand-children-defmethod: Internal functions
expand-copying-setf-writers: Internal functions
expand-lookup-specialization: Internal functions

F
finger: Exported generic functions
finger: Exported generic functions
from: Internal generic functions
from: Internal generic functions
from: Internal generic functions
Function, (setf node-heap-data-node): Internal functions
Function, (setf node-heap-data-path): Internal functions
Function, (setf node-heap-data-size): Internal functions
Function, (setf node-heap-data-sn): Internal functions
Function, copy-node-heap-data: Internal functions
Function, encapsulate: Internal functions
Function, expand-children-defmethod: Internal functions
Function, expand-copying-setf-writers: Internal functions
Function, expand-lookup-specialization: Internal functions
Function, lexicographic-<: Internal functions
Function, make-node-heap: Internal functions
Function, make-node-heap-data: Internal functions
Function, make-trie: Internal functions
Function, node-heap-add-children: Internal functions
Function, node-heap-data-<: Internal functions
Function, node-heap-data-node: Internal functions
Function, node-heap-data-p: Internal functions
Function, node-heap-data-path: Internal functions
Function, node-heap-data-size: Internal functions
Function, node-heap-data-sn: Internal functions
Function, node-heap-insert: Internal functions
Function, node-heap-pop: Internal functions
Function, node-heap-sift-down: Internal functions
Function, node-heap-sift-up: Internal functions
Function, path-of-node: Internal functions
Function, path-p: Internal functions
Function, path-transform-compress-mapping: Internal functions
Function, prefix?: Internal functions
Function, store-nodes: Internal functions
Function, transforms-to-trie: Internal functions

G
Generic Function, (setf cache): Internal generic functions
Generic Function, (setf data): Internal generic functions
Generic Function, (setf node-heap/count): Internal generic functions
Generic Function, (setf node-heap/heap): Internal generic functions
Generic Function, (setf root): Internal generic functions
Generic Function, (setf trie-map): Internal generic functions
Generic Function, cache: Internal generic functions
Generic Function, child-slots: Exported generic functions
Generic Function, children: Exported generic functions
Generic Function, copy: Exported generic functions
Generic Function, data: Internal generic functions
Generic Function, finger: Exported generic functions
Generic Function, from: Internal generic functions
Generic Function, mapc: Exported generic functions
Generic Function, mapcar: Exported generic functions
Generic Function, node: Exported generic functions
Generic Function, node-can-implant: Internal generic functions
Generic Function, node-equalp: Exported generic functions
Generic Function, node-heap/count: Internal generic functions
Generic Function, node-heap/heap: Internal generic functions
Generic Function, node-valid: Internal generic functions
Generic Function, node-values: Internal generic functions
Generic Function, nodes-disjoint: Internal generic functions
Generic Function, path: Exported generic functions
Generic Function, path-transform-of: Internal generic functions
Generic Function, populate-fingers: Exported generic functions
Generic Function, residue: Exported generic functions
Generic Function, root: Internal generic functions
Generic Function, subst: Internal generic functions
Generic Function, subst-if: Internal generic functions
Generic Function, subst-if-not: Internal generic functions
Generic Function, substitute-with: Internal generic functions
Generic Function, swap: Exported generic functions
Generic Function, transform: Exported generic functions
Generic Function, transform-finger: Internal generic functions
Generic Function, transform-finger-to: Exported generic functions
Generic Function, transform-path: Internal generic functions
Generic Function, transforms: Internal generic functions
Generic Function, trie-insert: Internal generic functions
Generic Function, trie-map: Internal generic functions

L
lexicographic-<: Internal functions

M
Macro, assert: Internal macros
Macro, descend: Internal macros
Macro, do-tree: Exported macros
Macro, dump: Internal macros
Macro, test-handler: Internal macros
Macro, with-encapsulation: Internal macros
make-node-heap: Internal functions
make-node-heap-data: Internal functions
make-trie: Internal functions
mapc: Exported generic functions
mapc: Exported generic functions
mapc: Exported generic functions
mapc: Exported generic functions
mapc: Exported generic functions
mapcar: Exported generic functions
mapcar: Exported generic functions
mapcar: Exported generic functions
mapcar: Exported generic functions
mapcar: Exported generic functions
mapcar: Exported generic functions
Method, (setf cache): Internal generic functions
Method, (setf data): Internal generic functions
Method, (setf node-heap/count): Internal generic functions
Method, (setf node-heap/heap): Internal generic functions
Method, (setf root): Internal generic functions
Method, (setf trie-map): Internal generic functions
Method, cache: Internal generic functions
Method, child-slots: Exported generic functions
Method, children: Exported generic functions
Method, copy: Exported generic functions
Method, copy: Exported generic functions
Method, copy: Exported generic functions
Method, copy: Exported generic functions
Method, copy: Exported generic functions
Method, copy: Exported generic functions
Method, copy: Exported generic functions
Method, data: Internal generic functions
Method, finger: Exported generic functions
Method, from: Internal generic functions
Method, from: Internal generic functions
Method, mapc: Exported generic functions
Method, mapc: Exported generic functions
Method, mapc: Exported generic functions
Method, mapc: Exported generic functions
Method, mapcar: Exported generic functions
Method, mapcar: Exported generic functions
Method, mapcar: Exported generic functions
Method, mapcar: Exported generic functions
Method, mapcar: Exported generic functions
Method, node: Exported generic functions
Method, node-can-implant: Internal generic functions
Method, node-equalp: Exported generic functions
Method, node-equalp: Exported generic functions
Method, node-heap/count: Internal generic functions
Method, node-heap/heap: Internal generic functions
Method, node-valid: Internal generic functions
Method, node-values: Internal generic functions
Method, nodes-disjoint: Internal generic functions
Method, path: Exported generic functions
Method, path-transform-of: Internal generic functions
Method, populate-fingers: Exported generic functions
Method, populate-fingers: Exported generic functions
Method, residue: Exported generic functions
Method, root: Internal generic functions
Method, subst: Internal generic functions
Method, subst: Internal generic functions
Method, subst-if: Internal generic functions
Method, subst-if: Internal generic functions
Method, subst-if-not: Internal generic functions
Method, substitute-with: Internal generic functions
Method, substitute-with: Internal generic functions
Method, substitute-with: Internal generic functions
Method, substitute-with: Internal generic functions
Method, swap: Exported generic functions
Method, swap: Exported generic functions
Method, swap: Exported generic functions
Method, swap: Exported generic functions
Method, transform: Exported generic functions
Method, transform: Exported generic functions
Method, transform-finger: Internal generic functions
Method, transform-finger-to: Exported generic functions
Method, transform-finger-to: Exported generic functions
Method, transform-path: Internal generic functions
Method, transform-path: Internal generic functions
Method, transforms: Internal generic functions
Method, trie-insert: Internal generic functions
Method, trie-map: Internal generic functions

N
node: Exported generic functions
node: Exported generic functions
node-can-implant: Internal generic functions
node-can-implant: Internal generic functions
node-equalp: Exported generic functions
node-equalp: Exported generic functions
node-equalp: Exported generic functions
node-heap-add-children: Internal functions
node-heap-data-<: Internal functions
node-heap-data-node: Internal functions
node-heap-data-p: Internal functions
node-heap-data-path: Internal functions
node-heap-data-size: Internal functions
node-heap-data-sn: Internal functions
node-heap-insert: Internal functions
node-heap-pop: Internal functions
node-heap-sift-down: Internal functions
node-heap-sift-up: Internal functions
node-heap/count: Internal generic functions
node-heap/count: Internal generic functions
node-heap/heap: Internal generic functions
node-heap/heap: Internal generic functions
node-valid: Internal generic functions
node-valid: Internal generic functions
node-values: Internal generic functions
node-values: Internal generic functions
nodes-disjoint: Internal generic functions
nodes-disjoint: Internal generic functions

P
path: Exported generic functions
path: Exported generic functions
path-of-node: Internal functions
path-p: Internal functions
path-transform-compress-mapping: Internal functions
path-transform-of: Internal generic functions
path-transform-of: Internal generic functions
populate-fingers: Exported generic functions
populate-fingers: Exported generic functions
populate-fingers: Exported generic functions
prefix?: Internal functions

R
residue: Exported generic functions
residue: Exported generic functions
root: Internal generic functions
root: Internal generic functions

S
store-nodes: Internal functions
subst: Internal generic functions
subst: Internal generic functions
subst: Internal generic functions
subst-if: Internal generic functions
subst-if: Internal generic functions
subst-if: Internal generic functions
subst-if-not: Internal generic functions
subst-if-not: Internal generic functions
substitute-with: Internal generic functions
substitute-with: Internal generic functions
substitute-with: Internal generic functions
substitute-with: Internal generic functions
substitute-with: Internal generic functions
swap: Exported generic functions
swap: Exported generic functions
swap: Exported generic functions
swap: Exported generic functions
swap: Exported generic functions

T
test-handler: Internal macros
transform: Exported generic functions
transform: Exported generic functions
transform: Exported generic functions
transform-finger: Internal generic functions
transform-finger: Internal generic functions
transform-finger-to: Exported generic functions
transform-finger-to: Exported generic functions
transform-finger-to: Exported generic functions
transform-path: Internal generic functions
transform-path: Internal generic functions
transform-path: Internal generic functions
transforms: Internal generic functions
transforms: Internal generic functions
transforms-to-trie: Internal functions
trie-insert: Internal generic functions
trie-insert: Internal generic functions
trie-map: Internal generic functions
trie-map: Internal generic functions

W
with-encapsulation: Internal macros

Jump to:   (  
A   C   D   E   F   G   L   M   N   P   R   S   T   W  

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

A.3 Variables

Jump to:   C   D   F   H   M   N   P   R   S   T  
Index Entry  Section

C
cache: Exported classes
child-slots: Exported classes
count: Internal classes

D
data: Internal classes

F
finger: Exported classes
from: Internal classes

H
heap: Internal classes

M
map: Internal classes

N
node: Exported classes
node: Internal structures

P
path: Exported classes
path: Internal structures

R
residue: Exported classes
root: Internal classes

S
size: Exported classes
size: Internal structures
Slot, cache: Exported classes
Slot, child-slots: Exported classes
Slot, count: Internal classes
Slot, data: Internal classes
Slot, finger: Exported classes
Slot, from: Internal classes
Slot, heap: Internal classes
Slot, map: Internal classes
Slot, node: Exported classes
Slot, node: Internal structures
Slot, path: Exported classes
Slot, path: Internal structures
Slot, residue: Exported classes
Slot, root: Internal classes
Slot, size: Exported classes
Slot, size: Internal structures
Slot, sn: Internal structures
Slot, transform: Exported classes
Slot, transforms: Internal classes
sn: Internal structures

T
transform: Exported classes
transforms: Internal classes

Jump to:   C   D   F   H   M   N   P   R   S   T  

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

A.4 Data types

Jump to:   C   F   N   P   S   T  
Index Entry  Section

C
Class, finger: Exported classes
Class, node: Exported classes
Class, node-heap: Internal classes
Class, path-transform: Internal classes
Class, trie: Internal classes
Class, trie-node: Internal classes

F
finger: Exported classes
functional-trees: The functional-trees system
functional-trees: The functional-trees package
functional-trees/functional-trees: The functional-trees/functional-trees system

N
node: Exported classes
node-heap: Internal classes
node-heap-data: Internal structures
node-heap-index: Internal types

P
Package, functional-trees: The functional-trees package
path: Exported types
path-transform: Internal classes

S
Structure, node-heap-data: Internal structures
System, functional-trees: The functional-trees system
System, functional-trees/functional-trees: The functional-trees/functional-trees system

T
trie: Internal classes
trie-node: Internal classes
Type, node-heap-index: Internal types
Type, path: Exported types

Jump to:   C   F   N   P   S   T