The validate-list Reference Manual

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

The validate-list Reference Manual

This is the validate-list Reference Manual, version 1.0.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 06:07:29 2022 GMT+0.

Table of Contents


1 Introduction

validate-list

update notes

Now with a compiler macro that will convert templates that are immutalbe straight into their compiled form using (compile-template ..), by constant it would mean something like (validate-list <my list> '((im a template))) For a list to satisfy (constantp <list>) it should be quoted like '(<list>) so the code has been updated to support validation and compilation of templates that are constructed with quotes like `'().

I have integrated the tests with asdf so (asdf:test-system :validate-list) should run seemlessly.

Compiled functions are now given a declaration of (speed 3) and (safety 1), making them even faster than before.

Download

grab from quicklisp

(ql:quickload :validate-list)
(asdf:test-system :validate-list)
;inform me if any fail
(in-package :validate-list)

This is an attempt at using templates to validate the contents of a list. The idea came because when you parse json from an untrusted source you don't know for certain what has been sent, so the idea is that once parsed you can use a template to check if the parsed data (now a list) conforms to what you want. The primary function is validate-list Which takes in two arguments, the list you wish to validate and a template. Here is the docstring:

"Takes in a LIST that you want to validate, and a TEMPLATE, the TEMPLATE is a list of lists, each list contains keywords and their values (a full list of keys can be found by calling CURRENT-KEYS), if TEMPLATE is 'invalid' then the condition BAD-TEMPLATE-FORM is signalled. Each list within the template represents 1 element in the LIST and is a 'description' of its contents. For example given the template '((:equal "key") (:type string :maxlen 40)) this could be used to validate the list '("key" "abcdeegadfgfsdf") because as the template says, the first item in list is "key" and the second according to the template should be of type 'string and no longer than 40 characters long, which it is not, so this is valid and will return t, if a list fails when checked against the template then this func signals the condition FAILED-TO-VALIDATE, which will contain information about where validation failed. For a list of examples see src/tests.lisp,the invalid templates are marked. In the interests of speed no checks are done to validate the structure of your template before validation happens, you can use 'is-valid-template' as a precursory check to make sure that the template is constructed with valid plists and valid keywords. There is also the possibility that when you try to validate a list where you expect a certain structure and get something else you will get a BAD-TEMPLATE-FORM condition where the template is fine but the list is not, just treat this like the validation failed."

Example templates to validate example lists

;;;trivial example:
(defparameter *test-list1* '("key" "abcdeegadfgfsdf"))
(defparameter *test-template1* '((:equal "key") (:type string :maxlen 40)))

;;;complicated example: 
(defparameter *test-list16*  '("year" 98 ("keyvals" ("USA" 35 "Poland" 55 "UK" 96)
                                          1 2 (2) (6 7) ("oof" "oof" "oof") "abc")))
(defparameter *test-template16* `((:equal "year")(:type integer :or (96 97 98))
                                  ((:or ("keyvals" "time")) 
                                   ,(repeat-pattern 3 '((:type string :maxlen 6 :minlen 2)
                                                        (:type number :between (0 100))))
                                   ,@(repeat-test 2 '(:type number :satisfies (evenp oddp)))
                                   (:type list :length 1)
                                   (:type list :contents (:type number :satisfies (evenp oddp)))
                                   (:type list :minlen 1 :maxlen 5
                                    :contents (:type string :maxlen 5 :equal "oof"))
                                   (:type string :equal "abc"))))
->
((:EQUAL "year") (:TYPE INTEGER :OR (96 97 98))
 ((:OR ("keyvals" "time"))
  ((:TYPE STRING :MAXLEN 6 :MINLEN 2) (:TYPE NUMBER :BETWEEN (0 100))
   (:TYPE STRING :MAXLEN 6 :MINLEN 2) (:TYPE NUMBER :BETWEEN (0 100))
   (:TYPE STRING :MAXLEN 6 :MINLEN 2) (:TYPE NUMBER :BETWEEN (0 100)))
  (:TYPE NUMBER :SATISFIES (EVENP ODDP)) (:TYPE NUMBER :SATISFIES (EVENP ODDP))
  (:TYPE LIST :LENGTH 1)
  (:TYPE LIST :CONTENTS (:TYPE NUMBER :SATISFIES (EVENP ODDP)))
  (:TYPE LIST :MINLEN 1 :MAXLEN 5 :CONTENTS
   (:TYPE STRING :MAXLEN 5 :EQUAL "oof"))
  (:TYPE STRING :EQUAL "abc")))

