The cl-trie Reference Manual

Table of Contents

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

The cl-trie Reference Manual

This is the cl-trie Reference Manual, generated automatically by Declt version 2.3 "Robert April" on Tue Jan 09 14:05:27 2018 GMT+0.


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

1 Introduction

Build Status

Overview

cl-trie is a package that contains an implementation of a trie data structure. It utilizes CLOS. By default the trie is indexed by strings, but can be extended to other data types using inheritance on the base trie class.

License

cl-trie is licensed with MIT license, which means that you can do pretty much everything with it. Enjoy!

Compatibility

I am trying to build the library on as many compilers that I can. I have encountered some problems with UIOP on CLISP; therefore, CLISP is not supported, which means that I do not guarantee that code works on CLISP, but it should work (since it works on all other conforming compilers).

API Reference

I have not decided how to present the API reference yet. You can find all the generic functions in the src/generics.lisp; each generic function has a documentation string. The only missing piece is accessors and utility functions, but the only utility right now is hash-table->trie, which is pretty self explanatory.

Example

This example will simply use the basic example from the #:cl-trie-examples package.

Basic idea

In this example, we will define a function that shows cl-trie features and prints some data about the text file.

Loading file

We want to create a function that loads a text file to trie. We will do that by splitting the line on whitespace (using cl-ppcre).

(defun load-into-trie (file)
  (with-open-file (in file)
    ;; By default, trie warns you when you don't set the key
    ;; The only valid key is either character or NIL.
    ;; We muffle warning by setting verbose to NIL, making key take the default value
    ;; The default value for key is NIL.
    (loop with trie = (make-instance 'cl-trie:trie :verbose nil)
       for line = (read-line in nil 'eof nil)
       until (eql 'eof line)
       for splitted-line = (cl-ppcre:split "\\s" line)
       do (mapc (lambda (word) (setf (cl-trie:lookup trie word)
                                  ;; lookup accepts default returned value.
                                  ;; By default there are 0 words in text.
                                  (1+ (cl-trie:lookup trie word 0))))
                splitted-line)
       finally (return trie))))

As you can see, we create a fresh trie(and use :verbose nil to stop it from warning us about having no key). We use (setf cl-trie:lookup) and cl-trie:lookup to count words.

This is a good place to talk about how tries are defined when it comes to keys and children.

Each node of trie is a trie too. This means that you attach tries to other tries and create circular tries. While the first idea is quite okay, the second one is very likely to break things, so tread carefully. Also, notice that we did not put any key. This makes trie partially broken. It's okay if trie does not start with any key, but it can't be attached later, so that is something one has to consider. Any valid trie has key of either character or NIL, but a valid subtrie can only have a key of CHAR.

Keys are also meant to be immutable. Changing the key of trie would affect many other keys. Therefore, this operation is discouraged and not part of the official interface. You can change the key using (slot-value trie cl-trie::%key). Author discourages this practice.

Now we will add a function that will load file into hash-table. It will be of use later.

(defun load-into-hash-table (file)
  (with-open-file (in file)
    (loop with ht = (make-hash-table :test #'equal)
       for line = (read-line in nil 'eof nil)
       until (eql 'eof line)
       for splitted-line = (cl-ppcre:split "\\s" line)
       do (mapc (lambda (word) (setf (gethash word ht)
                                  ;; lookup accepts default returned value.
                                  ;; By default there are 0 words in text.
                                  (1+ (gethash word ht 0))))
                splitted-line)
       finally (return ht))))

Printing the dictionary.

After we have loaded the file, we might want to take a look at all the unique words that we have there (our dictionary). To do that, we will use #'cl-trie:all-keys method, which accepts a trie and returns a list of all keys.

(defun print-sorted-dictionary (trie)
  ;; Since default trie implementation ensures that keys are sorted lexicographically, we can simply print all the keys
  (mapc #'print (cl-trie:all-keys trie))
  ;; There exists an all-values function, which returns all values instead of the keys.
  )

As per comments, there is a sister function #'cl-trie:all-values, and both functions go through the trie in lexicographical order, so we will get our keys sorted. The sorting part is done during tree creation.

The naming might be a bit inconsistent, but let me explain. When I am talking that tree has a key, I mean its key slot. When I am talking that tree has keys, I mean the strings that create nodes with values. Therefore all-keys is a function that works on keys - strings that we loaded, not single characters.

Printing dictionary size.

Dictionary size might also be of interest for us. We will print it using #'cl-trie:size. It accepts trie as an argument and is pretty self-explanatory:

(defun print-dictionary-size (trie)
  ;; Trie's size is number of unique strings(keys) it holds.
  (print (cl-trie:size trie)))

Printing word count

Next part is printing the word count. Since we initially used word as a key for word count, we will simply sum all the values in the trie. For that, we will use #'cl-trie:mapvalues which accepts a one-argument function and a trie. It applies function to each value in the trie.

(defun count-all-words (trie)
  (let ((counter 0))
    (cl-trie:mapvalues (lambda (x) (incf counter x)) trie)
    counter)
  ;; There exists a mapkeys function, which works the same as mapvalues, but function is applied on keys.
  ;; The order stays the same (lexicographical)
  )

As with #'all-keys, there is a sister function for #'cl-trie:mapvalues called #'cl-trie:mapkeys. Mapkeys also works on whole strings and not single characters - so, keys of trie and not single key.

Counting single word occurances.

Now we would like to be able to count how many times does a given word appear in the text. We also want to say that word appears 0 times if it has never been seen in the text. This operation is quite simple:

(defun word-occurances (trie word)
  ;; We can pass a default value that will be returned if there is no word in dictionary.
  ;; If there are no words in dictionary, that means there are 0 words.
  (cl-trie:lookup trie word 0))

The lookup has an O(n) worst-case complexity where n is length of the word. If we find it, we have travelled through N nodes. If there are missing nodes anywhere on the road(e.g. no "e" after "m" in "omegle" search), it is terminated immediately.

#'cl-trie:lookup returns two values: a value that it found, and bollean indicating whether or not a value has been found. This means that one can have NILs as values and distinguish them from NILs that simply mean "no such node found".

Checking if trie is empty

Trie can be empty if we clear it, or if we didn't insert anything yet. We use #'cl-trie:emptyp generic function for that.

(defun print-is-empty (trie)
  ;; Emptyp is a function that returns T when trie is empty and NIL otherwise.
  (if (cl-trie:emptyp trie)
      (princ "Yes")
      (princ "No"))
  (terpri))

Warning: Trie is considered empty if it does not contains any values! This means that you can have a trie with preserved structure, but all the values discarded. This will make future insertions faster (because you will not have to create all the nodes on your way), but trie will take a bit more size.

You clear trie using #'cl-trie:clear. Clear leaves structure behind; if you want to free the memory, set children of the root to NIL instead.

Checking for substring

Now we want to see if there is a word in trie that contains a given substring. The substring can be the string itself.

(defun has-substring (trie substring)
  ;; Return substring node if it was found, NIL otherwise
  (let ((substring-node (cl-trie:find-node trie substring)))
    (when substring-node
      substring-node)))

Since #'cl-trie:find-node returns NIL if no node has been found, we could have just returned its result. #'cl-trie:find-node looks for the node and returns it. If no node has been found, it returns NIL.

Find-node takes also a :create-new keyword argument, which by default is NIL. If the argument is T, find-node will create all the nodes needed to get to the target node, and that node, meaning that it:

Putting the functions together

Now we just need to gather the functions together.

First, we will define a small utility to announce what we are currently doing.

(defun announce (string)
  (terpri)
  (loop repeat 25 do (princ "=") finally (terpri))
  (format t "Now ~A!~%" string)
  (loop repeat 25 do (princ "=") finally (terpri))
  (terpri))

Now that we have it, let's take a look at the final function, analyze-file:

(defun analyze-file (file)
  ;; Measure time of loading the trie
  (announce "loading the file")
  (let ((trie (time (load-into-trie file))))
    (announce "printing the sorted dictionary")
    (print-sorted-dictionary trie)
    (announce "printing dictionary size")
    (print-dictionary-size trie)
    (announce "printing all words count (including duplicates)")
    (print (count-all-words trie))
    (announce "printing occurances of the word \"The\"")
    (print (word-occurances trie "The"))
    ;; We can set values of keys using (setf lookup) or #'insert.
    (cl-trie:insert (1+ (word-occurances trie "The")) trie "The")
    (announce "printing occurances of the word \"The\", after increasing it by 1")
    (print (word-occurances trie "The"))
    ;; Now since "The" is in the trie, we can be pretty sure it has "Th" substring in there:
    (announce "Printing whether there is a substring \"Th\" in there (should be!)")
    (print (has-substring trie "Th"))
    ;; Since we wrote has-substring so that it returns the node that it found,
    ;; we can also find that it has a substring "e" (comleting a word "The")
    ;; we can do that, because each node of trie is also a trie.
    (announce "Printing whether there is a substring \"e\" in the substring \"Th\"(should be!)")
    (print (has-substring (has-substring trie "Th") "e"))
    ;; Now remove the word "The" from the trie.
    (announce "Removing the \"The\" from the trie!")
    (cl-trie:remove-index trie "The")
    (announce "Printing occurances of the word \"The\" (should be 0)")
    (print (word-occurances trie "The"))
    (announce "Is the trie empty?")
    (print-is-empty trie)
    ;; Just to show how the function works, we clear the trie and reload it...
    (announce "Clearing the trie.")
    (cl-trie:clear trie)
    (announce "Is the trie empty?")
    (print-is-empty trie)
    ;; But this time we load it into the hash-table and convert it into the trie.
    (announce "Loading the file once again, but this time to hash-table and then converting it to trie.")
    (time (setf trie (cl-trie:hash-table->trie (load-into-hash-table file))))))

Quite lengthy, but pretty simple. We:

  1. Load the trie.
  2. Print sorted dictionary.
  3. Print dictionary size(word count).
  4. Print total number of words in the text.
  5. Print how many times does the word "The" appear in the text.
  6. Increase i ts occurances by 1.
  7. do 5. again
  8. Check for the "Th" substring in the text. Then, we check for the "e" substring in "Th" node (meaning that if there is, then "The" substring is also there).
  9. Remove "The" from the trie.
  10. Show that "The" is no longer in the trie.
  11. Show that trie is not empty.
  12. Clear the trie.
  13. Show that trie is empty afterwards.
  14. We finally reload the trie, but we do so by first loading the file into the hash-table, and then transforming it into trie.

Removing the node

This tutorial did not cover the remove-node function. We could have used it to remove the "The" node:

(cl-trie:remove-node (cl-trie:find-node trie "The"))

which is basically what cl-trie:remove-index does. However, this also deletes the value. We might want to just "remove" the word from the trie, but keep the value for the future. We use :preserve-value for that:

(cl-trie:remove-node (cl-trie:find-node trie "The") :preserve-value t)

Tests

To test the library, load it and use asdf:

(ql:quickload :cl-trie)
(asdf:test-system 'cl-trie)

Contact

Feel free to contact me by my e-mail (which can be found in cl-trie.asd), or by creating an issue.

Author

This package has been created by Mateusz Malisz.


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 cl-trie

Author

Mateusz Malisz <maliszmat@gmail.com>

License

MIT

Description

Common Lisp implementation of Trie data structure.

Source

cl-trie.asd (file)

Components

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

3 Files

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


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

3.1 Lisp


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

3.1.1 cl-trie.asd

Location

/home/quickbuilder/quicklisp/dists/quicklisp/software/cl-trie-20170630-git/cl-trie.asd

Systems

cl-trie (system)


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

3.1.2 cl-trie/package.lisp

Parent

cl-trie (system)

Location

package.lisp

Packages

cl-trie


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

3.1.3 cl-trie/generics.lisp

Dependency

package.lisp (file)

Parent

cl-trie (system)

Location

generics.lisp

Exported Definitions
Internal Definitions

attach (generic function)


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

3.1.4 cl-trie/basic-trie.lisp

Dependency

generics.lisp (file)

Parent

cl-trie (system)

Location

basic-trie.lisp

Exported Definitions
Internal Definitions

basic-trie (class)


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

3.1.5 cl-trie/trie.lisp

Dependency

basic-trie.lisp (file)

Parent

cl-trie (system)

Location

trie.lisp

Exported Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 cl-trie

Source

package.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Functions

Function: hash-table->trie HASH-MAP

Convert hash-table to a trie.

Package

cl-trie

Source

trie.lisp (file)


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

5.1.2 Generic functions

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

cl-trie

Methods
Method: activep (TRIE trie)
Method: (setf activep) NEW-VALUE (TRIE trie)

A flag that tells whether a node is active and value is of interest, or is inactive and value can be ignored.

Source

trie.lisp (file)

Generic Function: all-keys TRIE

Return list of all keys of TRIE.

Package

cl-trie

Source

generics.lisp (file)

Methods
Method: all-keys (TRIE trie)
Source

trie.lisp (file)

Generic Function: all-values TRIE

Return list of all values of TRIE.

Package

cl-trie

Source

generics.lisp (file)

Methods
Method: all-values (TRIE trie)
Source

trie.lisp (file)

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

cl-trie

Methods
Method: children (BASIC-TRIE basic-trie)
Method: (setf children) NEW-VALUE (BASIC-TRIE basic-trie)

Children nodes of the trie.

Source

basic-trie.lisp (file)

Generic Function: clear TRIE

Clear TRIE of its contents, leaving it empty.

Package

cl-trie

Source

generics.lisp (file)

Methods
Method: clear (TRIE trie)
Source

trie.lisp (file)

Generic Function: emptyp TRIE

Return T if TRIE is empty, otherwise NIL.

Package

cl-trie

Source

generics.lisp (file)

Methods
Method: emptyp (TRIE trie)
Source

trie.lisp (file)

Generic Function: find-node TRIE INDEX &key CREATE-NEW

Find node under INDEX in TRIE, or return NIL if no node has been found. If CREATE-NEW is T, all the nodes, including the searched one, will be created if they do not exist, effectively creating the node at index.

Package

cl-trie

Source

generics.lisp (file)

Methods
Method: find-node (TRIE trie) (INDEX string) &key CREATE-NEW
Source

trie.lisp (file)

Generic Function: insert ELEM TRIE INDEX

Insert ELEM as value of item at INDEX in TRIE to NEW-VALUE. Alias to (setf lookup).

Package

cl-trie

Source

generics.lisp (file)

Methods
Method: insert ELEM (TRIE trie) (INDEX string)
Source

trie.lisp (file)

Generic Function: key OBJECT
Package

cl-trie

Methods
Method: key (BASIC-TRIE basic-trie)

A part of the sequence, that indicates that this node represents a sequence of all keys from the root up to this node, including this node.

Source

basic-trie.lisp (file)

Generic Function: leafp TRIE

Return T if trie is a leaf(has no children), NIL otherwise.

Package

cl-trie

Source

generics.lisp (file)

Methods
Method: leafp (TRIE trie)
Source

trie.lisp (file)

Generic Function: lookup TRIE INDEX &optional DEFAULT

Check if there is something at INDEX in TRIE.
Return two values, the first one being value at TRIE, and second one being
T if anything was found at index and NIL if not.
If DEFAULT is provided, in case nothing is found, DEFAULT will be returned as the first value.

Package

cl-trie

Source

generics.lisp (file)

Writer

(setf lookup) (generic function)

Methods
Method: lookup (TRIE trie) (INDEX string) &optional DEFAULT
Source

trie.lisp (file)

Generic Function: (setf lookup) NEW-VALUE TRIE INDEX

Set value of item at INDEX in TRIE to NEW-VALUE. Return the node that will hold the value.

Package

cl-trie

Source

generics.lisp (file)

Reader

lookup (generic function)

Methods
Method: (setf lookup) NEW-VALUE (TRIE trie) (INDEX string)
Source

trie.lisp (file)

Generic Function: mapkeys FN TRIE

Apply function FN to each key in TRIE. Returns TRIE.

Package

cl-trie

Source

generics.lisp (file)

Methods
Method: mapkeys (FN function) (TRIE trie)
Source

trie.lisp (file)

Generic Function: mapvalues FN TRIE

Apply function FN to each value in TRIE. Returns TRIE.

Package

cl-trie

Source

generics.lisp (file)

Methods
Method: mapvalues (FN function) (TRIE trie)
Source

trie.lisp (file)

Generic Function: remove-index TRIE INDEX

Remove INDEX entry from TRIE. Return TRIE.

Package

cl-trie

Source

generics.lisp (file)

Methods
Method: remove-index (TRIE trie) (INDEX string)
Source

trie.lisp (file)

Generic Function: remove-node NODE &key PRESERVE-VALUE

Deactivate NODE, removing the value unless preserve-value is non-nil. Return NODE.

Package

cl-trie

Source

generics.lisp (file)

Methods
Method: remove-node (NODE trie) &key PRESERVE-VALUE
Source

trie.lisp (file)

Generic Function: size TRIE

Return size of TRIE, where size is number of elements found in the trie.

Package

cl-trie

Source

generics.lisp (file)

Methods
Method: size TRIE
Source

trie.lisp (file)

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

cl-trie

Methods
Method: value (BASIC-TRIE basic-trie)

automatically generated reader method

Source

basic-trie.lisp (file)

Method: (setf value) NEW-VALUE (BASIC-TRIE basic-trie)

automatically generated writer method

Source

basic-trie.lisp (file)

Method: (setf value) VALUE (TRIE trie) after
Source

trie.lisp (file)


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

5.1.3 Conditions

Condition: empty-key-warning ()

A warning emmited when key for trie is not provided.

Package

cl-trie

Source

generics.lisp (file)

Direct superclasses

warning (condition)

Condition: wrong-key-type-error ()

An error emmited when key is of a wrong type.

Package

cl-trie

Source

generics.lisp (file)

Direct superclasses

error (condition)


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

5.1.4 Classes

Class: trie ()

A lexicographically sorted trie.

Package

cl-trie

Source

trie.lisp (file)

Direct superclasses

basic-trie (class)

Direct methods
Direct slots
Slot: %activep

A flag that tells whether a node is active and value is of interest, or is inactive and value can be ignored.

Type

boolean

Initargs

:activep

Readers

activep (generic function)

Writers

(setf activep) (generic function)

Direct Default Initargs
InitargValue
:childrennil
:verboset

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

5.2 Internal definitions


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

5.2.1 Generic functions

Generic Function: attach PARENT-TRIE CHILDREN-TRIE &key ON-CONFLICT

Attach CHILDREN-TRIE to PARENT-TRIE.
If conflict happens(attached trie has the same key as already existing branch), the on-conflict describes the chosen strategy.
Possible options:
NIL - do nothing
:merge - try to merge tries
:error - raise an error

Package

cl-trie

Source

generics.lisp (file)


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

5.2.2 Classes

Class: basic-trie ()
Package

cl-trie

Source

basic-trie.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

trie (class)

Direct methods
  • value (method)
  • value (method)
  • key (method)
  • children (method)
  • children (method)
Direct slots
Slot: %children

Children nodes of the trie.

Type

list

Initargs

:children

Readers

children (generic function)

Writers

(setf children) (generic function)

Slot: %key

A part of the sequence, that indicates that this node represents a sequence of all keys from the root up to this node, including this node.

Initargs

:key

Initform

(warn (quote cl-trie:empty-key-warning))

Readers

key (generic function)

Slot: %value
Initargs

:value

Readers

value (generic function)

Writers

(setf value) (generic function)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   C   F   L  
Index Entry  Section

C
cl-trie.asd: The cl-trie<dot>asd file
cl-trie/basic-trie.lisp: The cl-trie/basic-trie<dot>lisp file
cl-trie/generics.lisp: The cl-trie/generics<dot>lisp file
cl-trie/package.lisp: The cl-trie/package<dot>lisp file
cl-trie/trie.lisp: The cl-trie/trie<dot>lisp file

F
File, Lisp, cl-trie.asd: The cl-trie<dot>asd file
File, Lisp, cl-trie/basic-trie.lisp: The cl-trie/basic-trie<dot>lisp file
File, Lisp, cl-trie/generics.lisp: The cl-trie/generics<dot>lisp file
File, Lisp, cl-trie/package.lisp: The cl-trie/package<dot>lisp file
File, Lisp, cl-trie/trie.lisp: The cl-trie/trie<dot>lisp file

L
Lisp File, cl-trie.asd: The cl-trie<dot>asd file
Lisp File, cl-trie/basic-trie.lisp: The cl-trie/basic-trie<dot>lisp file
Lisp File, cl-trie/generics.lisp: The cl-trie/generics<dot>lisp file
Lisp File, cl-trie/package.lisp: The cl-trie/package<dot>lisp file
Lisp File, cl-trie/trie.lisp: The cl-trie/trie<dot>lisp file

Jump to:   C   F   L  

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

A.2 Functions

Jump to:   (  
A   C   E   F   G   H   I   K   L   M   R   S   V  
Index Entry  Section

(
(setf activep): Exported generic functions
(setf activep): Exported generic functions
(setf children): Exported generic functions
(setf children): Exported generic functions
(setf lookup): Exported generic functions
(setf lookup): Exported generic functions
(setf value): Exported generic functions
(setf value): Exported generic functions
(setf value): Exported generic functions

A
activep: Exported generic functions
activep: Exported generic functions
all-keys: Exported generic functions
all-keys: Exported generic functions
all-values: Exported generic functions
all-values: Exported generic functions
attach: Internal generic functions

C
children: Exported generic functions
children: Exported generic functions
clear: Exported generic functions
clear: Exported generic functions

E
emptyp: Exported generic functions
emptyp: Exported generic functions

F
find-node: Exported generic functions
find-node: Exported generic functions
Function, hash-table->trie: Exported functions

G
Generic Function, (setf activep): Exported generic functions
Generic Function, (setf children): Exported generic functions
Generic Function, (setf lookup): Exported generic functions
Generic Function, (setf value): Exported generic functions
Generic Function, activep: Exported generic functions
Generic Function, all-keys: Exported generic functions
Generic Function, all-values: Exported generic functions
Generic Function, attach: Internal generic functions
Generic Function, children: Exported generic functions
Generic Function, clear: Exported generic functions
Generic Function, emptyp: Exported generic functions
Generic Function, find-node: Exported generic functions
Generic Function, insert: Exported generic functions
Generic Function, key: Exported generic functions
Generic Function, leafp: Exported generic functions
Generic Function, lookup: Exported generic functions
Generic Function, mapkeys: Exported generic functions
Generic Function, mapvalues: Exported generic functions
Generic Function, remove-index: Exported generic functions
Generic Function, remove-node: Exported generic functions
Generic Function, size: Exported generic functions
Generic Function, value: Exported generic functions

H
hash-table->trie: Exported functions

I
insert: Exported generic functions
insert: Exported generic functions

K
key: Exported generic functions
key: Exported generic functions

L
leafp: Exported generic functions
leafp: Exported generic functions
lookup: Exported generic functions
lookup: Exported generic functions

M
mapkeys: Exported generic functions
mapkeys: Exported generic functions
mapvalues: Exported generic functions
mapvalues: Exported generic functions
Method, (setf activep): Exported generic functions
Method, (setf children): Exported generic functions
Method, (setf lookup): Exported generic functions
Method, (setf value): Exported generic functions
Method, (setf value): Exported generic functions
Method, activep: Exported generic functions
Method, all-keys: Exported generic functions
Method, all-values: Exported generic functions
Method, children: Exported generic functions
Method, clear: Exported generic functions
Method, emptyp: Exported generic functions
Method, find-node: Exported generic functions
Method, insert: Exported generic functions
Method, key: Exported generic functions
Method, leafp: Exported generic functions
Method, lookup: Exported generic functions
Method, mapkeys: Exported generic functions
Method, mapvalues: Exported generic functions
Method, remove-index: Exported generic functions
Method, remove-node: Exported generic functions
Method, size: Exported generic functions
Method, value: Exported generic functions

R
remove-index: Exported generic functions
remove-index: Exported generic functions
remove-node: Exported generic functions
remove-node: Exported generic functions

S
size: Exported generic functions
size: Exported generic functions

V
value: Exported generic functions
value: Exported generic functions

Jump to:   (  
A   C   E   F   G   H   I   K   L   M   R   S   V  

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

A.3 Variables

Jump to:   %  
S  
Index Entry  Section

%
%activep: Exported classes
%children: Internal classes
%key: Internal classes
%value: Internal classes

S
Slot, %activep: Exported classes
Slot, %children: Internal classes
Slot, %key: Internal classes
Slot, %value: Internal classes

Jump to:   %  
S  

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

A.4 Data types

Jump to:   B   C   E   P   S   T   W  
Index Entry  Section

B
basic-trie: Internal classes

C
cl-trie: The cl-trie system
cl-trie: The cl-trie package
Class, basic-trie: Internal classes
Class, trie: Exported classes
Condition, empty-key-warning: Exported conditions
Condition, wrong-key-type-error: Exported conditions

E
empty-key-warning: Exported conditions

P
Package, cl-trie: The cl-trie package

S
System, cl-trie: The cl-trie system

T
trie: Exported classes

W
wrong-key-type-error: Exported conditions

Jump to:   B   C   E   P   S   T   W