The helper functions

There are two helper functions repeat-pattern and repeat-test. The purpose of these functions is to help validate a known length and a known pattern, for example if you know that the list is going to be 10 elements long you don't want to write out (:type string) 10 times so you can instead just use one of these functions to do it for you.

VALIDATE-LIST>  (repeat-pattern 3 '((:type string :maxlen 6 :minlen 2)
                                    (:type number :between (0 100))))
((:TYPE STRING :MAXLEN 6 :MINLEN 2) (:TYPE NUMBER :BETWEEN (0 100))
 (:TYPE STRING :MAXLEN 6 :MINLEN 2) (:TYPE NUMBER :BETWEEN (0 100))
 (:TYPE STRING :MAXLEN 6 :MINLEN 2) (:TYPE NUMBER :BETWEEN (0 100)))
VALIDATE-LIST> (repeat-test 3 '(:type number :satisfies (#'evenp #'oddp)))
((:TYPE NUMBER :SATISFIES (#'EVENP #'ODDP))
 (:TYPE NUMBER :SATISFIES (#'EVENP #'ODDP))
 (:TYPE NUMBER :SATISFIES (#'EVENP #'ODDP)))

As you can see in the examples I have used ` and , to control the evaluation of the functions. This is probably the easiest way to do this. It is very important to make sure you use ,@ where necessary as it will be a big cause of BAD-TEMPLATE-FORMAT conditions.

Keyword functions

Here are the keys and what they do (each key takes exactly 1 argument):

Special keys

There is one special key which is an extension of :type and :contents which is used with :type list.

Compiling templates

If you reckon you will be making heavy use of a template you can compile it using compile-template This function takes a template as an argument and returns a compiled function, this compiled function can be used to validate a list simply by calling the function with the list you wish to validate as the only argument. Here is an example:

VALIDATE-LIST> (compile-template *test-template8*)
#<FUNCTION (LAMBDA (LIST)) {10054100CB}>
NIL
NIL
VALIDATE-LIST> (funcall * *test-list8*)
T
VALIDATE-LIST> 

Compiling the templates offers quite the speed advantage. Here are some tests:


V-L-TESTS> (time (dotimes (i 1000000)
                   (validate-list *test-list8* *test-template8*)))
Evaluation took:
  4.643 seconds of real time
  4.658734 seconds of total run time (4.613572 user, 0.045162 system)
  [ Run times consist of 0.221 seconds GC time, and 4.438 seconds non-GC time. ]
  100.34% CPU
  12,035,600,724 processor cycles
  2,415,984,640 bytes consed
  
NIL
V-L-TESTS> (let ((fun (compile-template *test-template8*)))
             (time (dotimes (i 1000000)
                     (funcall fun *test-list8*))))
Evaluation took:
  2.020 seconds of real time
  2.021337 seconds of total run time (2.020652 user, 0.000685 system)
  [ Run times consist of 0.025 seconds GC time, and 1.997 seconds non-GC time. ]
  100.05% CPU
  5,237,150,378 processor cycles
  191,993,040 bytes consed
  
NIL
VALIDATE-LIST> 

Defining your own symbols

If you find you need more functionality you can define your own symbols with the function define-key here is the doctsring:

Takes in a keyword and associates the keyword with the function. The function must accept two arguments, the first an entry ie a value in a list wanting to be validated and the second an object see any of the other uses of DEFINE-KEY in src/validate-list.lisp to get an idea what your λ should > look like. Here is an example


(define-key :n= 
   (lambda (entry arg) 
              (check-type entry number)
              (check-type arg number)
              (= arg entry)))
                  

Now with the new keyword :n= defined this can be used in a template like so where list is '(100) and the template is '((:n= 100)).

Here are a couple of examples taken from Moonbot, my bot for Matrix.

(validate-list:define-key :valid-user
  'validate-user)

(defun validate-user (entry x)
  "Given a list and an integer (X), takes the X position from the list and 
checks if it is a valid user"
  (declare (special community connection))
  (let ((user (elt entry x)))
    (if (find user (members community) :test #'string=)
        t 
        (valid-user-p connection (elt entry x)))))

(validate-list:define-key :valid-room
  'validate-room)

(defun validate-room (entry x)
  (declare (special community))
  (find (elt entry x) (rooms community) :test #'string=))

(validate-list:define-key :valid-community
  'validate-community)

(defun validate-community (entry x)
  (declare (special moonbot))
  (find (intern (string-upcase (elt entry x)) :keyword)
        (communities moonbot) :key #'name))

Other

The condition unknown-keyword is signalled when you put an unknown keyword in your template. It has two accessors

The condition bad-template-format is signalled when a template is poorly formed. It has three accessors

License

MIT


2 Systems

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


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

2.1 validate-list

Allows you to validate the contents and structure of a list based off of a template

Author

K1D77A

License

MIT

Version

1.0.1

Dependencies
  • arithmetic-operators-as-words (system).
  • lisp-unit (system).
  • alexandria (system).
Source

validate-list.asd.

Child Component

src (module).


3 Modules

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


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

3.1 validate-list/src

Source

validate-list.asd.

Parent Component

validate-list (system).

Child Components

4 Files

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


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

4.1 Lisp


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

4.1.1 validate-list/validate-list.asd

Source

validate-list.asd.

Parent Component

validate-list (system).

ASDF Systems

validate-list.


4.1.2 validate-list/src/package.lisp

Source

validate-list.asd.

Parent Component

src (module).

Packages

validate-list.


4.1.3 validate-list/src/conditions.lisp

Dependency

package.lisp (file).

Source

validate-list.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.4 validate-list/src/validate-list.lisp

Dependency

conditions.lisp (file).

Source

validate-list.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.5 validate-list/src/compile-template.lisp

Dependency

validate-list.lisp (file).

Source

validate-list.asd.

Parent Component

src (module).

Public Interface

compile-template (function).

Internals

5 Packages

Packages are listed by definition order.


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

5.1 validate-list

Source

package.lisp.

Use List

common-lisp.

Public Interface
Internals

6 Definitions

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


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

6.1 Public Interface


6.1.1 Compiler macros

Compiler Macro: validate-list (list template)
Package

validate-list.

Source

validate-list.lisp.


6.1.2 Ordinary functions

Function: compile-template (template &optional see-code)

Takes in a valid TEMPLATE and returns a compiled 1 argument function. This function is called
with a list, ie the one you wish to validate. This function will signal a BAD-TEMPLATE-FORMAT condition if the template is bad.

Package

validate-list.

Source

compile-template.lisp.

Function: current-keys ()
Package

validate-list.

Source

validate-list.lisp.

Function: define-key (key func)

Takes in a keyword and associates the keyword with the function. The function must accept two
arguments, the first an entry ie a value in a list wanting to be validated and the second an object
see any of the other uses of DEFINE-KEY in src/validate-list.lisp to get an idea what your lambda should look like. Here is an example (define-key :n=
(lambda (entry arg)
(check-type entry number)
(check-type arg number)
(= entry arg)))
Now with the new keyword :n= defined this can be used in a template like so where list is ’(100)
and the template is ’((:n= 100)).

Package

validate-list.

Source

validate-list.lisp.

Function: is-valid-template (template)

Takes in a TEMPLATE and attempts to make sure it has a valid structure. If it does not then signals condition BAD-TEMPLATE-FORMAT

Package

validate-list.

Source

validate-list.lisp.

Function: repeat-pattern (length pattern-list)

Given a length and a list this will return a list of LENGTH with PATTERN-LIST repeated LENGTH times

Package

validate-list.

Source

validate-list.lisp.

Function: repeat-test (length validation-list)

Returns a list of length LENGTH which simply repeats VALIDATION-LIST

Package

validate-list.

Source

validate-list.lisp.

Function: same-structures-p (list template &optional print-lists)

Given LIST and TEMPLATE of arbitrary depth, return t if they have the same structure or nil if not. In the event of any error this function returns nil, as the assumption is that the structures are not the same.

Package

validate-list.

Source

validate-list.lisp.

Function: validate-list (list template)

Takes in a LIST that you want to validate, and a TEMPLATE, the TEMPLATE is a list of lists,
each list contains keywords and their values (a full list of keys can be found by calling CURRENT-KEYS), if TEMPLATE is ’invalid’ then the condition BAD-TEMPLATE-FORM is signalled. Each list within the template represents 1 element in the LIST and is a ’description’ of its contents.
For example given the template ’((:equal "key") (:type string :maxlen 40)) this could be used
to validate the list ’("key" "abcdeegadfgfsdf") because as the template says, the first item in
list is "key" and the second according to the template should be of type ’string and no longer
than 40 characters long, which it is not, so this is valid and will return t, if a list fails when
checked against the template then this func signals the condition FAILED-TO-VALIDATE, which
will contain information about where validation failed. For a list of examples see src/tests.lisp, the invalid templates are marked.
In the interests of speed no checks are done to validate the structure of your template
before validation happens,
you can use ’is-valid-template’ as a precursory check to make sure that the template is
constructed with valid plists and valid keywords. There is also the possibility that when you try
to validate a list where you expect a certain structure and get something else you will get a
BAD-TEMPLATE-FORM condition where the template is fine but the list is not, just treat this like
the validation failed.

Package

validate-list.

Source

validate-list.lisp.


6.1.3 Generic functions

Generic Reader: bad-template-format-message (condition)
Generic Writer: (setf bad-template-format-message) (condition)
Package

validate-list.

Methods
Reader Method: bad-template-format-message ((condition bad-template-format))
Writer Method: (setf bad-template-format-message) ((condition bad-template-format))
Source

conditions.lisp.

Target Slot

message.

Generic Reader: bad-template-format-signaller (condition)
Generic Writer: (setf bad-template-format-signaller) (condition)
Package

validate-list.

Methods
Reader Method: bad-template-format-signaller ((condition bad-template-format))
Writer Method: (setf bad-template-format-signaller) ((condition bad-template-format))
Source

conditions.lisp.

Target Slot

signaller.

Generic Reader: bad-template-format-template (condition)
Generic Writer: (setf bad-template-format-template) (condition)
Package

validate-list.

Methods
Reader Method: bad-template-format-template ((condition bad-template-format))
Writer Method: (setf bad-template-format-template) ((condition bad-template-format))
Source

conditions.lisp.

Target Slot

template.

Generic Reader: failed-to-validate-arg (condition)
Generic Writer: (setf failed-to-validate-arg) (condition)
Package

validate-list.

Methods
Reader Method: failed-to-validate-arg ((condition failed-to-validate))
Writer Method: (setf failed-to-validate-arg) ((condition failed-to-validate))
Source

conditions.lisp.

Target Slot

failed-to-validate-arg.

Generic Reader: failed-to-validate-entry (condition)
Generic Writer: (setf failed-to-validate-entry) (condition)
Package

validate-list.

Methods
Reader Method: failed-to-validate-entry ((condition failed-to-validate))
Writer Method: (setf failed-to-validate-entry) ((condition failed-to-validate))
Source

conditions.lisp.

Target Slot

failed-to-validate-entry.

Generic Reader: failed-to-validate-key (condition)
Generic Writer: (setf failed-to-validate-key) (condition)
Package

validate-list.

Methods
Reader Method: failed-to-validate-key ((condition failed-to-validate))
Writer Method: (setf failed-to-validate-key) ((condition failed-to-validate))
Source

conditions.lisp.

Target Slot

failed-to-validate-key.

Generic Reader: failed-to-validate-message (condition)
Generic Writer: (setf failed-to-validate-message) (condition)
Package

validate-list.

Methods
Reader Method: failed-to-validate-message ((condition failed-to-validate))
Writer Method: (setf failed-to-validate-message) ((condition failed-to-validate))
Source

conditions.lisp.

Target Slot

failed-to-validate-message.

Generic Reader: unknown-keyword-keyword (condition)
Generic Writer: (setf unknown-keyword-keyword) (condition)
Package

validate-list.

Methods
Reader Method: unknown-keyword-keyword ((condition unknown-keyword))
Writer Method: (setf unknown-keyword-keyword) ((condition unknown-keyword))
Source

conditions.lisp.

Target Slot

keyword.

Generic Reader: unknown-keyword-message (condition)
Generic Writer: (setf unknown-keyword-message) (condition)
Package

validate-list.

Methods
Reader Method: unknown-keyword-message ((condition unknown-keyword))
Writer Method: (setf unknown-keyword-message) ((condition unknown-keyword))
Source

conditions.lisp.

Target Slot

message.


6.1.4 Standalone methods

Method: print-object ((object failed-to-validate) stream)
Source

conditions.lisp.

Method: print-object ((object unknown-keyword) stream)
Source

conditions.lisp.

Method: print-object ((object bad-template-format) stream)
Source

conditions.lisp.


6.1.5 Conditions

Condition: bad-template-format
Package

validate-list.

Source

conditions.lisp.

Direct superclasses

error.

Direct methods
Direct slots
Slot: template
Initargs

:bad-template-format-template

Readers

bad-template-format-template.

Writers

(setf bad-template-format-template).

Slot: signaller

Contains the condition which was called that caused this condition to be signalled

Initargs

:bad-template-format-signaller

Readers

bad-template-format-signaller.

Writers

(setf bad-template-format-signaller).

Slot: message

Message indicating what when wrong

Initargs

:bad-template-format-message

Readers

bad-template-format-message.

Writers

(setf bad-template-format-message).

Condition: failed-to-validate
Package

validate-list.

Source

conditions.lisp.

Direct superclasses

error.

Direct methods
Direct slots
Slot: failed-to-validate-key
Initargs

:failed-to-validate-key

Readers

failed-to-validate-key.

Writers

(setf failed-to-validate-key).

Slot: failed-to-validate-arg
Initargs

:failed-to-validate-arg

Readers

failed-to-validate-arg.

Writers

(setf failed-to-validate-arg).

Slot: failed-to-validate-entry
Initargs

:failed-to-validate-entry

Readers

failed-to-validate-entry.

Writers

(setf failed-to-validate-entry).

Slot: failed-to-validate-message

Message indicating what when wrong

Initargs

:failed-to-validate-message

Readers

failed-to-validate-message.

Writers

(setf failed-to-validate-message).

Condition: unknown-keyword
Package

validate-list.

Source

conditions.lisp.

Direct superclasses

error.

Direct methods
Direct slots
Slot: keyword
Package

common-lisp.

Initargs

:unknown-keyword-keyword

Readers

unknown-keyword-keyword.

Writers

(setf unknown-keyword-keyword).

Slot: message

Message indicating what when wrong

Initargs

:unknown-keyword-message

Readers

unknown-keyword-message.

Writers

(setf unknown-keyword-message).


6.2 Internals


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

6.2.1 Special variables

Special Variable: *compiled-hash*
Package

validate-list.

Source

validate-list.lisp.

Special Variable: *functions*
Package

validate-list.

Source

validate-list.lisp.

Special Variable: *validate-list-p-err-message*
Package

validate-list.

Source

validate-list.lisp.


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

6.2.2 Ordinary functions

Function: argument (template-fun)
Package

validate-list.

Source

compile-template.lisp.

Function: call-fun-check-true (fun arg1 arg2)
Package

validate-list.

Source

compile-template.lisp.

Function: compile-template-entry (template-entry)
Package

validate-list.

Source

compile-template.lisp.

Function: fun (template-fun)
Package

validate-list.

Source

compile-template.lisp.

Function: handle-between (entry between-list)
Package

validate-list.

Source

validate-list.lisp.

Function: handle-contents (entry template-entry)
Package

validate-list.

Source

validate-list.lisp.

Function: handle-equal (entry equal)
Package

validate-list.

Source

validate-list.lisp.

Function: handle-greater-than (entry greater-than)
Package

validate-list.

Source

validate-list.lisp.

Function: handle-length (entry length)
Package

validate-list.

Source

validate-list.lisp.

Function: handle-less-than (entry less-than)
Package

validate-list.

Source

validate-list.lisp.

Function: handle-maxlen (entry maxlen)
Package

validate-list.

Source

validate-list.lisp.

Function: handle-minlen (entry minlen)
Package

validate-list.

Source

validate-list.lisp.

Function: handle-or (entry list-of-potentials)
Package

validate-list.

Source

validate-list.lisp.

Function: handle-satisfies (entry func)
Package

validate-list.

Source

validate-list.lisp.

Function: handle-type (entry type)
Package

validate-list.

Source

validate-list.lisp.

Function: keyword->function (keyword)

Given a keyword in KEYWORD, this function looks for the associated function in *functions* if found then the function is returned, otherwise a UNKNOWN-KEYWORD condition is signalled.

Package

validate-list.

Source

validate-list.lisp.

Function: map-plist (func plist)

Maps a PLIST and calls FUNC that accepts two arguments. returns a list of funcall-result

Package

validate-list.

Source

validate-list.lisp.

Function: process-template-entry (template-entry entry)
Package

validate-list.

Source

validate-list.lisp.

Function: process-template-funs (template)

Takes in a TEMPLATE and converts all the key args within each plist into the associated functions ready to be called

Package

validate-list.

Source

compile-template.lisp.

Function: quoted-p (form)
Package

validate-list.

Source

validate-list.lisp.

Function: signal-bad-template-format (template message &optional signaller)
Package

validate-list.

Source

conditions.lisp.

Function: signal-failed-to-validate (keyword arg entry message)
Package

validate-list.

Source

conditions.lisp.

Function: signal-unknown-keyword (keyword message)
Package

validate-list.

Source

conditions.lisp.


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   (  
A   B   C   D   F   G   H   I   K   M   P   Q   R   S   U   V  
Index Entry  Section

(
(setf bad-template-format-message): Public generic functions
(setf bad-template-format-message): Public generic functions
(setf bad-template-format-signaller): Public generic functions
(setf bad-template-format-signaller): Public generic functions
(setf bad-template-format-template): Public generic functions
(setf bad-template-format-template): Public generic functions
(setf failed-to-validate-arg): Public generic functions
(setf failed-to-validate-arg): Public generic functions
(setf failed-to-validate-entry): Public generic functions
(setf failed-to-validate-entry): Public generic functions
(setf failed-to-validate-key): Public generic functions
(setf failed-to-validate-key): Public generic functions
(setf failed-to-validate-message): Public generic functions
(setf failed-to-validate-message): Public generic functions
(setf unknown-keyword-keyword): Public generic functions
(setf unknown-keyword-keyword): Public generic functions
(setf unknown-keyword-message): Public generic functions
(setf unknown-keyword-message): Public generic functions

A
argument: Private ordinary functions

B
bad-template-format-message: Public generic functions
bad-template-format-message: Public generic functions
bad-template-format-signaller: Public generic functions
bad-template-format-signaller: Public generic functions
bad-template-format-template: Public generic functions
bad-template-format-template: Public generic functions

C
call-fun-check-true: Private ordinary functions
compile-template: Public ordinary functions
compile-template-entry: Private ordinary functions
Compiler Macro, validate-list: Public compiler macros
current-keys: Public ordinary functions

D
define-key: Public ordinary functions

F
failed-to-validate-arg: Public generic functions
failed-to-validate-arg: Public generic functions
failed-to-validate-entry: Public generic functions
failed-to-validate-entry: Public generic functions
failed-to-validate-key: Public generic functions
failed-to-validate-key: Public generic functions
failed-to-validate-message: Public generic functions
failed-to-validate-message: Public generic functions
fun: Private ordinary functions
Function, argument: Private ordinary functions
Function, call-fun-check-true: Private ordinary functions
Function, compile-template: Public ordinary functions
Function, compile-template-entry: Private ordinary functions
Function, current-keys: Public ordinary functions
Function, define-key: Public ordinary functions
Function, fun: Private ordinary functions
Function, handle-between: Private ordinary functions
Function, handle-contents: Private ordinary functions
Function, handle-equal: Private ordinary functions
Function, handle-greater-than: Private ordinary functions
Function, handle-length: Private ordinary functions
Function, handle-less-than: Private ordinary functions
Function, handle-maxlen: Private ordinary functions
Function, handle-minlen: Private ordinary functions
Function, handle-or: Private ordinary functions
Function, handle-satisfies: Private ordinary functions
Function, handle-type: Private ordinary functions
Function, is-valid-template: Public ordinary functions
Function, keyword->function: Private ordinary functions
Function, map-plist: Private ordinary functions
Function, process-template-entry: Private ordinary functions
Function, process-template-funs: Private ordinary functions
Function, quoted-p: Private ordinary functions
Function, repeat-pattern: Public ordinary functions
Function, repeat-test: Public ordinary functions
Function, same-structures-p: Public ordinary functions
Function, signal-bad-template-format: Private ordinary functions
Function, signal-failed-to-validate: Private ordinary functions
Function, signal-unknown-keyword: Private ordinary functions
Function, validate-list: Public ordinary functions

G
Generic Function, (setf bad-template-format-message): Public generic functions
Generic Function, (setf bad-template-format-signaller): Public generic functions
Generic Function, (setf bad-template-format-template): Public generic functions
Generic Function, (setf failed-to-validate-arg): Public generic functions
Generic Function, (setf failed-to-validate-entry): Public generic functions
Generic Function, (setf failed-to-validate-key): Public generic functions
Generic Function, (setf failed-to-validate-message): Public generic functions
Generic Function, (setf unknown-keyword-keyword): Public generic functions
Generic Function, (setf unknown-keyword-message): Public generic functions
Generic Function, bad-template-format-message: Public generic functions
Generic Function, bad-template-format-signaller: Public generic functions
Generic Function, bad-template-format-template: Public generic functions
Generic Function, failed-to-validate-arg: Public generic functions
Generic Function, failed-to-validate-entry: Public generic functions
Generic Function, failed-to-validate-key: Public generic functions
Generic Function, failed-to-validate-message: Public generic functions
Generic Function, unknown-keyword-keyword: Public generic functions
Generic Function, unknown-keyword-message: Public generic functions

H
handle-between: Private ordinary functions
handle-contents: Private ordinary functions
handle-equal: Private ordinary functions
handle-greater-than: Private ordinary functions
handle-length: Private ordinary functions
handle-less-than: Private ordinary functions
handle-maxlen: Private ordinary functions
handle-minlen: Private ordinary functions
handle-or: Private ordinary functions
handle-satisfies: Private ordinary functions
handle-type: Private ordinary functions

I
is-valid-template: Public ordinary functions

K
keyword->function: Private ordinary functions

M
map-plist: Private ordinary functions
Method, (setf bad-template-format-message): Public generic functions
Method, (setf bad-template-format-signaller): Public generic functions
Method, (setf bad-template-format-template): Public generic functions
Method, (setf failed-to-validate-arg): Public generic functions
Method, (setf failed-to-validate-entry): Public generic functions
Method, (setf failed-to-validate-key): Public generic functions
Method, (setf failed-to-validate-message): Public generic functions
Method, (setf unknown-keyword-keyword): Public generic functions
Method, (setf unknown-keyword-message): Public generic functions
Method, bad-template-format-message: Public generic functions
Method, bad-template-format-signaller: Public generic functions
Method, bad-template-format-template: Public generic functions
Method, failed-to-validate-arg: Public generic functions
Method, failed-to-validate-entry: Public generic functions
Method, failed-to-validate-key: Public generic functions
Method, failed-to-validate-message: Public generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, unknown-keyword-keyword: Public generic functions
Method, unknown-keyword-message: Public generic functions

P
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
process-template-entry: Private ordinary functions
process-template-funs: Private ordinary functions

Q
quoted-p: Private ordinary functions

R
repeat-pattern: Public ordinary functions
repeat-test: Public ordinary functions

S
same-structures-p: Public ordinary functions
signal-bad-template-format: Private ordinary functions
signal-failed-to-validate: Private ordinary functions
signal-unknown-keyword: Private ordinary functions

U
unknown-keyword-keyword: Public generic functions
unknown-keyword-keyword: Public generic functions
unknown-keyword-message: Public generic functions
unknown-keyword-message: Public generic functions

V
validate-list: Public compiler macros
validate-list: Public ordinary functions

Jump to:   (  
A   B   C   D   F   G   H   I   K   M   P   Q   R   S   U   V