The rutils Reference Manual

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

The rutils Reference Manual

This is the rutils Reference Manual, version 5.2.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 05:47:46 2022 GMT+0.

Table of Contents


1 Introduction

RUTILS is a syntactic utilities package for Common Lisp

RUTILS logo

(that aims to radically simplify the Lisp programmer's life both in the REPL and in large system development)

RUTILS stands for RADICAL-UTILITIES :)

See the announcement.

Read the tutorial for usage details or the quickdocs.

Short history

Originally, RUTILS stood for REASONABLE-UTILITIES, but now I switched to calling them RADICAL-UTILITIES, because they make some uncommon and not generally acceptable choices in terms of style of CL development. Namely:

But, what's more important, they aim to radically simplify Lisp programming in the small (with a special accent on simplifying REPL-driven development).

See the original rationale for REASONABLE-UTILITIES.

The current version is 5.0.0.

Major Features

Explicitly not supported

The following broad topics are not supported by design:

Technical notes

Dependencies

Exported features

The following symbols are added to *FEATURES*:

Organizational notes

(c) 2009-2019, Vsevolod Dyomkin vseloved@gmail.com

See LICENSE for usage permissions. See AUTHORS for credits.


2 Systems

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


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

2.1 rutils

A collection of basic utilities for syntactic
extension and basic data structure handling,
developed over the years of CL history by efforts of different individuals, and gathered under the unbrella of a hierarchy of packages
which can be used on-demand.

Maintainer

Vsevolod Dyomkin <vseloved@gmail.com>

Author

Vsevolod Dyomkin <vseloved@gmail.com>

License

3-clause MIT licence

Version

5.2.1

Dependencies
  • named-readtables (system).
  • closer-mop (system).
Source

rutils.asd.

Child Component

core (module).


3 Modules

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


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

3.1 rutils/core

Source

rutils.asd.

Parent Component

rutils (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 rutils/rutils.asd

Source

rutils.asd.

Parent Component

rutils (system).

ASDF Systems

rutils.


4.1.3 rutils/core/readtable.lisp

Dependency

packages.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface
Internals

4.1.4 rutils/core/symbol.lisp

Dependency

readtable.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface

4.1.5 rutils/core/misc.lisp

Dependency

symbol.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface
Internals

4.1.6 rutils/core/anaphora.lisp

Dependency

misc.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface

4.1.7 rutils/core/list.lisp

Dependency

anaphora.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface

4.1.8 rutils/core/string.lisp

Dependency

list.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface

4.1.9 rutils/core/hash-table.lisp

Dependency

string.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface

4.1.10 rutils/core/hash-set.lisp

Dependency

hash-table.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface

4.1.11 rutils/core/tree.lisp

Dependency

hash-set.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface

4.1.12 rutils/core/array.lisp

Dependency

tree.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface

4.1.13 rutils/core/sequence.lisp

Dependency

array.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface
Internals

4.1.14 rutils/core/pair.lisp

Dependency

sequence.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface
Internals

4.1.15 rutils/core/kv.lisp

Dependency

pair.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface
  • dokv (macro).
  • eq-test (generic function).
  • keys (generic function).
  • kvs (generic function).
  • mapkv (generic function).
  • vals (generic function).

4.1.16 rutils/core/generic.lisp

Dependency

kv.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface
Internals

4.1.17 rutils/core/bind.lisp

Dependency

generic.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface
Internals

4.1.18 rutils/core/iter.lisp

Dependency

bind.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface
Internals

4.1.19 rutils/core/abbr.lisp

Dependency

iter.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Public Interface

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

4.1.20 rutils/core/rutils.lisp

Dependency

abbr.lisp (file).

Source

rutils.asd.

Parent Component

core (module).

Internals

*all-packages* (special variable).


5 Packages

Packages are listed by definition order.


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

5.1 rtl

The whole set of utilities + abbreviations in one package.

Source

packages.lisp.

Nickname

rutil

Use List
Used By List

rtl-user.


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

5.2 rutils.readtable

Literate syntax definitions.

Source

packages.lisp.

Use List
  • common-lisp.
  • editor-hints.named-readtables.
Used By List
Public Interface
Internals

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

5.3 rutils.sequence

Sequence utilities, including SPLIT-SEQUENCE.

Source

packages.lisp.

Use List
Used By List
Public Interface
Internals

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

5.4 rutils.bind

Unified extensible bind operator.

Source

packages.lisp.

Use List
Used By List

rutils.

Public Interface
Internals

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

5.5 rutils.generic

Generic access, copy, tally.

Source

packages.lisp.

Use List
Used By List
Public Interface
Internals

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

5.6 rutils.misc

Assorted small utilities.

Source

packages.lisp.

Use List
Used By List
Public Interface
Internals

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

5.7 rutils.iter

Iterate macro with keywords for clauses.

Source

packages.lisp.

Use List
Used By List

rutils.

Public Interface
Internals

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

5.8 rutils.hash-table

Hash-table utilities.

Source

packages.lisp.

Use List
Used By List
Public Interface

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

5.9 rutils-user

CL-USER + RUTILS.

Source

packages.lisp.

Use List

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

5.10 rutils.string

String utilities.

Source

packages.lisp.

Use List
Used By List
Public Interface

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

5.11 rutils.abbr

Abbreviations of some common utilities with long names.

Source

packages.lisp.

Use List
Used By List

rtl.

Public Interface

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

5.12 rutils.tree

Tree utilities.

Source

packages.lisp.

Use List
Used By List

rutils.

Public Interface

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

5.13 rutils.list

List utilities.

Source

packages.lisp.

Use List
Used By List
Public Interface

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

5.14 rutils.array

Array utilities.

Source

packages.lisp.

Use List
Used By List
Public Interface

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

5.15 rutils.hash-set

Hash-set utilities.

Source

packages.lisp.

Use List
Used By List

rutils.

Public Interface

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

5.16 rutils

The whole set of utilities in one package.

Source

packages.lisp.

Use List
Used By List
Internals

*all-packages* (special variable).


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

5.17 rutils.kv

Key-value utilities.

Source

packages.lisp.

Use List
Used By List

rutils.

Public Interface
  • dokv (macro).
  • eq-test (generic function).
  • keys (generic function).
  • kvs (generic function).
  • mapkv (generic function).
  • vals (generic function).

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

5.18 rtl-user

CL-USER + RTL.

Source

packages.lisp.

Use List
  • common-lisp.
  • common-lisp-user.
  • rtl.

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

5.19 rutils.pair

Generic pair data structure.

Source

packages.lisp.

Use List
Used By List
Public Interface
Internals

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

5.20 rutils.anaphora

Anaphoric control constructs.

Source

packages.lisp.

Use List
Used By List
Public Interface

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

5.21 rutils.symbol

Core symbol-manipulation utilities.

Source

packages.lisp.

Use List
Used By List
Public Interface

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


Next: , Previous: , Up: Public Interface   [Contents][Index]

6.1.1 Special variables

Special Variable: +default-opts+

Default optimization settings for RUTILS.

Package

rutils.readtable.

Source

packages.lisp.

Special Variable: iter-version

Current version of Iterate.

Package

rutils.iter.

Source

iter.lisp.


6.1.2 Macros

Macro: -> (x &rest forms)

Threads the expr through FORMS. Inserts X as the
second item in the first form, or in place of % if it is present in the form, making a list of it if it is not a list already.
If there are more forms, inserts the first form
as the second item in second form, etc.

Package

rutils.misc.

Source

misc.lisp.

Macro: ->> (x &rest forms)

Threads the expr through FORMS. Inserts X as the
last item in the first form, or in place of % if it is present in the form, making a list of it if it is not a list already.
If there are more forms, inserts the first form
as the last item in second form, etc.

Package

rutils.misc.

Source

misc.lisp.

Macro: 2nd (form)

(NTH-VALUE 1 FORM)

Package

rutils.misc.

Source

misc.lisp.

Macro: <- (place fn)

Apply FN in-place to PLACE.

Package

rutils.misc.

Source

misc.lisp.

Macro: => (fn1 fn2 &rest fns)

Function composition of FN1, FN2 and all the other FNS.

Package

rutils.misc.

Source

misc.lisp.

Macro: aand (&rest args)

Like AND. IT is bound to the value of the previous AND form.

Package

rutils.anaphora.

Alias for

and-it.

Macro: abbr (short long &optional lambda-list)

Abbreviate LONG macro or function name as SHORT.
If LAMBDA-LIST is present, also copy appropriate SETF-expander.

Package

rutils.symbol.

Source

symbol.lisp.

Macro: acond (&body body)

Like COND. IT is bound to the passed COND test.

Package

rutils.anaphora.

Alias for

cond-it.

Macro: adowhile (test &body body)

Like DOWHILE. IT is bound to TEST.

Package

rutils.anaphora.

Alias for

dowhile-it.

Macro: aif (test then &optional else)

Like IF. IT is bound to TEST.

Package

rutils.anaphora.

Alias for

if-it.

Macro: and-bind (var &rest args)

Like AND. VAR will be bound to the value of the previous AND form

Package

rutils.anaphora.

Alias for

and-let.

Macro: and-it (&rest args)

Like AND. IT is bound to the value of the previous AND form.

Package

rutils.anaphora.

Source

anaphora.lisp.

Macro: and-let (var &rest args)

Like AND. VAR will be bound to the value of the previous AND form

Package

rutils.anaphora.

Source

anaphora.lisp.

Macro: appendf (place &rest lists)

Modify-macro for APPEND. Appends LISTS to the place designated by the first argument.

Package

rutils.list.

Source

list.lisp.

Macro: awhen (test &body body)

Like WHEN. IT is bound to TEST.

Package

rutils.anaphora.

Alias for

when-it.

Macro: bind ((&rest bindings) &body body)

Bind variables from BINDINGS to be active inside BODY, as if by LET*, combined with MULTIPLE-VALUE-BIND, DESTRUCTURING-BIND and other -bind forms, depending on the type of the first argument.

Package

rutils.bind.

Source

bind.lisp.

Macro: coercef (place type-spec)

Modify-macro for COERCE.

Package

rutils.misc.

Source

misc.lisp.

Macro: cond-bind (var &body body)

Like COND. VAR will be bound to the passed COND test.

Package

rutils.anaphora.

Alias for

cond-let.

Macro: cond-it (&body body)

Like COND. IT is bound to the passed COND test.

Package

rutils.anaphora.

Source

anaphora.lisp.

Macro: cond-let (var &body body)

Like COND. VAR will be bound to the passed COND test.

Package

rutils.anaphora.

Source

anaphora.lisp.

Macro: cswitch ((object &key test key) &body clauses)

Like SWITCH, but signals a continuable error if no key matches.

Package

rutils.misc.

Source

misc.lisp.

Macro: dcase (keyform &body clauses)

DCASE is a combination of CASE and DESTRUCTURING-BIND.
KEYFORM must evaluate to a CONS.

Clauses are of the form:

((CASE-KEYS . DESTRUCTURING-LAMBDA-LIST) FORM*)

The clause whose CASE-KEYS matches CAR of KEY, as if by CASE,
is selected, and FORMs are then executed with CDR of KEY is destructured and bound by the DESTRUCTURING-LAMBDA-LIST.

Package

rutils.misc.

Source

misc.lisp.

Macro: dccase (keyform &body clauses)

DCCASE is a combination of CCASE and DESTRUCTURING-BIND.
KEYFORM must evaluate to a CONS.

Clauses are of the form:

((CASE-KEYS . DESTRUCTURING-LAMBDA-LIST) FORM*)

The clause whose CASE-KEYS matches CAR of KEY, as if by CCASE,
is selected, and FORMs are then executed with CDR of KEY is destructured and bound by the DESTRUCTURING-LAMBDA-LIST.

Package

rutils.misc.

Source

misc.lisp.

Macro: decase (keyform &body clauses)

DECASE is a combination of ECASE and DESTRUCTURING-BIND.
KEYFORM must evaluate to a CONS.

Clauses are of the form:

((CASE-KEYS . DESTRUCTURING-LAMBDA-LIST) FORM*)

The clause whose CASE-KEYS matches CAR of KEY, as if by ECASE,
is selected, and FORMs are then executed with CDR of KEY is destructured and bound by the DESTRUCTURING-LAMBDA-LIST.

Package

rutils.misc.

Source

misc.lisp.

Macro: defclause (clause-template &body body)

Macro for defining iterate clauses (with DEFUN).

Package

rutils.iter.

Source

iter.lisp.

Macro: defclause-driver (clause-template &body body)

Macro for for defining (with DEFUN) iterators, which may also be used as generators.

Package

rutils.iter.

Source

iter.lisp.

Macro: defclause-sequence (element-name index-name &key access-fn size-fn element-type sequence-type element-doc-string index-doc-string)

A simple way to define a FOR-like &sequence clause.

Package

rutils.iter.

Source

iter.lisp.

Macro: defmacro-clause (clause-template &body body)

Macro for defining iterate clauses (with DEFMACRO).

Package

rutils.iter.

Source

iter.lisp.

Macro: defmacro-driver (clause-template &body body)

Macro for for defining iterators (with DEFMACRO), which may also be used as generators.

Package

rutils.iter.

Source

iter.lisp.

Macro: defpar (var val &optional doc)

Define a parameter that is not normally changed by the program, but that may be changed without causing an error. Declare the variable special and sets its value to VAL, overwriting any previous value. The third argument is an optional documentation string for the parameter.

Package

rutils.abbr.

Alias for

defparameter.

Macro: deletef (place item &rest remove-keywords)

Modify-macro for DELETE. Sets place designated by the first argument to the result of calling DELETE with ITEM, place, and the REMOVE-KEYWORDS.

Package

rutils.sequence.

Source

sequence.lisp.

Macro: doindex ((index-var elt-var sequence &optional result-form) &body body)

Iterates over a sequence while keeping track of an index. A DO-style macro.

Example usage:

CL-USER> (doindex (i e ’(a b c))
(format T "~&~S ~S" i e))
1 a
2 b
3 c

Package

rutils.sequence.

Source

sequence.lisp.

Macro: dokv ((k v kv &optional rez) &body body)

Like DOLIST but iterates over key-value pairs (K V) in anything, that can be viewed as a KV (hash-table, alist, plist, object).
Autodeclares variables named _ as ignored.

Package

rutils.kv.

Source

kv.lisp.

Macro: doleaves ((node tree &optional result) &body body)

Iterate over each leaf NODE of the TREE in depth-first order. Optionally return RESULT.

Package

rutils.tree.

Source

tree.lisp.

Macro: dolines ((line src &optional result) &body body)

Iterate over each LINE in SRC (a stream or path to a file) as in DOLIST.

Package

rutils.string.

Source

string.lisp.

Macro: doplist ((key val plist &optional rez) &body body)

Like DOLIST but iterate over 2 items of the PLIST at once, onsidered KEY and VAL. Asserts proper PLIST.

Package

rutils.list.

Source

list.lisp.

Macro: dotable ((k v table &optional rez) &body body)

Like DOLIST but iterates over key-value pairs (K V) in anything, that can be viewed as a table (hash-table, alist, plist, object).
Autodeclares variables named _ as ignored.

Package

rutils.hash-table.

Source

hash-table.lisp.

Macro: dotree ((subtree tree &optional result) &body body)

Iterate over each SUBTREE of the TREE in depth-first order. Optionally return RESULT.

Package

rutils.tree.

Source

tree.lisp.

Macro: dovec ((var vec &optional result-form) &body body)

Iterates over a vector (like in DOLIST).

Package

rutils.array.

Source

array.lisp.

Macro: dowhile-bind ((var test) &body body)

Like DOWHILE. VAR will be bound to TEST.

Package

rutils.anaphora.

Alias for

dowhile-let.

Macro: dowhile-it (test &body body)

Like DOWHILE. IT is bound to TEST.

Package

rutils.anaphora.

Source

anaphora.lisp.

Macro: dowhile-let ((var test) &body body)

Like DOWHILE. VAR will be bound to TEST.

Package

rutils.anaphora.

Source

anaphora.lisp.

Macro: ds-bind (lambda-list expression &body body)

Bind the variables in LAMBDA-LIST to the corresponding values in the tree structure resulting from the evaluation of EXPRESSION.

Package

rutils.abbr.

Alias for

destructuring-bind.

Macro: dsetq (template value)

Destructuring assignment; supports both (VALUES ...) for destructuring a multiple-value form and NIL as a variable name, meaning to ignore that position, e.g. (DSETQ (VALUES (A . B) NIL C) FORM).

Package

rutils.iter.

Source

iter.lisp.

Macro: eswitch ((object &key test key) &body clauses)

Like SWITCH, but signals an error if no key matches.

Package

rutils.misc.

Source

misc.lisp.

Macro: eval-always (&body body)

Wrap BODY in eval-when with all keys (compile, load and execute) mentioned.

Package

rutils.symbol.

Source

symbol.lisp.

Macro: flet* (&rest body)

An abbreviation for LABELS.

Package

rutils.abbr.

Source

abbr.lisp.

Macro: fn (name lambda-list &body body)

Expands into a lambda-expression within whose BODY NAME denotes the corresponding function.

Package

rutils.misc.

Alias for

named-lambda.

Macro: getset# (key table new-value)

Either get the value from TABLE by KEY or set a new calculated NEW-VALUE there and return it.
It’s similar to GETHASH called with 3 parameteres, but functions lazily.

Package

rutils.hash-table.

Alias for

getsethash.

Macro: getsethash (key table new-value)

Either get the value from TABLE by KEY or set a new calculated NEW-VALUE there and return it.
It’s similar to GETHASH called with 3 parameteres, but functions lazily.

Package

rutils.hash-table.

Source

hash-table.lisp.

Macro: if-bind ((var test) then &optional else)

Like IF. VAR will be bound to TEST.

Package

rutils.anaphora.

Alias for

if-let.

Macro: if-it (test then &optional else)

Like IF. IT is bound to TEST.

Package

rutils.anaphora.

Source

anaphora.lisp.

Macro: if-let ((var test) then &optional else)

Like IF. VAR will be bound to TEST.

Package

rutils.anaphora.

Source

anaphora.lisp.

Macro: iter (&body body)

Jonathan Amsterdam’s powerful and extensible iteration facility, providing multiple accumulation, generators, memory of previous iterations, over 50 clauses to start with and a Lisp-like syntax. Evaluate (iter:display-iter-clauses) for an overview of clauses.

Package

rutils.iter.

Source

iter.lisp.

Macro: listcase (list &body cases)

A typecase-like macro to destinguish between 3 possible kinds of LIST: simple lists, alists, and dlists.
Evaluates the appropriate key-form depending on the kind: ALIST, DLIST or simple list (T).

Package

rutils.list.

Source

list.lisp.

Macro: multiple-value-prog2 (first-form second-form &body forms)

Evaluates FIRST-FORM, then SECOND-FORM, and then FORMS. Yields as its value all the value returned by SECOND-FORM.

Package

rutils.misc.

Source

misc.lisp.

Macro: mv-bind (vars value-form &body body)
Package

rutils.abbr.

Alias for

multiple-value-bind.

Macro: named-lambda (name lambda-list &body body)

Expands into a lambda-expression within whose BODY NAME denotes the corresponding function.

Package

rutils.misc.

Source

misc.lisp.

Macro: nconcf (place &rest lists)

Modify-macro for NCONC. Concatenates LISTS to place designated by the first argument.

Package

rutils.list.

Source

list.lisp.

Macro: nreversef (place)

Modify-macro for NREVERSE. Reverses the list stored in the given place by destructively modifying it and saves back the result into the place.

Package

rutils.list.

Source

list.lisp.

Macro: nunionf (place list &rest args)

Modify-macro for NUNION. Saves the union of LIST and the contents of the place designated by the first argument to the designated place. May modify either argument.

Package

rutils.list.

Source

list.lisp.

Macro: once-only (specs &body forms)

Evaluate FORMS with names rebound to temporary variables, ensuring that each is evaluated only once.

Each SPEC must be either a NAME, or a (NAME INITFORM), with plain NAME using the named variable as initform.

Example:

CL-USER> (defmacro cons1 (x)
(once-only (x)
‘(cons ,x ,x)))
CL-USER> (let ((y 0))
(cons1 (incf y)))
(1 . 1)

Package

rutils.misc.

Source

misc.lisp.

Macro: pcase (pred keyform &rest clauses)

Like CASE, but uses given PRED instead of EQL to select appropriate CLAUSE.

Example usage:

CL-USER> (pcase ’< 1
(0 (print "Below zero"))
(2 (print "OK"))
(otherwise (error "Oops")))

Package

rutils.misc.

Source

misc.lisp.

Macro: pccase (pred keyform &rest clauses)

Like CCASE, but uses given PRED instead of EQL to select appropriate CLAUSE.

Example usage:

CL-USER> (pccase ’< 1
(0 (print "Below zero"))
(2 (print "OK")))

Package

rutils.misc.

Source

misc.lisp.

Macro: pecase (pred keyform &rest clauses)

Like ECASE, but uses given PRED instead of EQL to select appropriate CLAUSE.

Example usage:

CL-USER> (pecase ’< 1
(0 (print "Below zero"))
(2 (print "OK")))

Package

rutils.misc.

Source

misc.lisp.

Macro: re-setf (var &rest clauses)

SETFs VAR to the value of each clause subsequently. Re-uses the new value of VAR in subsequent clauses. Expects VAR to be a valid place for SETF.

Package

rutils.misc.

Source

misc.lisp.

Macro: removef (place item &rest remove-keywords)

Modify-macro for REMOVE. Sets place designated by the first argument to the result of calling REMOVE with ITEM, place, and the REMOVE-KEYWORDS.

Package

rutils.sequence.

Source

sequence.lisp.

Macro: reversef (place)

Modify-macro for REVERSE. Copies and reverses the list stored in the given place and saves back the result into the place.

Package

rutils.list.

Source

list.lisp.

Macro: switch ((object &key test key) &body clauses)

Evaluate first matching clause, returning its values, or evaluates and returns the values of DEFAULT if no keys match.

Package

rutils.misc.

Source

misc.lisp.

Macro: unionf (place list &rest args)

Modify-macro for UNION. Saves the union of LIST and the contents of the place designated by the first argument to the designated place.

Package

rutils.list.

Source

list.lisp.

Macro: void (place)

Nullify PLACE.

Package

rutils.misc.

Source

misc.lisp.

Macro: w/instr ((var string &key index start end) &body forms-decls)
Package

rutils.abbr.

Alias for

with-input-from-string.

Macro: w/outstr ((var &optional string &key element-type) &body body)
Package

rutils.abbr.

Alias for

with-output-to-string.

Macro: w/uniqs ((&rest names) &body body)

Provide gensyms for given NAMES.

Package

rutils.symbol.

Alias for

with-gensyms.

Macro: when-bind ((var test) &body body)

Like WHEN. VAR will be bound to TEST.

Package

rutils.anaphora.

Alias for

when-let.

Macro: when-it (test &body body)

Like WHEN. IT is bound to TEST.

Package

rutils.anaphora.

Source

anaphora.lisp.

Macro: when-let ((var test) &body body)

Like WHEN. VAR will be bound to TEST.

Package

rutils.anaphora.

Source

anaphora.lisp.

Macro: with ((&rest bindings) &body body)

Bind variables from BINDINGS to be active inside BODY, as if by LET*, combined with MULTIPLE-VALUE-BIND, DESTRUCTURING-BIND and other -bind forms, depending on the type of the first argument.

Package

rutils.bind.

Alias for

bind.

Macro: with-gensyms ((&rest names) &body body)

Provide gensyms for given NAMES.

Package

rutils.symbol.

Source

symbol.lisp.

Macro: with-keys ((&rest kv-pairs) ht &body body)

Like WITH-ACCESSORS but for pairs in hash-table HT.

Package

rutils.hash-table.

Source

hash-table.lisp.

Macro: with-out-file ((var path) &body body)
Package

rutils.string.

Source

string.lisp.

Macro: with-output-to-list ((out) &body body)

A simple list analog of WITH-OUTPUT-TO-STRING, which supports the general pattern of using list as an accumulator. OUT is bound to a fresh list, that will be returned nreversed. BODY is wraped in implicit block NIL.

Package

rutils.list.

Source

list.lisp.

Macro: with-pair ((lt rt) pair &body body)

Bind LT and RT to PAIR’s slots and execute BODY inside.

Package

rutils.pair.

Source

pair.lisp.

Macro: with-unique-names ((&rest names) &body body)

Provide gensyms for given NAMES.

Package

rutils.symbol.

Alias for

with-gensyms.

Macro: xor (&rest args)

Evaluates the ARGS one at a time. If more than one is T, evaluation stops and NIL is returned. If exactly one arg is T, that value is returned.

Package

rutils.misc.

Source

misc.lisp.


Next: , Previous: , Up: Public Interface   [Contents][Index]

6.1.3 Compiler macros

Compiler Macro: equal-lengths (length &rest sequences)
Package

rutils.sequence.

Source

sequence.lisp.


6.1.4 Setf expanders

Setf Expander: (setf ?) (obj key &rest keys-and-val)
Package

rutils.generic.

Source

abbr.lisp.

Reader

? (generic function).

Writer

generic-setf (generic function).

Setf Expander: (setf generic-elt) (obj key &rest keys-and-val)
Package

rutils.generic.

Source

generic.lisp.

Reader

generic-elt (generic function).

Writer

generic-setf (generic function).

Setf Expander: (setf get#) (key hashtable &optional default)
Package

rutils.hash-table.

Source

abbr.lisp.

Reader

get# (function).

Setf Expander: (setf smart-slot-value) (obj slot)
Package

rutils.generic.

Source

generic.lisp.

Reader

smart-slot-value (generic function).

Writer

smart-set-slot-value (generic function).


6.1.5 Ordinary functions

Function: #/-reader (stream char arg)

Literal syntax for raw strings (which don’t need escapin of control chars).

Example:

CL-USER> #/This is a "test" string/#
"This is a \"test\" string"
;; here " are actually unescaped, but you can’t write it in a docstring :)

Package

rutils.readtable.

Source

readtable.lisp.

Function: #`-reader (stream char arg)

Literal syntax for zero/one/two argument lambdas.
Use % as the function’s argument, %% as the second.

Examples:

- #‘(+ 2 %) => (lambda (&optional x y) (+ 2 x))
- #‘((print %) (1+ %)) => (lambda (&optional x) (print x) (1+ x)) - #‘(+ 1 2) => (lambda (&optional x y) (+ 1 2))
- #‘(+ % %%) => (lambda (&optional x y) (+ x y))

Package

rutils.readtable.

Source

readtable.lisp.

Function: #h-reader (stream char arg)

Literal syntax for hash-tables.

Examples:

CL-USER> #h(:a 1 :b 2)
#<HASH-TABLE :TEST EQL :COUNT 2>
;; holding 2 key/value pairs: ((:a . 1) (:b . 2))

CL-USER> #h(equalp "a" 1 "b" 2)
#<HASH-TABLE :TEST EQUALP :COUNT 2>
;; holding 2 key/value pairs: (("a" . 1) ...)

Package

rutils.readtable.

Source

readtable.lisp.

Function: #v-reader (stream char arg)

Literal syntax for vectors.
Unlike #() evaluates its contents before vector creation

Examples:

CL-USER> #v(1 2 3)
#(1 2 3)

CL-USER> #v((+ 1 2))
#(3)

Package

rutils.readtable.

Source

readtable.lisp.

Function: #{-reader (stream char arg)

Literal syntax for fixed-size hash-tables.

Examples:

CL-USER> #{:a 1 :b 2}
#<HASH-TABLE :TEST EQL :COUNT 2>
;; holding 2 key/value pairs: ((:a . 1) (:b . 2))

CL-USER> #{equalp "a" 1 "b" 2}
#<HASH-TABLE :TEST EQUALP :COUNT 2>
;; holding 2 key/value pairs: (("a" . 1) ...)

Package

rutils.readtable.

Source

readtable.lisp.

Function: @-reader (stream char)

Short slot and sequence elements access syntax.

Examples:

CL-USER> (defclass foo () ((bar :initform 42))) CL-USER> (defvar *foo* (make ’foo)) CL-USER> @*foo*.bar
42
CL-USER> (defvar *baz* #(1 *foo*))
CL-USER> @*baz*#1.bar
42

Package

rutils.readtable.

Source

readtable.lisp.

Function: add# (item set)

Add ITEM to hash-set SET.

Package

rutils.hash-set.

Source

hash-set.lisp.

Function: alist->ht (alist &rest hash-table-initargs)

Returns a hash-table containing the keys and values, alternating in ALIST. Hash table is initialized using the HASH-TABLE-INITARGS.

Package

rutils.hash-table.

Alias for

hash-table-from-alist.

Function: alist-to-plist (alist)

Make a plist from an alist ALIST.

Package

rutils.list.

Source

list.lisp.

Function: alistp (list)

Test wheather LIST is a properly formed alist.

Package

rutils.list.

Source

list.lisp.

Function: and2 (x y)

AND for 2 arguments as a function.

Package

rutils.misc.

Source

misc.lisp.

Function: assoc1 (item alist &key default key test test-not)

Return a value in ALIST, whose key is eql to ITEM. Also as 2nd value return, whether ITEM was found. If there is no such entry, returns DEFAULT. The usual KEY, TEST and TEST-NOT arguments apply.

Package

rutils.list.

Source

list.lisp.

Function: atomize (list-or-val)
Package

rutils.list.

Source

list.lisp.

Function: blankp (string)

Test whether a STRING is blank (empty).

Package

rutils.string.

Source

string.lisp.

Function: butlast2 (list &optional n)

Split LIST in 2 parts and return them as multiple values:
head and tail. If (= N 1), which is the most common case, the tail will be a single element, otherwise – a list as well.

Package

rutils.list.

Source

list.lisp.

Function: call (function &rest arguments)

Call FUNCTION with the given ARGUMENTS.

Package

rutils.abbr.

Alias for

funcall.

Function: concat (&rest lists)

CONCATENATE all the LISTS into a single list.

Package

rutils.list.

Source

list.lisp.

Function: copy-array (arr)

Create a fresh copy of the array ARR.

Package

rutils.array.

Source

array.lisp.

Function: copy-hash-table (ht &key key test size rehash-size rehash-threshold)

Returns a copy of hash table HT, with the same keys and values. The copy has the same properties as the original, unless overridden by the keyword arguments.

Before each of the original values is set into the new hash-table, KEY is invoked on the value. As KEY defaults to IDENTITY
a shallow copy is returned by default.

Package

rutils.hash-table.

Source

hash-table.lisp.

Function: dcons (key val dlist)

Add KEY-VAL pair to the front of DLIST.

Package

rutils.list.

Source

list.lisp.

Function: delete-from-plist (plist &rest keys)

Just like REMOVE-FROM-PLIST, but this version may destructively modify the provided PLIST.

Package

rutils.list.

Source

list.lisp.

Function: diff# (set1 set2)

Set difference between hash-sets SET1 & SET2.

Package

rutils.hash-set.

Source

hash-set.lisp.

Function: display-iter-clauses (&optional clause-spec)

Display ITERATE clause.

Package

rutils.iter.

Source

iter.lisp.

Function: dlistp (list)

Test wheather LIST is a properly formed dlist, i.e. a list-structure of the form: ((keys) vals).

Package

rutils.list.

Source

list.lisp.

Function: dyadic (list)

Test wheather LIST contains exactly 2 elements.

Package

rutils.list.

Source

list.lisp.

Function: emptyp (sequence)

Returns true if SEQUENCE is an empty sequence. Signals an error if SEQUENCE is not a sequence.

Package

rutils.sequence.

Source

sequence.lisp.

Function: emptyp# (set)

Test wether a hash-set is empty

Package

rutils.hash-set.

Source

hash-set.lisp.

Function: ends-with (suffix string &key test -end)

Test, whether STRING ends with SUFFIX. Accepts TEST. If -END is provided matches from this offset from end.

Package

rutils.string.

Source

string.lisp.

Function: ensure-keyword (obj &key format)

Make a keyword from OBJ according to FORMAT.

Package

rutils.symbol.

Source

symbol.lisp.

Function: ensure-list (obj)

Wrap OBJ in a list, if it’s not a list.

Package

rutils.list.

Source

list.lisp.

Function: ensure-symbol (obj &key format package)

Make a symbol in either PACKAGE or *PACKAGE* from OBJ according to FORMAT.

Package

rutils.symbol.

Source

symbol.lisp.

Function: equal-lengths (&rest sequences)

Takes any number of sequences or integers in any order. Returns true iff the length of all the sequences and the integers are equal.
Hint: there’s a compiler macro that expands into more efficient code if the first argument is a literal integer.

Package

rutils.sequence.

Source

sequence.lisp.

Function: flat-map (function &rest lists)

Apply FUNCTION to respective elements of each LIST, appending all the result lists to a single list. FUNCTION must return a list.

Package

rutils.list.

Alias for

mappend.

Function: flatten (list &optional level)

Flatten possibly nested LIST a given number of LEVELs (or to the end).

Package

rutils.list.

Source

list.lisp.

Function: fmt (format-string &rest args)

(FORMAT NIL FORMAT-STRING ARGS)

Package

rutils.string.

Source

string.lisp.

Function: get# (key hash-table &optional default)

Finds the entry in HASH-TABLE whose key is KEY and returns the associated value and T as multiple values, or returns DEFAULT and NIL if there is no such entry. Entries can be added using SETF.

Package

rutils.hash-table.

Alias for

gethash.

Function: group (n seq)

Split SEQ into a list of sequences of the same type of length N (the last sequence may be shorter).

Package

rutils.sequence.

Source

sequence.lisp.

Function: hash-set (&optional test &rest items)

Create a hash-set with a given TEST and initial contents ITEMS.

Package

rutils.hash-set.

Source

hash-set.lisp.

Function: hash-table-from-alist (alist &rest hash-table-initargs)

Returns a hash-table containing the keys and values, alternating in ALIST. Hash table is initialized using the HASH-TABLE-INITARGS.

Package

rutils.hash-table.

Source

hash-table.lisp.

Function: hash-table-from-plist (plist &rest hash-table-initargs)

Returns a hash-table containing the keys and values, alternating in PLIST. Hash table is initialized using the HASH-TABLE-INITARGS.

Package

rutils.hash-table.

Source

hash-table.lisp.

Function: hash-table-keys (ht)

Return a list of keys of hash-table HT.

Package

rutils.hash-table.

Source

hash-table.lisp.

Function: hash-table-to-alist (ht)

Returns an alist containing the keys and values of hash-table HT.

Package

rutils.hash-table.

Source

hash-table.lisp.

Function: hash-table-to-plist (ht)

Returns a list containing the keys and values of hash-table HT.

Package

rutils.hash-table.

Source

hash-table.lisp.

Function: hash-table-vals (ht)

Return a list of values of hash-table HT.

Package

rutils.hash-table.

Source

hash-table.lisp.

Function: ht->alist (ht)

Returns an alist containing the keys and values of hash-table HT.

Package

rutils.hash-table.

Alias for

hash-table-to-alist.

Function: ht->pairs (ht)

Dump hash-table HT to list of pairs.

Package

rutils.pair.

Source

pair.lisp.

Function: ht->plist (ht)

Returns a list containing the keys and values of hash-table HT.

Package

rutils.hash-table.

Alias for

hash-table-to-plist.

Function: ht-count (hash-table)

Return the number of entries in the given HASH-TABLE.

Package

rutils.hash-table.

Alias for

hash-table-count.

Function: ht-keys (ht)

Return a list of keys of hash-table HT.

Package

rutils.hash-table.

Alias for

hash-table-keys.

Function: ht-vals (ht)

Return a list of values of hash-table HT.

Package

rutils.hash-table.

Alias for

hash-table-vals.

Function: in# (key hash-table)

Check if KEY is present in HASH-TABLE.

Package

rutils.hash-table.

Source

hash-table.lisp.

Function: inter# (set1 set2)

Set intersection between hash-sets SET1 & SET2.

Package

rutils.hash-set.

Source

hash-set.lisp.

Function: interleave (list &rest lists)

Return a list whose elements are taken from LIST and each of LISTS like this: 1st of list, 1st of 1st of lists,..., 1st of last of lists, 2nd of list,...

Package

rutils.list.

Source

list.lisp.

Function: interpose (separator list)

Returns a sequence of the elements of SEQUENCE separated by SEPARATOR.

Package

rutils.list.

Source

list.lisp.

Function: just (thing)

This function simply returns what was passed to it.

Package

rutils.abbr.

Alias for

identity.

Function: keep (item sequence &rest args &key from-end test test-not start end count key)

The opposite of REMOVE.

Package

rutils.sequence.

Source

sequence.lisp.

Function: keep-if (predicate sequence &rest args &key from-end start end count key)

Return a copy of sequence with elements not satisfying PREDICATE removed.

Package

rutils.sequence.

Alias for

remove-if-not.

Function: keep-if-not (predicate sequence &rest args &key from-end start end count key)

Return a copy of sequence with elements satisfying PREDICATE removed.

Package

rutils.sequence.

Alias for

remove-if.

Function: last-char (string)

Return the last character of STRING if it’s not empty, otherwise - nil.

Package

rutils.string.

Source

string.lisp.

Function: last-elt (sequence)

Returns the last element of SEQUENCE.
Signals a type-error if SEQUENCE is not a proper sequence, or is an empty sequence.

Package

rutils.sequence.

Source

sequence.lisp.

Function: (setf last-elt) (sequence)

Sets the last element of SEQUENCE.
Signals a type-error if SEQUENCE is not a proper sequence, is an empty sequence.

Package

rutils.sequence.

Source

sequence.lisp.

Function: last1 (list &optional n)

Get the N-th element of LIST from end, starting from the last one (which is number 1).

Package

rutils.list.

Source

list.lisp.

Function: (setf last1) (list &optional n)
Package

rutils.list.

Source

list.lisp.

Function: length= (sequence length)

Return true if SEQUENCE’s length equals LENGTH. Returns FALSE for circular lists.
Signals an error if SEQUENCE is not a sequence.

Package

rutils.sequence.

Source

sequence.lisp.

Function: less (x y)

Like <, but works for NIL values of X and Y.
Obviously, NIL is LESS, than anything, including itself.

Package

rutils.misc.

Source

misc.lisp.

Function: lt (structure)
Package

rutils.pair.

Alias for

pair-left.

Function: m1 (form &optional env)

If form is a macro (or symbol macro), expand it once. Return two values, the expanded form and a T-or-NIL flag indicating whether the form was, in fact, a macro. ENV is the lexical environment to expand in, which defaults to the null environment.

Package

rutils.abbr.

Alias for

macroexpand-1.

Function: make-gensym-list (length &optional x)

Return a list of LENGTH gensyms, using the second (optional, defaulting to ’G’) argument.

Package

rutils.symbol.

Source

symbol.lisp.

Function: make-pair (&key left right)
Package

rutils.pair.

Source

pair.lisp.

Function: map* (fn seq &rest seqs)

DWIM version of map that uses the type of first sequence (SEQ) for result.

Package

rutils.sequence.

Source

sequence.lisp.

Function: mapcanindex (fn list)

Mapcan FN with 2 lists:
- numeric inidices for LIST, starting from 0 - LIST itself

Package

rutils.list.

Source

list.lisp.

Function: mapcat (function &rest lists)

Apply FUNCTION to respective elements of each LIST, appending all the result lists to a single list. FUNCTION must return a list.

Package

rutils.list.

Alias for

mappend.

Function: mapindex (fn list)

Mapcar FN with 2 lists:
- numeric inidices for LIST, starting from 0 - LIST itself

Package

rutils.list.

Source

list.lisp.

Function: mapleaves (fn tree)

Map a one-argument function FN over each leaf node of the TREE
in depth-first order, returning a new tree with the same structure.

Package

rutils.tree.

Source

tree.lisp.

Function: mappend (function &rest lists)

Apply FUNCTION to respective elements of each LIST, appending all the result lists to a single list. FUNCTION must return a list.

Package

rutils.list.

Source

list.lisp.

Function: maptimes (times fn)

Map FN with number range from 0 to TIMES (exclusive).

Package

rutils.list.

Source

list.lisp.

Function: maptree (fn tree)

Map a one-argument function FN over each subtree of the TREE
in depth-first order, returning a new tree with the same structure.

Package

rutils.tree.

Source

tree.lisp.

Function: merge-hash-tables (ht &rest hts)

From 1 or more HTS create a single one with TEST of HT.

Package

rutils.hash-table.

Source

hash-table.lisp.

Function: merge-hash-tables-with (fn ht &rest hts)

From 1 or more HTS create a single one with TEST of HT
and values created by calling FN (a two-argument function that should be prepared to accept nil values when some keys are not present in all hash-tables) with all the values from HT & HTS for a particular key.

Package

rutils.hash-table.

Source

hash-table.lisp.

Function: merge-hts (ht &rest hts)

From 1 or more HTS create a single one with TEST of HT.

Package

rutils.hash-table.

Alias for

merge-hash-tables.

Function: merge-hts-with (fn ht &rest hts)

From 1 or more HTS create a single one with TEST of HT
and values created by calling FN (a two-argument function that should be prepared to accept nil values when some keys are not present in all hash-tables) with all the values from HT & HTS for a particular key.

Package

rutils.hash-table.

Alias for

merge-hash-tables-with.

Function: mkeyw (obj &key format)

Make a keyword from OBJ according to FORMAT.

Package

rutils.symbol.

Alias for

ensure-keyword.

Function: mklist (obj)

Wrap OBJ in a list, if it’s not a list.

Package

rutils.list.

Alias for

ensure-list.

Function: mksym (obj &key format package)

Make a symbol in either PACKAGE or *PACKAGE* from OBJ according to FORMAT.

Package

rutils.symbol.

Alias for

ensure-symbol.

Function: more (x y)

Like >, but works for NIL values of X and Y.
Obviously, NIL is not MORE, than anything, including itself.

Package

rutils.misc.

Source

misc.lisp.

Function: not-less (x y)

Like >=, but works for NIL values of X and Y.
Obviously, NIL is not NOT-LESS, than anything, including itself.

Package

rutils.misc.

Source

misc.lisp.

Function: not-more (x y)

Like <=, but works for NIL values of X and Y.
Obviously, NIL is NOT-MORE, than anything, including itself.

Package

rutils.misc.

Source

misc.lisp.

Function: nshuffle (sequence &key start end)

Shuffle SEQUENCE (in bounds of START and END) in-place.

Package

rutils.sequence.

Source

sequence.lisp.

Function: or2 (x y)

OR for 2 arguments as a function.

Package

rutils.misc.

Source

misc.lisp.

Function: p# (ht &optional stream)

Pretty print hash-table HT to STREAM.

Package

rutils.hash-table.

Alias for

print-hash-table.

Function: package-external-symbols (package)

List all symbols in a PACKAGE.

Package

rutils.symbol.

Source

symbol.lisp.

Function: package-internal-symbols (package)

List all symbols in a PACKAGE that are not imported.

Package

rutils.symbol.

Source

symbol.lisp.

Function: package-symbols (package)

List all symbols in a PACKAGE.

Package

rutils.symbol.

Source

symbol.lisp.

Function: pair (x y)

A shortcut to make a pair of X and Y.

Package

rutils.pair.

Source

pair.lisp.

Function: pair-left (structure)
Package

rutils.pair.

Source

pair.lisp.

Function: (setf pair-left) (structure)
Package

rutils.pair.

Source

pair.lisp.

Function: pairs->ht (pairs &rest hash-table-initargs)

Create hash-table from the list of PAIRS.
Hash table is initialized using the HASH-TABLE-INITARGS.

Package

rutils.pair.

Source

pair.lisp.

Function: partition-with (key-sequence sequence &key ordering test key result-type keys-sorted)

Partition a SEQUENCE into a sequence of sequences, each one related
by TEST to one key in KEY-SEQUENCE (which may be already sorted: KEYS-SORTED).

Returns a sorted KEY-SEQUENCE as a 2nd value.

Return values are coerced to RESULT-TYPE, that should be a sequence subtype (default is LIST).

ORDERING is used for sorting both SEQUENCE and KEY-SEQUENCE.
Accepts KEY.

Package

rutils.sequence.

Source

sequence.lisp.

Function: permutations (list)

Generate all permutations of LIST. Complexity: O(n!)

Package

rutils.list.

Source

list.lisp.

Function: plist->ht (plist &rest hash-table-initargs)

Returns a hash-table containing the keys and values, alternating in PLIST. Hash table is initialized using the HASH-TABLE-INITARGS.

Package

rutils.hash-table.

Alias for

hash-table-from-plist.

Function: plist-to-alist (plist)

Make an alist from a plist PLIST.

Package

rutils.list.

Source

list.lisp.

Function: plistp (list)

Test wheather LIST is a properly formed plist.

Package

rutils.list.

Source

list.lisp.

Function: print-hash-table (ht &optional stream)

Pretty print hash-table HT to STREAM.

Package

rutils.hash-table.

Source

hash-table.lisp.

Function: print-ht (ht &optional stream)

Pretty print hash-table HT to STREAM.

Package

rutils.hash-table.

Alias for

print-hash-table.

Function: product (fn seq &rest seqs)

Product of the results of mapping FN to SEQ and other SEQS.

Package

rutils.sequence.

Source

sequence.lisp.

Function: pushx (new-element vector &optional min-extension)
Package

rutils.abbr.

Alias for

vector-push-extend.

Function: range (start limit &key step)

Return a list of numbers, starting from START up to LIMIT incremented by STEP (default 1).

Package

rutils.list.

Source

list.lisp.

Function: re-export-symbols (from-package to-package)

Make the exported symbols in FROM-PACKAGE be also exported from TO-PACKAGE.

Package

rutils.symbol.

Source

symbol.lisp.

Function: read-file (filename)

Read a whole file by FILENAME into a string.

Package

rutils.string.

Source

string.lisp.

Function: rem# (key hash-table)

Remove the entry in HASH-TABLE associated with KEY. Return T if there was such an entry, or NIL if not.

Package

rutils.hash-table.

Alias for

remhash.

Function: remove-from-plist (plist &rest keys)

Returns a propery-list with same keys and values as PLIST,
except that keys in the list designated by KEYS and values, corresponding to them are removed. The returned property-list may share structure with the PLIST, but PLIST is not destructively modified. Keys are compared using EQ.

Package

rutils.list.

Source

list.lisp.

Function: remove-idx (idx list)

Return a copy of the list without IDX-th element.

Package

rutils.list.

Source

list.lisp.

Function: rotate (sequence &optional n)

Returns a sequence of the same type as SEQUENCE, with the elements of SEQUENCE rotated by N: N elements are moved from the end of the sequence to the front if N is positive, and -N elements moved from the front to the end if N is negative. SEQUENCE must be a proper sequence. N must be an integer, defaulting to 1.

If absolute value of N is greater then the length of the sequence, the results are identical to calling ROTATE with

(* (signum n) (mod n (length sequence))).

Note: the original sequence may be destructively altered,
and result sequence may share structure with it.

Package

rutils.sequence.

Source

sequence.lisp.

Function: rt (structure)
Package

rutils.pair.

Alias for

pair-right.

Function: safe-sort (sequence predicate &rest args &key key)

The destructuve nature of SORT triggers many obscure bugs. This function is a thin wrapper over SORT that enqures that an input SEQUENCE is copied.

Package

rutils.sequence.

Source

sequence.lisp.

Function: set# (key ht val)

Set VAL at KEY in hash-table HT.

Package

rutils.hash-table.

Alias for

sethash.

Function: set-equal (list1 list2 &key test key)

Return true if every element of LIST1 matches some element of LIST2 and
every element of LIST2 matches some element of LIST1. Otherwise returns false.

Package

rutils.list.

Source

list.lisp.

Function: sethash (key ht val)

Set VAL at KEY in hash-table HT.

Package

rutils.hash-table.

Source

hash-table.lisp.

Function: shuffle (sequence &key start end)

Return a shuffled copy of SEQUENCE (in bounds of START and END).

Package

rutils.sequence.

Source

sequence.lisp.

Function: single (list)

Test wheather LIST contains exactly 1 element.

Package

rutils.list.

Source

list.lisp.

Function: slice (vec beg &optional end)

Return an array-slice into VEC from BEG to END.
If VEC is already a displaced array, recursively ascend to the original non-displaced array and create a slice into it
(to avoid multiple levels of indirection).

Package

rutils.array.

Source

array.lisp.

Function: slurp (filename)

Read a whole file by FILENAME into a string.

Package

rutils.string.

Alias for

read-file.

Function: split (delimiter seq &key count remove-empty-subseqs from-end start end key test test-not)

Return a list of subsequences in SEQ delimited by DELIMITER.

If REMOVE-EMPTY-SUBSEQS is NIL, empty subsequences will
be included in the result; otherwise they will be discarded. All other keywords work analogously to those for SUBSTITUTE. In particular, the behavior of FROM-END is possibly different from other versions of this function; FROM-END values of NIL and T are equivalent unless COUNT is supplied. The second return value is an index suitable as an argument to SUBSEQ into the sequence indicating where processing stopped.

Package

rutils.sequence.

Alias for

split-sequence.

Function: split-if (predicate seq &key count remove-empty-subseqs from-end start end key)

Return a list of subsequences in SEQ delimited by items, satisfying PREDICATE.

If REMOVE-EMPTY-SUBSEQS is NIL, empty subsequences will be included in the result; otherwise they will be discarded. All other keywords work analogously to those for SUBSTITUTE. In particular, the behavior of FROM-END is possibly different from other versions of this function; FROM-END values of NIL
and T are equivalent unless COUNT is supplied. The second return value is an index suitable as an argument to SUBSEQ into the sequence indicating where processing stopped.

Package

rutils.sequence.

Alias for

split-sequence-if.

Function: split-if-not (predicate seq &key count remove-empty-subseqs from-end start end key)

Return a list of subsequences in SEQ delimited by items, satisfying (complement PREDICATE).

If REMOVE-EMPTY-SUBSEQS is NIL, empty subsequences will be included in the result; otherwise they will be discarded. All other keywords work analogously to those for SUBSTITUTE.
In particular, the behavior of FROM-END is possibly different from other versions of this function; FROM-END values of NIL and T are equivalent unless COUNT is supplied. The second return value is an index suitable as an argument to SUBSEQ into the sequence indicating where processing stopped.

Package

rutils.sequence.

Alias for

split-sequence-if-not.

Function: split-sequence (delimiter seq &key count remove-empty-subseqs from-end start end key test test-not)

Return a list of subsequences in SEQ delimited by DELIMITER.

If REMOVE-EMPTY-SUBSEQS is NIL, empty subsequences will
be included in the result; otherwise they will be discarded. All other keywords work analogously to those for SUBSTITUTE. In particular, the behavior of FROM-END is possibly different from other versions of this function; FROM-END values of NIL and T are equivalent unless COUNT is supplied. The second return value is an index suitable as an argument to SUBSEQ into the sequence indicating where processing stopped.

Package

rutils.sequence.

Source

sequence.lisp.

Function: split-sequence-if (predicate seq &key count remove-empty-subseqs from-end start end key)

Return a list of subsequences in SEQ delimited by items, satisfying PREDICATE.

If REMOVE-EMPTY-SUBSEQS is NIL, empty subsequences will be included in the result; otherwise they will be discarded. All other keywords work analogously to those for SUBSTITUTE. In particular, the behavior of FROM-END is possibly different from other versions of this function; FROM-END values of NIL
and T are equivalent unless COUNT is supplied. The second return value is an index suitable as an argument to SUBSEQ into the sequence indicating where processing stopped.

Package

rutils.sequence.

Source

sequence.lisp.

Function: split-sequence-if-not (predicate seq &key count remove-empty-subseqs from-end start end key)

Return a list of subsequences in SEQ delimited by items, satisfying (complement PREDICATE).

If REMOVE-EMPTY-SUBSEQS is NIL, empty subsequences will be included in the result; otherwise they will be discarded. All other keywords work analogously to those for SUBSTITUTE.
In particular, the behavior of FROM-END is possibly different from other versions of this function; FROM-END values of NIL and T are equivalent unless COUNT is supplied. The second return value is an index suitable as an argument to SUBSEQ into the sequence indicating where processing stopped.

Package

rutils.sequence.

Source

sequence.lisp.

Function: split-string (string)

Split STRING by WHITE-CHAR-P.

Package

rutils.string.

Source

string.lisp.

Function: starts-with (prefix string &key test start)

Test, whether STRING starts with PREFIX.
If START is provided matches from this offset from the start.

Package

rutils.string.

Source

string.lisp.

Function: strcat (&rest string-designators)

CONCATENATE all the strings in STRING-DESIGNATORS.

Package

rutils.string.

Source

string.lisp.

Function: strjoin (delim strings)

Join STRINGS with DELIM.

Package

rutils.string.

Source

string.lisp.

Function: sub (sequence start &optional end)

Return a copy of a subsequence of SEQUENCE starting with element number START and continuing to the end of SEQUENCE or the optional END.

Package

rutils.abbr.

Alias for

subseq.

Function: substr (string start &optional end)

Efficient substring of STRING from START to END (optional), where both can be negative, which means counting from the end.

Package

rutils.string.

Source

string.lisp.

Function: sum (fn seq &rest seqs)

Sum the results of mapping FN to SEQ and other SEQS.

Package

rutils.sequence.

Source

sequence.lisp.

Function: take (n list &optional step)

Return a list with N elements, which are taken from LIST by this formula: INDEX of ELEMENT = I * STEP for I from 0

Package

rutils.list.

Source

list.lisp.

Function: take# (key ht)

Get and remove VAL at KEY in hash-table HT.

Package

rutils.hash-table.

Alias for

takehash.

Function: takehash (key ht)

Get and remove VAL at KEY in hash-table HT.

Package

rutils.hash-table.

Source

hash-table.lisp.

Function: toggle-print-hash-table (&optional on)

Toggles printing hash-tables with PRINT-HASH-TABLE or with default method. If ON is set explicitly will turn on literal printing (T) or default (NIL).

Package

rutils.hash-table.

Source

hash-table.lisp.

Function: tree-depth (tree)

Returns the length of the largest of nodes from the root tree.

Package

rutils.tree.

Source

tree.lisp.

Function: tree-size (tree)

Returns the number of nodes (internal & external) in the indicated TREE.

Package

rutils.tree.

Source

tree.lisp.

Function: true (val)

The complement to NULL.
Unlike IDENTITY will return T if VAL is not NIL.

Package

rutils.misc.

Source

misc.lisp.

Function: tryadic (list)

Test wheather LIST contains exactly 3 elements.

Package

rutils.list.

Source

list.lisp.

Function: union# (set1 set2)

Set union between hash-sets SET1 & SET2.

Package

rutils.hash-set.

Source

hash-set.lisp.

Function: vec (&rest args)

Make a new adjustable vector with ARGS as contents.

Package

rutils.array.

Source

array.lisp.

Function: white-char-p (char)

Is CHAR a whitespace character (newline chars are also considered white).

Package

rutils.string.

Source

string.lisp.

Function: xor# (set1 set2)

Set xor between hash-sets SET1 & SET2.

Package

rutils.hash-set.

Source

hash-set.lisp.

Function: xor2 (x y)

XOR for 2 arguments as a function.

Package

rutils.misc.

Source

misc.lisp.

Function: zip (&rest lists)

Return a single list whose elements are lists of the consecutive elements of LISTS, until one of the LISTS ends.

Package

rutils.list.

Source

list.lisp.

Function: zip* (&rest lists)

Return a single list whose elements are lists of the consecutive elements of LISTS, until all of the LISTS end.

Package

rutils.list.

Source

list.lisp.

Function: zip*-with (fn &rest lists)

Return a single list whose elements are the results
of applying FN to groups of the consecutive elements of LISTS, until all of the LISTS end.

Package

rutils.list.

Source

list.lisp.

Function: zip-with (fn &rest lists)

Return a single list whose elements are the results
of applying FN to groups of the consecutive elements of LISTS, until one of the LISTS ends.

Package

rutils.list.

Source

list.lisp.


6.1.6 Generic functions

Generic Function: ? (obj key &rest keys)

Generic element access in OBJ by KEY. Supports chaining with KEYS.

Package

rutils.generic.

Alias for

generic-elt.

Generic Function: bind-dispatch (arg1 arg2 &rest args)
Package

rutils.bind.

Source

bind.lisp.

Methods
Method: bind-dispatch ((arg1 symbol) arg2 &rest args)
Method: bind-dispatch ((arg1 list) (arg2 (eql rutils.generic:?)) &rest args)
Method: bind-dispatch ((arg1 list) (arg2 (eql rutils.readtable::@)) &rest args)
Method: bind-dispatch ((arg1 list) arg2 &rest args)
Generic Function: copy (obj &rest kvs)

Create a shallow copy of an object.
If KVS are specified, they may be used to update the relevant parts (like slots of an object, keys in a hash-table
or indexed elements of a sequence).

Package

rutils.generic.

Source

generic.lisp.

Methods
Method: copy ((obj list) &rest kvs)
Method: copy ((obj sequence) &rest kvs)
Method: copy ((obj hash-table) &rest kvs)
Method: copy ((obj structure-object) &rest kvs)
Generic Function: eq-test (kv)

Return an equality test predicate of the KV.

Package

rutils.kv.

Source

kv.lisp.

Methods
Method: eq-test ((kv hash-table))
Method: eq-test ((list list))
Generic Function: generic-elt (obj key &rest keys)

Generic element access in OBJ by KEY. Supports chaining with KEYS.

Package

rutils.generic.

Source

generic.lisp.

Setf expander for this generic function

(setf generic-elt).

Methods
Method: generic-elt ((obj (eql nil)) key &rest keys)
Method: generic-elt ((obj standard-object) key &rest keys)
Method: generic-elt ((obj structure-object) key &rest keys)
Method: generic-elt ((obj hash-table) key &rest keys)
Method: generic-elt ((obj sequence) key &rest keys)
Method: generic-elt ((obj array) (key list) &rest keys)
Method: generic-elt ((obj vector) key &rest keys)
Method: generic-elt ((obj list) key &rest keys)
Method: generic-elt :around (obj key &rest keys)
Method: generic-elt (obj key &rest keys)
Generic Reader: generic-elt-error-key (condition)
Generic Writer: (setf generic-elt-error-key) (condition)
Package

rutils.generic.

Methods
Reader Method: generic-elt-error-key ((condition generic-elt-error))
Writer Method: (setf generic-elt-error-key) ((condition generic-elt-error))
Source

generic.lisp.

Target Slot

key.

Generic Reader: generic-elt-error-obj (condition)
Generic Writer: (setf generic-elt-error-obj) (condition)
Package

rutils.generic.

Methods
Reader Method: generic-elt-error-obj ((condition generic-elt-error))
Writer Method: (setf generic-elt-error-obj) ((condition generic-elt-error))
Source

generic.lisp.

Target Slot

obj.

Generic Function: keys (kv)

Return a list of all keys in a KV. Order is unspecified.

Package

rutils.kv.

Source

kv.lisp.

Methods
Method: keys ((kv hash-table))
Method: keys ((list list))
Generic Function: kvs (kv &optional result-kind)

Return a list of all key-value pairs in a KV in one the 3 kinds:

- list of pairs (default)
- alist
- dlist

Order is unspecified.

Package

rutils.kv.

Source

kv.lisp.

Methods
Method: kvs ((kv hash-table) &optional result-kind)
Generic Function: make (class &rest initargs &key &allow-other-keys)
Package

rutils.abbr.

Alias for

make-instance.

Generic Function: mapkv (fn kv)

Like MAPCAR but for a data structure that can be viewed as a KV.

Package

rutils.kv.

Source

kv.lisp.

Methods
Method: mapkv (fn (kv hash-table))
Method: mapkv (fn (list list))
Generic Function: pairs (table)

Return a list of all key-value PAIRS in a TABLE. Order is unspecified.

Package

rutils.pair.

Source

pair.lisp.

Methods
Method: pairs ((table hash-table))
Method: pairs ((list list))
Generic Function: smart-slot-value (obj slot)

Similar to SLOT-VALUE but tries to find slot definitions regardless of the package.

Package

rutils.generic.

Source

generic.lisp.

Setf expander for this generic function

(setf smart-slot-value).

Methods
Method: smart-slot-value (obj slot)
Generic Function: tally (obj)

Return the count of items in a collection or other compound object.

Package

rutils.generic.

Source

generic.lisp.

Methods
Method: tally ((obj sequence))
Method: tally ((obj hash-table))
Generic Function: vals (kv)

Return a list of all values in a KV. Order is unspecified.

Package

rutils.kv.

Source

kv.lisp.

Methods
Method: vals ((kv hash-table))
Method: vals ((list list))

6.1.7 Standalone methods

Method: print-object ((err generic-elt-error) stream)
Source

generic.lisp.


6.1.8 Conditions

Condition: case-failure
Package

rutils.misc.

Source

misc.lisp.

Direct superclasses
  • case-failure.
  • type-error.
Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

case-failure-name.

Writers

This slot is read-only.

Slot: possibilities
Initargs

:possibilities

Readers

case-failure-possibilities.

Writers

This slot is read-only.

Condition: generic-elt-error
Package

rutils.generic.

Source

generic.lisp.

Direct superclasses

condition.

Direct methods
Direct slots
Slot: obj
Initargs

:obj

Readers

generic-elt-error-obj.

Writers

(setf generic-elt-error-obj).

Slot: key
Initargs

:key

Readers

generic-elt-error-key.

Writers

(setf generic-elt-error-key).

Condition: rutils-style-warning
Package

rutils.symbol.

Source

symbol.lisp.

Direct superclasses
  • simple-condition.
  • style-warning.

Previous: , Up: Public Interface   [Contents][Index]

6.1.9 Types

Type: array-index (&optional length)

Type designator for an index into array of LENGTH: an integer between 0 (inclusive) and LENGTH (exclusive).
LENGTH defaults to ARRAY-DIMENSION-LIMIT.

Package

rutils.array.

Source

array.lisp.

Type: array-length (&optional length)

Type designator for a dimension of an array of LENGTH: an integer between 0 (inclusive) and LENGTH (inclusive).
LENGTH defaults to ARRAY-DIMENSION-LIMIT.

Package

rutils.array.

Source

array.lisp.

Type: string-designator ()

A string designator type. It is either a string, a symbol, or a character.

Package

rutils.string.

Source

string.lisp.


6.2 Internals


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

6.2.1 Special variables

Special Variable: *accum-var-alist*

This is how we get multiple accumulations into the same variable
to come out right. See MAKE-ACCUM-VAR-BINDING.
It’s an alist of (ACCUM-VAR KIND <possibly other info>).
The currently used kinds are:
* :collect - for collect, nconc, append, etc.
* :increment - for count, sum and multiply
* :max - for maximize
* :min - for minimize
* :if-exists - for always/never/thereis and finding such-that
Note that we do not check for type conflict in the re-use of these variables.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *all-packages*
Package

rutils.

Source

rutils.lisp.

Special Variable: *always-declare-variables*

Like (declare (declare-variables))

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *bind-ignores*

List of gensymed symbols that should be declared ignored for bind.

Package

rutils.bind.

Source

bind.lisp.

Special Variable: *bindings*

For the use of MAKE-BINDING-INTERNAL, to pass back bindings. (:IF FIRST-TIME) also uses it to create first-time variables.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *block-name*

Name of the block for this iterate /> form. Used in generating return statements

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *clause*

*CLAUSE*> is bound to each entire iterate clause before the clause is processed. Mostly for error output (see CLAUSE-ERROR class).

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *clause-info-index*

The index of standard clauses (a discrimination tree). This is a DEFVAR, so that reloading doesn’t clobber existing defs (though it will clobber those clauses, that are defined in this file).

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *declaration-context?*

*DECLARATION-CONTEXT?* is bound to T inside a form, that allows declarations, like (FLET, LABELS).

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *declarations*

For functions (like MAKE-BINDING), that don’t want to or can’t pass declarations normally. These are really decl-specs, not full declarations.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *declare-variables*

*DECLARE-VARIABLES* is bound to T if (declare (iterate:declare-variables)) was seen at top-level, or if *ALWAYS-DECLARE-VARIABLES* is non-nil.
This indicates, that variables, that haven’t been declared by the user should be declared to have the appropriate types. What ’appropriate’ means depends
on the context.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *decls*

Global collection of declaration forms.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *driver-info-alist*

List of info about drivers for use by the NEXT mechanism.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *env*

Environment, for MACROEXPAND.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *final*

Global collection of final forms.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *finalp*

Global collection of final forms, protected by UNWIND-PROTECT.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *genvar-counter*

Counter of GENVAR’s.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *initial*

Global collection of initial forms.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *internal-variables*

This is a list of lists, containing the variables, made by internal LETs or other binding forms. It is used to check for the error of having iterate try to bind one of these variables at top-level. E.g. this code is an error. CL-USER> (iter (:for i :from 1 :to 10)
(let ((a nil))
(:collect i :into a)))

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *list-end-test*

This is so the advanced user can choose how the end of a list
is checked for.
There are three choices for termination predicate in
FOR...ON and FOR...IN, differing in their behavior on lists with a non-nil cdr: * NULL: If lucky, will get an error when taking the cdr. Bad choice
* ATOM: Will terminate correctly with no error
* ENDP: Will give an appropriate error message

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *loop-body-wrappers*

Things that we should wrap the loop’s body in.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *loop-end*

A loop label.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *loop-end-used?*

Whether a label was used already (to avoid generating them)?
This is so we don’t get a warning from compilers that check for unused tags.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *loop-step*

A loop label.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *loop-step-used?*

Whether a label was used already (to avoid generating them)?
This is so we don’t get a warning from compilers that check for unused tags.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *loop-top*

A loop label.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *previous-vars-alist*

Used by PREVIOUS.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *result-var*

*RESULT-VAR* is bound to a gensym before the clauses of an iterate form are processed. In the generated code, the gensym is bound to NIL before any other bindings are performed. Clauses are free to generate code that sets the value of *RESULT-VAR*.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *shared-bindings-alist*

Shared variables created by MAKE-SHARED-BINDING.
It’s an alist of (NAME GENSYM-VAR <possibly other info>). Tipical use is FIRST-ITERATION-P.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *special-clause-alist*

Clauses, that are ’special’ in the sense, that they don’t conform to the keyword-argument syntax of Iterate clauses

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *special-form-alist*

An alist of lisp special forms and the functions for handling them. nil as function means leave form as-is

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *step*

Global collection of stepping forms.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *temps*

These two are for conserving temporaries. *TEMPS* is a list
of temporaries that have already been created and given bindings. *TEMPS-IN-USE* is a list of temporaries that are currently being used. See WITH-TEMPORARY, WITH-TEMPORARIES.
This seems to stem from a time where it was more efficient to use CL-USER> (progn (temp)
...
(setq temp #) ; somewhere deep inside the body (foo temp)
(bar temp)
...)
than using a local LET deep inside that body, as in
CL-USER> (tagbody ...
(let ((temp #))
(foo temp)
(bar temp))
...)
which may be easier for compiler data flow and lifetime analysis.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *temps-in-use*

These two are for conserving temporaries. *TEMPS* is a list
of temporaries that have already been created and given bindings. *TEMPS-IN-USE* is a list of temporaries that are currently being used. See WITH-TEMPORARY, WITH-TEMPORARIES.
This seems to stem from a time where it was more efficient to use CL-USER> (progn (temp)
...
(setq temp #) ; somewhere deep inside the body (foo temp)
(bar temp)
...)
than using a local LET deep inside that body, as in
CL-USER> (tagbody ...
(let ((temp #))
(foo temp)
(bar temp))
...)
which may be easier for compiler data flow and lifetime analysis.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *top-level?*

*TOP-LEVEL?* is bound to T at top-level (i.e. before any forms, that contain clauses inside them, like IF, LET etc.) and to NIL inside such forms. It is useful to ensure, that certain forms (particularly iteration drivers) occur only at top-level.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: *type-alist*

Iterate binds *TYPE-ALIST* to an alist of variables and
their types before processing clauses. It does this by looking at (declare (type ...)) forms in the clauses and recording
the information there. (Only variable type information, not function)

Package

rutils.iter.

Source

iter.lisp.

Special Variable: +fill-col+
Package

rutils.iter.

Source

iter.lisp.

Special Variable: +sequence-keyword-list+

Keywords, used in sequence iteration clauses.

Package

rutils.iter.

Source

iter.lisp.

Special Variable: +standard-type-symbols+

Table 4-1 of the Common Lisp Manual

Package

rutils.iter.

Source

iter.lisp.


6.2.2 Macros

Macro: adding-smart-slot-methods (obj slot expr)
Package

rutils.generic.

Source

generic.lisp.

Macro: augment (var stuff)

Add STUFF to the end of VAR list.

Package

rutils.iter.

Source

iter.lisp.

Macro: clause-for-in-package-13 (&key for in-package external-only generate)

ITER over symbols accessible in package PKG.

Package

rutils.iter.

Source

iter.lisp.

Macro: def-special-clause (name arglist &body body)

Define clause by DEFUN. Special-clause names should be exported.

Package

rutils.iter.

Source

iter.lisp.

Macro: defsynonym (symbol synonym)

Set SYNONYM for a SYMBOL.

Package

rutils.iter.

Source

iter.lisp.

Macro: prepend (stuff var)

Add STUFF to the beginning of VAR list.

Package

rutils.iter.

Source

iter.lisp.

Macro: return-driver-code (&key variable initial declarations body step final final-protected next)
Package

rutils.iter.

Source

iter.lisp.

Macro: return-sequence-code (&key element-var sequence access-fn size-fn element-type sequence-type)
Package

rutils.iter.

Source

iter.lisp.

Macro: trivial-positional-lambda (body)
Package

rutils.readtable.

Source

readtable.lisp.

Macro: with-temporary (var &body body)

Execute BODY iside the temporary binding of VAR to.

Package

rutils.iter.

Source

iter.lisp.


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

6.2.3 Ordinary functions

Function: ^-reader (stream char)

Literal syntax for zero/one/two argument lambdas.
Use % as the function’s argument, %% as the second.

Examples:

- ^(+ 2 %) => (lambda (&optional x y) (+ 2 x))
- ^((print %) (1+ %)) => (lambda (&optional x) (print x) (1+ x)) - ^(+ 1 2) => (lambda (&optional x y) (+ 1 2))
- ^(+ % %%) => (lambda (&optional x y) (+ x y))

Package

rutils.readtable.

Source

readtable.lisp.

Function: add-binding (var value)
Package

rutils.iter.

Source

iter.lisp.

Function: add-driver-info (var-template next-code generator?)
Package

rutils.iter.

Source

iter.lisp.

Function: add-internal-var (var)

Return a list of VAR, CONS’ed at the front to *INTERNAL-VARIABLES*.

Package

rutils.iter.

Source

iter.lisp.

Function: add-internal-vars (vars)

Return a list of VARS, NCONC’ed at the front to *INTERNAL-VARIABLES*. VARS can be a lambda-list, a list of LET bindings, or a list of variables.

Package

rutils.iter.

Source

iter.lisp.

Function: add-loop-body-wrapper (wrapper)

Ad a WRAPPER to *LOOP-BODY-WRAPPERS*, if it’s not already there.

Package

rutils.iter.

Source

iter.lisp.

Function: add-progn (forms)

When FORMS is more than one form, cons the PROGN in.

Package

rutils.iter.

Source

iter.lisp.

Function: after-each (&rest forms)

FORMS to execute after each iteration.

Package

rutils.iter.

Source

iter.lisp.

Function: ambiguity-check-clause (ci1 ci2 insert-n)
Package

rutils.iter.

Source

iter.lisp.

Function: ambiguity-check-index (ci1 index)

Check CI1 pair for being already present in the alist inside INDEX with the subset of required keywors.

Package

rutils.iter.

Source

iter.lisp.

Function: ambiguous-clauses? (ci1 ci2)

Test wheather required-keywords of CI1 are a prefix of required-keywords of CI2 (i.e. introduce ambiguity).

Package

rutils.iter.

Source

iter.lisp.

Function: apply-clause-function (func args)

Apply a function, defined for ITERATE clause FUNC to ARGS.

Package

rutils.iter.

Source

iter.lisp.

Function: apply-subst-expr (subst-expr args)
Package

rutils.iter.

Source

iter.lisp.

Function: arg-check (clause info)

Make sure that each keyword in ITERATE CLAUSE is in INFO.

Package

rutils.iter.

Source

iter.lisp.

Function: bug (format-string &rest args)

Signal an Iterate bug to *ERROR-OUTPUT*.

Package

rutils.iter.

Source

iter.lisp.

Function: build-index (keywords info)
Package

rutils.iter.

Source

iter.lisp.

Function: check-internal-variables (var)
Package

rutils.iter.

Source

iter.lisp.

Function: check-sequence-keywords (from upfrom downfrom to downto above below known-limits?)
Package

rutils.iter.

Source

iter.lisp.

Function: clause-accumulate-by-42 (&key accumulate by initial-value into)

Generalized accumulation.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-adjoin-37 (&key adjoin into at test result-type)

Adjoin into a list (tests for membership first).

Package

rutils.iter.

Source

iter.lisp.

Function: clause-always-30 (&key always)

Return last value, when EXPR is always non-NIL.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-append-39 (&key append into at)

APPEND into a list.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-collect-36 (&key collect into at result-type)

Collect into a list (with CONS).

Package

rutils.iter.

Source

iter.lisp.

Function: clause-count-22 (&key count into)

Increment VAR if EXPR is non-NIL.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-error (format-string &rest args)

ERROR of improper use of iterate.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-find-max-34 (&key find max into)

Return value, which maximizes EXPR.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-find-min-35 (&key find min into)

Return value, which minimizes EXPR.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-find-such-that-33 (&key find such-that into on-failure)

Return EXPR, when test is non-NIL.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-2 (&key for from upfrom downfrom to downto above below by with-index generate)

General FOR clause.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-=-20 (&key for =)

Set VAR on each iteration.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-do-next-17 (&key for do-next generate)

General driver; VAR must be set in DO-NEXT.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-first-then-21 (&key for first then)

Set VAR on first, and then on subsequent iterations.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-in-4 (&key for in by generate)

ITER over elements of LIST.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-in-file-14 (&key for in-file using generate)

ITER over forms from a file by FILENAME (which will be closed at the end).

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-in-hashtable-11 (&key for in-hashtable generate)

ITER over elements and keys of a hash-table TABLE.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-in-packages-12 (&key for in-packages having-access generate)

ITER over symbols and their access-types in packages PKGS.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-in-sequence-7 (&key for in-sequence from upfrom downfrom to downto above below by with-index generate)

ITER over elements of a sequence.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-in-stream-15 (&key for in-stream using generate)

ITER over forms from a STREAM (which will be closed at the end).

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-in-string-9 (&key for in-string from upfrom downfrom to downto above below by with-index generate)

ITER over characters of a string.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-in-vector-5 (&key for in-vector from upfrom downfrom to downto above below by with-index generate)

ITER over elements of a vector.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-index-of-sequence-8 (&key for index-of-sequence from upfrom downfrom to downto above below by with-index generate)

Indices of a sequence (vector or list).

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-index-of-string-10 (&key for index-of-string from upfrom downfrom to downto above below by with-index generate)

Indices of a string.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-index-of-vector-6 (&key for index-of-vector from upfrom downfrom to downto above below by with-index generate)

Indices of a vector.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-initially-then-19 (&key for initially then)

Set VAR initially, then on subsequent iterations.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-next-16 (&key for next generate)

General driver; VAR is set to value of NEXT.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-on-3 (&key for on by generate)

ITER over sublists of LIST.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-for-prev-43 (&key for prev initially back)

Previous value of a variable.

Package

rutils.iter.

Source

iter.lisp.

Reader: clause-info-doc-string (instance)
Writer: (setf clause-info-doc-string) (instance)
Package

rutils.iter.

Source

iter.lisp.

Target Slot

doc-string.

Reader: clause-info-function (instance)
Writer: (setf clause-info-function) (instance)
Package

rutils.iter.

Source

iter.lisp.

Target Slot

function.

Reader: clause-info-generator? (instance)
Writer: (setf clause-info-generator?) (instance)
Package

rutils.iter.

Source

iter.lisp.

Target Slot

generator?.

Reader: clause-info-keywords (instance)
Writer: (setf clause-info-keywords) (instance)
Package

rutils.iter.

Source

iter.lisp.

Target Slot

keywords.

Function: clause-info-p (object)
Package

rutils.iter.

Source

iter.lisp.

Reader: clause-info-req-keywords (instance)
Writer: (setf clause-info-req-keywords) (instance)
Package

rutils.iter.

Source

iter.lisp.

Target Slot

req-keywords.

Function: clause-matches? (clause-spec kws)

Test wheather CLAUSE-SPEC matches KWS. If no CLAUSE-SPEC is given, assume, that it matches.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-max-26 (&key max into)

Maximize value of an EXPR.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-min-27 (&key min into)

Minimize value of an EXPR.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-mult-24 (&key mult into)

Multiply into VAR.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-nconc-38 (&key nconc into at)

NCONC into a list.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-never-31 (&key never)

Return T, when expression is never non-NIL.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-nunion-41 (&key nunion into at test)

Union into a LIST, destructively.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-reduce-by-25 (&key reduce by initial-value into)

Generalized reduction.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-repeat-1 (&key repeat)

Repeat the loop N times.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-sum-23 (&key sum into)

Sum into VAR.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-there-is-32 (&key there-is)

Return value of EXPR, as soon as it is non-NIL.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-union-40 (&key union into at test)

Union into a LIST.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-until-29 (&key until)

Exit loop, when EXPR is non-NIL.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-warning (format-string &rest args)

WARN of some improper use of ITERATE.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-while-28 (&key while)

Exit loop, when EXPR is NIL.

Package

rutils.iter.

Source

iter.lisp.

Function: clause-with-18 (&key with =)

Bind VAR.

Package

rutils.iter.

Source

iter.lisp.

Function: constant? (x)

Test, wheather X is a constant.

This differs from CONSTANTP in that it doesn’t acknowledge DEFCONSTANTs to be constants; the problem with so acknowledging them is that the run-time and compile-time environments may differ. The things CONSTANT? returns for are really and truly constant everywhere.

Package

rutils.iter.

Source

iter.lisp.

Function: contains-duplicates? (lst)

Check, wheather LST contains duplicate symbols.

Package

rutils.iter.

Source

iter.lisp.

Function: copy-clause-info (instance)
Package

rutils.iter.

Source

iter.lisp.

Function: copy-driver-info (instance)
Package

rutils.iter.

Source

iter.lisp.

Function: copy-pair (sequence)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package

rutils.pair.

Alias for

copy-seq.

Function: copy-previous-info (instance)
Package

rutils.iter.

Source

iter.lisp.

Function: copy-save-info (instance)
Package

rutils.iter.

Source

iter.lisp.

Function: default-driver-code ()

Default code, that will be executed if no drivers are defined.

Package

rutils.iter.

Source

iter.lisp.

Function: define-clause (define-form clause-template body generator?)
Package

rutils.iter.

Source

iter.lisp.

Function: delete/swapped-arguments (sequence item &rest keyword-arguments)
Package

rutils.sequence.

Source

sequence.lisp.

Function: disp-std-clauses (clause-spec index)

Display standard (i.e. defined in ITER) clauses.

Package

rutils.iter.

Source

iter.lisp.

Function: display-clause (kws docstring)

Display a single ITERATE clause with a DOCSTRING, which accepts keywords KWS.

Package

rutils.iter.

Source

iter.lisp.

Function: display-index (&optional index indent)
Package

rutils.iter.

Source

iter.lisp.

Function: display-kws (kws)

Display ITERATE clause keywords KWS.

Package

rutils.iter.

Source

iter.lisp.

Function: do-destructuring-bindings (template value)

Examine TEMPLATE and if it’s a proper VAR-SPEC?, bind its var to VALUE.

Package

rutils.iter.

Source

iter.lisp.

Function: do-dsetq (template value &optional bindings? type)
Package

rutils.iter.

Source

iter.lisp.

Function: do-extra-save-var-hack (var save-info-list code-list)

The name speaks for itself.

Package

rutils.iter.

Source

iter.lisp.

Reader: driver-info-generator? (instance)
Writer: (setf driver-info-generator?) (instance)
Package

rutils.iter.

Source

iter.lisp.

Target Slot

generator?.

Reader: driver-info-next-code (instance)
Writer: (setf driver-info-next-code) (instance)
Package

rutils.iter.

Source

iter.lisp.

Target Slot

next-code.

Function: driver-info-p (object)
Package

rutils.iter.

Source

iter.lisp.

Reader: driver-info-used (instance)
Writer: (setf driver-info-used) (instance)
Package

rutils.iter.

Source

iter.lisp.

Target Slot

used.

Function: dsetq-error (format-string &rest args)

Signal an ERROR in DSETQ.

Package

rutils.iter.

Source

iter.lisp.

Function: duplicable? (x)

Return T if X can be copied in code. This is true for symbols,
on the assumption that the copies are close enough to each other so that updating the variable cannot occur.

Package

rutils.iter.

Source

iter.lisp.

Function: else (&rest forms)

FORMS to execute if the loop is never entered.

Package

rutils.iter.

Source

iter.lisp.

Function: eval-const-expr (expr)
Package

rutils.iter.

Source

iter.lisp.

Function: expand-binding (binding form)
Package

rutils.bind.

Source

bind.lisp.

Function: expand-destructuring-case (key clauses case)
Package

rutils.misc.

Source

misc.lisp.

Function: expand-predicate-case (pred keyform clauses case)
Package

rutils.misc.

Source

misc.lisp.

Function: expr-type-only (expr)
Package

rutils.iter.

Source

iter.lisp.

Function: expression-type (form)
Package

rutils.iter.

Source

iter.lisp.

Function: extract-function-name (spec)

Useful for macros that want to mimic the functional interface for functions like #’eq and ’eq.

Package

rutils.misc.

Source

misc.lisp.

Function: extract-var (var-spec)

Extract variable from THE-declaration or return as is.

Package

rutils.iter.

Source

iter.lisp.

Function: extract-vars (template)

Like EXTRACT-VAR, but will work with a destructuring template as well. Returns a list of variables.

Package

rutils.iter.

Source

iter.lisp.

Function: finally (&rest forms)

FORMS to execute after loop ends.

Package

rutils.iter.

Source

iter.lisp.

Function: finally-protected (&rest forms)

FORMS to execute in an UNWIND-PROTECT after loop ends.

Package

rutils.iter.

Source

iter.lisp.

Function: finish ()

Exit the loop gracefully, executing the epilogue.

Package

rutils.iter.

Source

iter.lisp.

Function: first-iteration-p ()

Return T in the first iteration of the loop.

Package

rutils.iter.

Source

iter.lisp.

Function: first-time-p ()

Return T for the first time it is evaluated.

Package

rutils.iter.

Source

iter.lisp.

Function: free-variables (form)
Package

rutils.iter.

Source

iter.lisp.

Function: free-vars (form bound-vars)
Package

rutils.iter.

Source

iter.lisp.

Function: free-vars-fspec (fspec bound-vars)

FSPEC is either:
* a symbol
* or (SETF <symbol>)
* or (<name-or-lambda> (<vars>) . body)

Package

rutils.iter.

Source

iter.lisp.

Function: free-vars-list (list bound-vars)
Package

rutils.iter.

Source

iter.lisp.

Function: function-quoted? (x)

Test, wheather X is of the form (FUNCTION ...) - same as #’(...).

Package

rutils.iter.

Source

iter.lisp.

Function: generate-function-step-code (var step)
Package

rutils.iter.

Source

iter.lisp.

Function: generate-switch-body (whole object clauses test key &optional default)
Package

rutils.misc.

Source

misc.lisp.

Function: genvar (&optional string)

A cross between GENSYM and GENTEMP.

Package

rutils.iter.

Source

iter.lisp.

Function: get-clause-info (clause &optional index)

Get ITERATE CLAUSE info from the INDEX.

Package

rutils.iter.

Source

iter.lisp.

Function: if-1st-time (then &optional else first-time-var)

Return:
1. a form, which evaluates THEN the first time through the loop, ELSE – the subsequent times
2. the variable, which may be passed with FIRST-TIME-VAR, that keeps track of first time

Package

rutils.iter.

Source

iter.lisp.

Function: in (block-name &rest forms)

Process FORMS in an ITER block with BLOCK-NAME.

Package

rutils.iter.

Source

iter.lisp.

Function: index-add (key thing index)

Add THING, qualified by KEY to the alits inside INDEX.

Package

rutils.iter.

Source

iter.lisp.

Function: index-lookup (item index)

Search for ITEM in the alist inside INDEX.

Package

rutils.iter.

Source

iter.lisp.

Function: index? (x)

Simple test wheather X is an index list (i.e. starts with :INDEX).

Package

rutils.iter.

Source

iter.lisp.

Function: initially (&rest forms)

FORMS to execute before loop starts.

Package

rutils.iter.

Source

iter.lisp.

Function: insert-previous-code ()

For each variable that requires a previous value, get all the update code for that variable and splice in code that will remember the previous values for the desired number of iterations. Return code to put in the init and step sections of the loop.

There are three situations here:
1. Variable has its initial value at the beginning of the loop, or gets its initial value in a different place than where it is updated. In this case, we can put the save code just before each update of the variable. Applicable clauses are: :FOR-PREVIOUS, :FOR-INITIALLY-THEN, and :FOR-FIRST-THEN. (class :INITIAL)
2. The variable is updated somewhere inside the loop, and the update also gives it its first value. We use another, internal save variable, which is set to the variable after each update. This is for :FOR-:= and driver clauses when :NEXT is used.(class :NEXT)
3. Variable is a driver with no :NEXT. We can put the update in the step portion of the loop, since we know the update code occurs at the beginning. (class :STEP)

Note that (3) is really an optimization of (2), and we could perform such an optimization more generally if we could show that a variable in class (2) was always updated before being used. Right now, we don’t bother. *** (3) is no longer done because driver code stays where the driver is. We could try to detect that the driver is at the beginning, but don’t for now.

Package

rutils.iter.

Source

iter.lisp.

Function: install-clause-info (req-keywords keywords function doc-string generator?)
Package

rutils.iter.

Source

iter.lisp.

Function: install-clause-info-1 (keywords index info)
Package

rutils.iter.

Source

iter.lisp.

Function: install-special-clause-function (symbol &optional docstring)

Put the SYMBOL with DOCSTRING at the end of *SPECIAL-CLAUSE-ALIST*, if not already present.

Package

rutils.iter.

Source

iter.lisp.

Function: intern-previous-info (var)

If VAR already has a previous-info structure, return it;
else create a new one, put it where it belongs, and return it. Make sure that if VAR is itself a save-var, the new record
goes after the one for VAR’s var, so that the previous code
is generated before it is itself considered update code for another previous splicing.

Package

rutils.iter.

Source

iter.lisp.

Function: internal-variable? (var)

Test, if VAR is present in *INTERNAL-VARIABLES*.

Package

rutils.iter.

Source

iter.lisp.

Function: is-iter-clause? (form)

Test wheather a CAR of FORM is defined as ITERATE clause.

Package

rutils.iter.

Source

iter.lisp.

Function: is-save-var (var entry)
Package

rutils.iter.

Source

iter.lisp.

Function: lambda-expression? (x)

Test, wheather X is a lambda-expression.

Package

rutils.iter.

Source

iter.lisp.

Function: lambda-list-vars (lambda-list)

Return the variables in the LAMBDA-LIST, omitting keywords, default and values.

Package

rutils.iter.

Source

iter.lisp.

Function: leave (&optional expr)

Exit the loop without running the epilogue code.

Package

rutils.iter.

Source

iter.lisp.

Function: list-of-forms? (x)
Package

rutils.iter.

Source

iter.lisp.

Function: local-binding-check (form)
Package

rutils.iter.

Source

iter.lisp.

Function: make-accum-var-binding (var value kind &key type using-type-of)
Package

rutils.iter.

Source

iter.lisp.

Function: make-accum-var-binding-internal (var value value-supplied? kind type using-type-of)
Package

rutils.iter.

Source

iter.lisp.

Function: make-accum-var-default-binding (var kind &key type using-type-of)
Package

rutils.iter.

Source

iter.lisp.

Function: make-application (fn &rest args)
Package

rutils.iter.

Source

iter.lisp.

Function: make-binding (var value &key type using-type-of)
Package

rutils.iter.

Source

iter.lisp.

Function: make-binding-internal (var-spec value value-supplied? use-type using-type-of)
Package

rutils.iter.

Source

iter.lisp.

Function: make-clause-info (&key function keywords req-keywords doc-string generator?)
Package

rutils.iter.

Source

iter.lisp.

Function: make-default-binding (var &key type using-type-of)
Package

rutils.iter.

Source

iter.lisp.

Function: make-destructuring-bindings (template value &key type using-type-of)
Package

rutils.iter.

Source

iter.lisp.

Function: make-driver-info (&key next-code generator? used)
Package

rutils.iter.

Source

iter.lisp.

Function: make-dsetqs (template value bindings?)
Package

rutils.iter.

Source

iter.lisp.

Function: make-funcall (fn &rest args)
Package

rutils.iter.

Source

iter.lisp.

Function: make-function-name (req-syms)

From a list of clause symbols REQ-SYMS make a unique symbol.

Package

rutils.iter.

Source

iter.lisp.

Function: make-initial-value (value value-supplied? type)
Package

rutils.iter.

Source

iter.lisp.

Function: make-mv-dsetqs (templates value bindings?)
Package

rutils.iter.

Source

iter.lisp.

Function: make-next-code (var code n)

Construct the body for NEXT carefully (avoid backquote), ensuring that CODE, and not a copy, appears in it.

Package

rutils.iter.

Source

iter.lisp.

Function: make-post-save-var (var)
Package

rutils.iter.

Source

iter.lisp.

Function: make-prev-code (set-var s-i &optional class)

Generate code fro the PREVIOUS mechanism.

Package

rutils.iter.

Source

iter.lisp.

Function: make-previous-info (&key var save-info-list code class)
Package

rutils.iter.

Source

iter.lisp.

Function: make-save-info (&key save-var save-vars iv-ref)
Package

rutils.iter.

Source

iter.lisp.

Function: make-save-previous-code (var save-vars)
Package

rutils.iter.

Source

iter.lisp.

Function: make-save-vars (var n)
Package

rutils.iter.

Source

iter.lisp.

Function: make-shared-binding (var value &key type using-type-of)

Look up in *SHARED-BINDINGS-ALIST* or create an entry, keyed by VAR, store GENSYM in the VALUE and also add it as a binding. Return the entry.

Package

rutils.iter.

Source

iter.lisp.

Function: make-var-and-binding (string value &key type using-type-of)

Make a binding for a newly GENVAR’ed variable, denoted by STRING, to the given VALUE. Possibly account for it’s TYPE.

Package

rutils.iter.

Source

iter.lisp.

Function: make-var-and-default-binding (string &key type using-type-of)
Package

rutils.iter.

Source

iter.lisp.

Function: next (var &optional n)

Explicitly step a driver VAR N times. Return VAR, after stepping.

Enclose the returned code in a PROGN, so that the variable reference isn’t confusable with a tag (since the code might appear within a TAGBODY). The PROGN is also necessary, so that spliced-in save code will not result in extra forms, for cases when the NEXT appears as an argument.

Package

rutils.iter.

Source

iter.lisp.

Function: next-iteration ()

Begin the next iteration.

Package

rutils.iter.

Source

iter.lisp.

Function: pair-right (structure)
Package

rutils.pair.

Source

pair.lisp.

Function: (setf pair-right) (structure)
Package

rutils.pair.

Source

pair.lisp.

Function: preprocess-clause (clause)

Preprocess ITERATE CLAUSE.

Package

rutils.iter.

Source

iter.lisp.

Reader: previous-info-class (instance)
Writer: (setf previous-info-class) (instance)
Package

rutils.iter.

Source

iter.lisp.

Target Slot

class.

Reader: previous-info-code (instance)
Writer: (setf previous-info-code) (instance)
Package

rutils.iter.

Source

iter.lisp.

Target Slot

code.

Function: previous-info-p (object)
Package

rutils.iter.

Source

iter.lisp.

Reader: previous-info-save-info-list (instance)
Writer: (setf previous-info-save-info-list) (instance)
Package

rutils.iter.

Source

iter.lisp.

Target Slot

save-info-list.

Reader: previous-info-var (instance)
Writer: (setf previous-info-var) (instance)
Package

rutils.iter.

Source

iter.lisp.

Target Slot

var.

Function: process-clause (clause)

Process ITERATE CLAUSE according to the rules, defined for it.
This should observe the invariant, that the forms it returns are already copied from the original code, hence NCONC-able.

Package

rutils.iter.

Source

iter.lisp.

Function: process-top-level-decls (clauses)

Process top-level declarations, present among CLAUSES.
Sets *TYPE-ALIST* to an alist of (var . type), and sets *DECLARE-VARIABLES* /> to T, when such a declaration was seen.

Package

rutils.iter.

Source

iter.lisp.

Function: progn-wrap (forms)

Transform forms, if more than one is present, and the first is a list: wrap PROGN around. Not copying forms.

Package

rutils.iter.

Source

iter.lisp.

Function: quoted? (x)

Test, wheather X is of the form (QUOTE ...).

Package

rutils.iter.

Source

iter.lisp.

Function: register-previous-code (vars code class)
Package

rutils.iter.

Source

iter.lisp.

Function: remove-clause (clause-keywords)

Remove clause from the index. It is identified by CLAUSE-KEYWORDS, which is a list with its symbols keywordized.

Package

rutils.iter.

Source

iter.lisp.

Function: remove/swapped-arguments (sequence item &rest keyword-arguments)
Package

rutils.sequence.

Source

sequence.lisp.

Function: return-code (&key declarations initial body step final final-protected)
Package

rutils.iter.

Source

iter.lisp.

Function: return-code-modifying-body (f stuff mod-f)

Call F with STUFF and return the regular 6 values (see WALK) with 1st return value being the result of application of MOD-F to body, returned by F.

Package

rutils.iter.

Source

iter.lisp.

Function: return-collection-code (&key variable expression start-operation end-operation one-element test place result-type)
Package

rutils.iter.

Source

iter.lisp.

Function: return-extremum-code (expr var-spec operation)
Package

rutils.iter.

Source

iter.lisp.

Function: return-find-extremum-code (expr m-expr var kind)
Package

rutils.iter.

Source

iter.lisp.

Function: return-reduction-code (&key identity operation external-op? variable expression test type using-type-of accum-kind)
Package

rutils.iter.

Source

iter.lisp.

Function: return-seq-code (&key element-var sequence access-fn size-fn element-type sequence-type from upfrom to downto above below downfrom with-index by generate)
Package

rutils.iter.

Source

iter.lisp.

Function: return-stream-driver-code (var thing reader stream-or-file generate)
Package

rutils.iter.

Source

iter.lisp.

Function: rotate-head-to-tail (sequence n)
Package

rutils.sequence.

Source

sequence.lisp.

Function: rotate-tail-to-head (sequence n)
Package

rutils.sequence.

Source

sequence.lisp.

Reader: save-info-iv-ref (instance)
Writer: (setf save-info-iv-ref) (instance)
Package

rutils.iter.

Source

iter.lisp.

Target Slot

iv-ref.

Function: save-info-p (object)
Package

rutils.iter.

Source

iter.lisp.

Reader: save-info-save-var (instance)
Writer: (setf save-info-save-var) (instance)
Package

rutils.iter.

Source

iter.lisp.

Target Slot

save-var.

Reader: save-info-save-vars (instance)
Writer: (setf save-info-save-vars) (instance)
Package

rutils.iter.

Source

iter.lisp.

Target Slot

save-vars.

Function: self-evaluating? (x)

Test, wheather X is a self-evaluating entity.

Everything but symbols and lists are self-evaluating since CLtL2. This differs from CONSTANTP in that it returns nil for quoted things and DEFCONSTANT’s.

Package

rutils.iter.

Source

iter.lisp.

Function: special-form? (symbol)

Check, that SYMBOL is present in *SPECIAL-FORM-ALIST*.
Used instead of SPECIAL-OPERATOR-P, which doesn’t work properly in some compilers (like Lucid). Besides, to track Iterate special clauses.

Package

rutils.iter.

Source

iter.lisp.

Function: splice-in-code (prev-code post-code code-list)

Put PREV-CODE in at the first cons cell of CODE, and POST-CODE at the last cons cell. Both PREV-CODE and POST-CODE are single forms.

Package

rutils.iter.

Source

iter.lisp.

Function: split-clause-template (ct)

Split CT into required keywords, optional keywords and values.

Package

rutils.iter.

Source

iter.lisp.

Function: split-list-odd-even (lst)

Split LST into odd- and even-numbered elements, returned with VALUES.

Package

rutils.iter.

Source

iter.lisp.

Function: starts-clause? (symbol)

Tests wheather SYMBOL is defined as an ITERATE clause starting symbol.

A symbol starts a clause, when it appears in the top-level index *CLAUSE-INFO-INDEX*, in the *SPECIAL-CLAUSE-ALIST*, or it is GENERATE.
This is used to distinguish the case when there’s a lisp form (in which case the symbol doesn’t start a clause), versus the situation, when an erroneous clause is provided.

Package

rutils.iter.

Source

iter.lisp.

Function: subst-ignore (arg)
Package

rutils.bind.

Source

bind.lisp.

Function: synonym (symbol)

Get SYNONYM for a SYMBOL. When there’s no SYNONYM, return the SYMBOL itself.

Package

rutils.iter.

Source

iter.lisp.

Function: terminate ()

Use within FOR...DO-/NEXT to end the iteration.

Package

rutils.iter.

Source

iter.lisp.

Function: the-expression? (x)

Test, wheather X is a THE-expression.

Package

rutils.iter.

Source

iter.lisp.

Function: top-level-check ()

Check for being at *TOP-LEVEL?* and signal CLAUSE-ERROR otherwise.

Package

rutils.iter.

Source

iter.lisp.

Function: var-binding? (var)

Test, if VAR is present in *BINDINGS*.

Package

rutils.iter.

Source

iter.lisp.

Function: var-declaration (var)

Return the declaration, associated with VAR.

Package

rutils.iter.

Source

iter.lisp.

Function: var-spec? (x)

Test, if X is a proper specifivation of a variable: a symbol or a THE-declaration.

Package

rutils.iter.

Source

iter.lisp.

Function: var-type (var)

Return type of VAR, which can be given as THE-declaration or as symbol.

Package

rutils.iter.

Source

iter.lisp.

Function: var-value-returned (forms)
Package

rutils.iter.

Source

iter.lisp.

Function: walk (form)

Walk the FORM and return the usual 6 things as multiple-values: * body
* type declarations
* initializations code
* stepping code
* final code
* final protected (by UNWIND-PROTECT)

Package

rutils.iter.

Source

iter.lisp.

Function: walk-arglist (args)

Walk ARGS list, possibly containing ITERATE clauses.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-cddr (first second &rest stuff)

Don’t walk the CAR and CADR of a list. CDDR might not be walked as well.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-cddr-with-declarations (first second &rest stuff)

a.k.a. walk-locally
Walk CDDR, ignoring declarations, that might be present in it.
Set *TOP-LEVEL?* to NIL (via WALK-ARGLIST). Note that when *TOP-LEVEL?* is NIL walk won’t yield declarations, because WALK-DECLARE errors out since all forms with *DECLARATION-CONTEXT?* T keep them local (that is, in WALK-LET, WALK-FLET and WALK-MULTIPLE-VALUE-BIND b-decls/edecls are always NIL.)

Package

rutils.iter.

Source

iter.lisp.

Function: walk-cdr (first &rest stuff)

Don’t walk the CAR of a list. CDR might not be walked as well.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-cdr-with-declarations (first &rest stuff)

a.k.a. walk-locally
Walk CDR, ignoring declarations, that might be present in it.
Set *TOP-LEVEL?* to NIL (via WALK-ARGLIST). Note that when *TOP-LEVEL?* is NIL walk won’t yield declarations, because WALK-DECLARE errors out since all forms with *DECLARATION-CONTEXT?* T keep them local (that is, in WALK-LET, WALK-FLET and WALK-MULTIPLE-VALUE-BIND b-decls/edecls are always NIL.)

Package

rutils.iter.

Source

iter.lisp.

Function: walk-declare (&rest declaration)

Walk DECLARATION. Declarations should be put in the declaration section
of the loop. They are only allowed at top-level, except that they are allowed within binding environments, in which case they apply only to that binding environment.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-expr (expr)

Walk EXPR and return just the PROGN-WRAP’ped body.
Other returned by walking values are AUGMENT’ed to globals and returned by PROCESS-CLAUSE in the end of processing it.

This isn’t used by the code walker itself, but is useful for clauses, that need to walk parts of themselves.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-flet (flet bindings &rest body)

Walk FLET or LABELS declarations. We don’t worry about the function bindings.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-fspec (form)

Walk lambdas’ and functions’ specs in FLET and LABELS.
FORM is (lambda-or-name args . body).
Only walk at the body. The args are set up as internal variables. Declarations are kept internal to the body.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-function (function form)

Walk FUNCTION specification.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-let (let-key bindings &rest body)

Walk LET-form, with BINDINGS and BODY, which may contain ITERATE clauses. The declarations go inside this let, not to the top-level. It is an error to use a variable in the LET-bindings as the target of accumulation (i.e. INTO), because ITERATE will try to make a top-level binding for that variable.
The same goes for other variables, that might be so bound.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-let*-bindings (bindings)

Walk BINDINGS for LET* one at a time, to get the variable scoping right.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-let-binding (binding)

Walk a simgle BINDING for LET or LET*.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-let-bindings (let-key bindings)

Walk BINDINGS, established by LET or LET*.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-list (forms)

Walk FORMS, as a simple list.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-list-nconcing (lst walk-fn &optional body-during)

Lowest-level walking function for lists. Applies WALK-FN to LST. Applies BODY-DURING to the body part, returned by WALK-FN.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-macrolet (form-name &rest stuff)

MACROLET is not supported inside ITER. Signal an error.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-multiple-value-bind (mvb vars expr &rest body)

Walk BINDINGS for MULTIPLE-VALUE-BIND. Declarations go inside the MULTIPLE-VALUE-BIND form, not to the top-level. See WALK-LET for binding subtleties.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-progn (progn &rest stuff)

Don’t walk the CAR of a list. CDR might not be walked as well, though.
The only difference between this and WALK-CDR is that *TOP-LEVEL* isn’t bound. This is so macros can return PROGNs of things.
It’s exactly like the definition of ’top-level’ in lisp.
(Also, just for looks, this returns NIL if the PROGN is empty.)

Package

rutils.iter.

Source

iter.lisp.

Function: walk-setq (setq &rest things)

Walk every thing in THINGS.

Package

rutils.iter.

Source

iter.lisp.

Function: walk-special-form (form)

Walk a special form, defined in *SPECIAL-FORM-ALIST*.

Package

rutils.iter.

Source

iter.lisp.

Function: wrap-form (wrappers form)

Wrap FORM with WRAPPERS, that should be given as a list.

Package

rutils.iter.

Source

iter.lisp.


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

6.2.4 Generic functions

Generic Reader: case-failure-name (condition)
Package

rutils.misc.

Methods
Reader Method: case-failure-name ((condition case-failure))
Source

misc.lisp.

Target Slot

name.

Generic Reader: case-failure-possibilities (condition)
Package

rutils.misc.

Methods
Reader Method: case-failure-possibilities ((condition case-failure))
Source

misc.lisp.

Target Slot

possibilities.

Generic Function: generic-setf (obj key &rest keys-and-val)

Generic element access in OBJ by KEY. Supports chaining with KEYS.

Package

rutils.generic.

Source

generic.lisp.

Setf expanders to this generic function
Methods
Method: generic-setf ((obj standard-object) key &rest keys-and-val)
Method: generic-setf ((obj structure-object) key &rest keys-and-val)
Method: generic-setf ((obj hash-table) key &rest keys-and-val)
Method: generic-setf ((obj sequence) key &rest keys-and-val)
Method: generic-setf ((obj vector) key &rest keys-and-val)
Method: generic-setf ((obj list) key &rest keys-and-val)
Method: generic-setf ((obj (eql nil)) key &rest keys)
Method: generic-setf :around (obj key &rest keys-and-val)
Generic Function: smart-set-slot-value (obj slot val)

Similar to (SETF SLOT-VALUE) but tries to find slot definitions regardless of the package.

Package

rutils.generic.

Source

generic.lisp.

Setf expanders to this generic function

(setf smart-slot-value).

Methods
Method: smart-set-slot-value (obj slot val)

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

6.2.5 Structures

Structure: clause-info

Clause-info structures, which are put in the clause index.

Package

rutils.iter.

Source

iter.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: function
Package

common-lisp.

Readers

clause-info-function.

Writers

(setf clause-info-function).

Slot: keywords
Readers

clause-info-keywords.

Writers

(setf clause-info-keywords).

Slot: req-keywords
Readers

clause-info-req-keywords.

Writers

(setf clause-info-req-keywords).

Slot: doc-string
Readers

clause-info-doc-string.

Writers

(setf clause-info-doc-string).

Slot: generator?
Readers

clause-info-generator?.

Writers

(setf clause-info-generator?).

Structure: driver-info

Driver-info structures, used by NEXT.

Package

rutils.iter.

Source

iter.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: next-code
Readers

driver-info-next-code.

Writers

(setf driver-info-next-code).

Slot: generator?
Readers

driver-info-generator?.

Writers

(setf driver-info-generator?).

Slot: used
Readers

driver-info-used.

Writers

(setf driver-info-used).

Structure: previous-info

Info structure, used by PREVIOUS.

Package

rutils.iter.

Source

iter.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: var
Readers

previous-info-var.

Writers

(setf previous-info-var).

Slot: save-info-list
Readers

previous-info-save-info-list.

Writers

(setf previous-info-save-info-list).

Slot: code
Readers

previous-info-code.

Writers

(setf previous-info-code).

Slot: class
Package

common-lisp.

Initform

:step

Readers

previous-info-class.

Writers

(setf previous-info-class).

Structure: save-info

Info structure, used by the PREVIOUS.

Package

rutils.iter.

Source

iter.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: save-var
Readers

save-info-save-var.

Writers

(setf save-info-save-var).

Slot: save-vars
Readers

save-info-save-vars.

Writers

(setf save-info-save-vars).

Slot: iv-ref
Readers

save-info-iv-ref.

Writers

(setf save-info-iv-ref).


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   #   (   -   2   <   =   ?   @   ^  
A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Z  
Index Entry  Section

#
#/-reader: Public ordinary functions
#h-reader: Public ordinary functions
#v-reader: Public ordinary functions
#`-reader: Public ordinary functions
#{-reader: Public ordinary functions

(
(setf ?): Public setf expanders
(setf clause-info-doc-string): Private ordinary functions
(setf clause-info-function): Private ordinary functions
(setf clause-info-generator?): Private ordinary functions
(setf clause-info-keywords): Private ordinary functions
(setf clause-info-req-keywords): Private ordinary functions
(setf driver-info-generator?): Private ordinary functions
(setf driver-info-next-code): Private ordinary functions
(setf driver-info-used): Private ordinary functions
(setf generic-elt): Public setf expanders
(setf generic-elt-error-key): Public generic functions
(setf generic-elt-error-key): Public generic functions
(setf generic-elt-error-obj): Public generic functions
(setf generic-elt-error-obj): Public generic functions
(setf get#): Public setf expanders
(setf last-elt): Public ordinary functions
(setf last1): Public ordinary functions
(setf pair-left): Public ordinary functions
(setf pair-right): Private ordinary functions
(setf previous-info-class): Private ordinary functions
(setf previous-info-code): Private ordinary functions
(setf previous-info-save-info-list): Private ordinary functions
(setf previous-info-var): Private ordinary functions
(setf save-info-iv-ref): Private ordinary functions
(setf save-info-save-var): Private ordinary functions
(setf save-info-save-vars): Private ordinary functions
(setf smart-slot-value): Public setf expanders

-
->: Public macros
->>: Public macros

2
2nd: Public macros

<
<-: Public macros

=
=>: Public macros

?
?: Public generic functions

@
@-reader: Public ordinary functions

^
^-reader: Private ordinary functions

A
aand: Public macros
abbr: Public macros
acond: Public macros
add#: Public ordinary functions
add-binding: Private ordinary functions
add-driver-info: Private ordinary functions
add-internal-var: Private ordinary functions
add-internal-vars: Private ordinary functions
add-loop-body-wrapper: Private ordinary functions
add-progn: Private ordinary functions
adding-smart-slot-methods: Private macros
adowhile: Public macros
after-each: Private ordinary functions
aif: Public macros
alist->ht: Public ordinary functions
alist-to-plist: Public ordinary functions
alistp: Public ordinary functions
ambiguity-check-clause: Private ordinary functions
ambiguity-check-index: Private ordinary functions
ambiguous-clauses?: Private ordinary functions
and-bind: Public macros
and-it: Public macros
and-let: Public macros
and2: Public ordinary functions
appendf: Public macros
apply-clause-function: Private ordinary functions
apply-subst-expr: Private ordinary functions
arg-check: Private ordinary functions
assoc1: Public ordinary functions
atomize: Public ordinary functions
augment: Private macros
awhen: Public macros

B
bind: Public macros
bind-dispatch: Public generic functions
bind-dispatch: Public generic functions
bind-dispatch: Public generic functions
bind-dispatch: Public generic functions
bind-dispatch: Public generic functions
blankp: Public ordinary functions
bug: Private ordinary functions
build-index: Private ordinary functions
butlast2: Public ordinary functions

C
call: Public ordinary functions
case-failure-name: Private generic functions
case-failure-name: Private generic functions
case-failure-possibilities: Private generic functions
case-failure-possibilities: Private generic functions
check-internal-variables: Private ordinary functions
check-sequence-keywords: Private ordinary functions
clause-accumulate-by-42: Private ordinary functions
clause-adjoin-37: Private ordinary functions
clause-always-30: Private ordinary functions
clause-append-39: Private ordinary functions
clause-collect-36: Private ordinary functions
clause-count-22: Private ordinary functions
clause-error: Private ordinary functions
clause-find-max-34: Private ordinary functions
clause-find-min-35: Private ordinary functions
clause-find-such-that-33: Private ordinary functions
clause-for-2: Private ordinary functions
clause-for-=-20: Private ordinary functions
clause-for-do-next-17: Private ordinary functions
clause-for-first-then-21: Private ordinary functions
clause-for-in-4: Private ordinary functions
clause-for-in-file-14: Private ordinary functions
clause-for-in-hashtable-11: Private ordinary functions
clause-for-in-package-13: Private macros
clause-for-in-packages-12: Private ordinary functions
clause-for-in-sequence-7: Private ordinary functions
clause-for-in-stream-15: Private ordinary functions
clause-for-in-string-9: Private ordinary functions
clause-for-in-vector-5: Private ordinary functions
clause-for-index-of-sequence-8: Private ordinary functions
clause-for-index-of-string-10: Private ordinary functions
clause-for-index-of-vector-6: Private ordinary functions
clause-for-initially-then-19: Private ordinary functions
clause-for-next-16: Private ordinary functions
clause-for-on-3: Private ordinary functions
clause-for-prev-43: Private ordinary functions
clause-info-doc-string: Private ordinary functions
clause-info-function: Private ordinary functions
clause-info-generator?: Private ordinary functions
clause-info-keywords: Private ordinary functions
clause-info-p: Private ordinary functions
clause-info-req-keywords: Private ordinary functions
clause-matches?: Private ordinary functions
clause-max-26: Private ordinary functions
clause-min-27: Private ordinary functions
clause-mult-24: Private ordinary functions
clause-nconc-38: Private ordinary functions
clause-never-31: Private ordinary functions
clause-nunion-41: Private ordinary functions
clause-reduce-by-25: Private ordinary functions
clause-repeat-1: Private ordinary functions
clause-sum-23: Private ordinary functions
clause-there-is-32: Private ordinary functions
clause-union-40: Private ordinary functions
clause-until-29: Private ordinary functions
clause-warning: Private ordinary functions
clause-while-28: Private ordinary functions
clause-with-18: Private ordinary functions
coercef: Public macros
Compiler Macro, equal-lengths: Public compiler macros
concat: Public ordinary functions
cond-bind: Public macros
cond-it: Public macros
cond-let: Public macros
constant?: Private ordinary functions
contains-duplicates?: Private ordinary functions
copy: Public generic functions
copy: Public generic functions
copy: Public generic functions
copy: Public generic functions
copy: Public generic functions
copy-array: Public ordinary functions
copy-clause-info: Private ordinary functions
copy-driver-info: Private ordinary functions
copy-hash-table: Public ordinary functions
copy-pair: Private ordinary functions
copy-previous-info: Private ordinary functions
copy-save-info: Private ordinary functions
cswitch: Public macros

D
dcase: Public macros
dccase: Public macros
dcons: Public ordinary functions
decase: Public macros
def-special-clause: Private macros
default-driver-code: Private ordinary functions
defclause: Public macros
defclause-driver: Public macros
defclause-sequence: Public macros
define-clause: Private ordinary functions
defmacro-clause: Public macros
defmacro-driver: Public macros
defpar: Public macros
defsynonym: Private macros
delete-from-plist: Public ordinary functions
delete/swapped-arguments: Private ordinary functions
deletef: Public macros
diff#: Public ordinary functions
disp-std-clauses: Private ordinary functions
display-clause: Private ordinary functions
display-index: Private ordinary functions
display-iter-clauses: Public ordinary functions
display-kws: Private ordinary functions
dlistp: Public ordinary functions
do-destructuring-bindings: Private ordinary functions
do-dsetq: Private ordinary functions
do-extra-save-var-hack: Private ordinary functions
doindex: Public macros
dokv: Public macros
doleaves: Public macros
dolines: Public macros
doplist: Public macros
dotable: Public macros
dotree: Public macros
dovec: Public macros
dowhile-bind: Public macros
dowhile-it: Public macros
dowhile-let: Public macros
driver-info-generator?: Private ordinary functions
driver-info-next-code: Private ordinary functions
driver-info-p: Private ordinary functions
driver-info-used: Private ordinary functions
ds-bind: Public macros
dsetq: Public macros
dsetq-error: Private ordinary functions
duplicable?: Private ordinary functions
dyadic: Public ordinary functions

E
else: Private ordinary functions
emptyp: Public ordinary functions
emptyp#: Public ordinary functions
ends-with: Public ordinary functions
ensure-keyword: Public ordinary functions
ensure-list: Public ordinary functions
ensure-symbol: Public ordinary functions
eq-test: Public generic functions
eq-test: Public generic functions
eq-test: Public generic functions
equal-lengths: Public compiler macros
equal-lengths: Public ordinary functions
eswitch: Public macros
eval-always: Public macros
eval-const-expr: Private ordinary functions
expand-binding: Private ordinary functions
expand-destructuring-case: Private ordinary functions
expand-predicate-case: Private ordinary functions
expr-type-only: Private ordinary functions
expression-type: Private ordinary functions
extract-function-name: Private ordinary functions
extract-var: Private ordinary functions
extract-vars: Private ordinary functions

F
finally: Private ordinary functions
finally-protected: Private ordinary functions
finish: Private ordinary functions
first-iteration-p: Private ordinary functions
first-time-p: Private ordinary functions
flat-map: Public ordinary functions
flatten: Public ordinary functions
flet*: Public macros
fmt: Public ordinary functions
fn: Public macros
free-variables: Private ordinary functions
free-vars: Private ordinary functions
free-vars-fspec: Private ordinary functions
free-vars-list: Private ordinary functions
Function, #/-reader: Public ordinary functions
Function, #h-reader: Public ordinary functions
Function, #v-reader: Public ordinary functions
Function, #`-reader: Public ordinary functions
Function, #{-reader: Public ordinary functions
Function, (setf clause-info-doc-string): Private ordinary functions
Function, (setf clause-info-function): Private ordinary functions
Function, (setf clause-info-generator?): Private ordinary functions
Function, (setf clause-info-keywords): Private ordinary functions
Function, (setf clause-info-req-keywords): Private ordinary functions
Function, (setf driver-info-generator?): Private ordinary functions
Function, (setf driver-info-next-code): Private ordinary functions
Function, (setf driver-info-used): Private ordinary functions
Function, (setf last-elt): Public ordinary functions
Function, (setf last1): Public ordinary functions
Function, (setf pair-left): Public ordinary functions
Function, (setf pair-right): Private ordinary functions
Function, (setf previous-info-class): Private ordinary functions
Function, (setf previous-info-code): Private ordinary functions
Function, (setf previous-info-save-info-list): Private ordinary functions
Function, (setf previous-info-var): Private ordinary functions
Function, (setf save-info-iv-ref): Private ordinary functions
Function, (setf save-info-save-var): Private ordinary functions
Function, (setf save-info-save-vars): Private ordinary functions
Function, @-reader: Public ordinary functions
Function, add#: Public ordinary functions
Function, add-binding: Private ordinary functions
Function, add-driver-info: Private ordinary functions
Function, add-internal-var: Private ordinary functions
Function, add-internal-vars: Private ordinary functions
Function, add-loop-body-wrapper: Private ordinary functions
Function, add-progn: Private ordinary functions
Function, after-each: Private ordinary functions
Function, alist->ht: Public ordinary functions
Function, alist-to-plist: Public ordinary functions
Function, alistp: Public ordinary functions
Function, ambiguity-check-clause: Private ordinary functions
Function, ambiguity-check-index: Private ordinary functions
Function, ambiguous-clauses?: Private ordinary functions
Function, and2: Public ordinary functions
Function, apply-clause-function: Private ordinary functions
Function, apply-subst-expr: Private ordinary functions
Function, arg-check: Private ordinary functions
Function, assoc1: Public ordinary functions
Function, atomize: Public ordinary functions
Function, blankp: Public ordinary functions
Function, bug: Private ordinary functions
Function, build-index: Private ordinary functions
Function, butlast2: Public ordinary functions
Function, call: Public ordinary functions
Function, check-internal-variables: Private ordinary functions
Function, check-sequence-keywords: Private ordinary functions
Function, clause-accumulate-by-42: Private ordinary functions
Function, clause-adjoin-37: Private ordinary functions
Function, clause-always-30: Private ordinary functions
Function, clause-append-39: Private ordinary functions
Function, clause-collect-36: Private ordinary functions
Function, clause-count-22: Private ordinary functions
Function, clause-error: Private ordinary functions
Function, clause-find-max-34: Private ordinary functions
Function, clause-find-min-35: Private ordinary functions
Function, clause-find-such-that-33: Private ordinary functions
Function, clause-for-2: Private ordinary functions
Function, clause-for-=-20: Private ordinary functions
Function, clause-for-do-next-17: Private ordinary functions
Function, clause-for-first-then-21: Private ordinary functions
Function, clause-for-in-4: Private ordinary functions
Function, clause-for-in-file-14: Private ordinary functions
Function, clause-for-in-hashtable-11: Private ordinary functions
Function, clause-for-in-packages-12: Private ordinary functions
Function, clause-for-in-sequence-7: Private ordinary functions
Function, clause-for-in-stream-15: Private ordinary functions
Function, clause-for-in-string-9: Private ordinary functions
Function, clause-for-in-vector-5: Private ordinary functions
Function, clause-for-index-of-sequence-8: Private ordinary functions
Function, clause-for-index-of-string-10: Private ordinary functions
Function, clause-for-index-of-vector-6: Private ordinary functions
Function, clause-for-initially-then-19: Private ordinary functions
Function, clause-for-next-16: Private ordinary functions
Function, clause-for-on-3: Private ordinary functions
Function, clause-for-prev-43: Private ordinary functions
Function, clause-info-doc-string: Private ordinary functions
Function, clause-info-function: Private ordinary functions
Function, clause-info-generator?: Private ordinary functions
Function, clause-info-keywords: Private ordinary functions
Function, clause-info-p: Private ordinary functions
Function, clause-info-req-keywords: Private ordinary functions
Function, clause-matches?: Private ordinary functions
Function, clause-max-26: Private ordinary functions
Function, clause-min-27: Private ordinary functions
Function, clause-mult-24: Private ordinary functions
Function, clause-nconc-38: Private ordinary functions
Function, clause-never-31: Private ordinary functions
Function, clause-nunion-41: Private ordinary functions
Function, clause-reduce-by-25: Private ordinary functions
Function, clause-repeat-1: Private ordinary functions
Function, clause-sum-23: Private ordinary functions
Function, clause-there-is-32: Private ordinary functions
Function, clause-union-40: Private ordinary functions
Function, clause-until-29: Private ordinary functions
Function, clause-warning: Private ordinary functions
Function, clause-while-28: Private ordinary functions
Function, clause-with-18: Private ordinary functions
Function, concat: Public ordinary functions
Function, constant?: Private ordinary functions
Function, contains-duplicates?: Private ordinary functions
Function, copy-array: Public ordinary functions
Function, copy-clause-info: Private ordinary functions
Function, copy-driver-info: Private ordinary functions
Function, copy-hash-table: Public ordinary functions
Function, copy-pair: Private ordinary functions
Function, copy-previous-info: Private ordinary functions
Function, copy-save-info: Private ordinary functions
Function, dcons: Public ordinary functions
Function, default-driver-code: Private ordinary functions
Function, define-clause: Private ordinary functions
Function, delete-from-plist: Public ordinary functions
Function, delete/swapped-arguments: Private ordinary functions
Function, diff#: Public ordinary functions
Function, disp-std-clauses: Private ordinary functions
Function, display-clause: Private ordinary functions
Function, display-index: Private ordinary functions
Function, display-iter-clauses: Public ordinary functions
Function, display-kws: Private ordinary functions
Function, dlistp: Public ordinary functions
Function, do-destructuring-bindings: Private ordinary functions
Function, do-dsetq: Private ordinary functions
Function, do-extra-save-var-hack: Private ordinary functions
Function, driver-info-generator?: Private ordinary functions
Function, driver-info-next-code: Private ordinary functions
Function, driver-info-p: Private ordinary functions
Function, driver-info-used: Private ordinary functions
Function, dsetq-error: Private ordinary functions
Function, duplicable?: Private ordinary functions
Function, dyadic: Public ordinary functions
Function, else: Private ordinary functions
Function, emptyp: Public ordinary functions
Function, emptyp#: Public ordinary functions
Function, ends-with: Public ordinary functions
Function, ensure-keyword: Public ordinary functions
Function, ensure-list: Public ordinary functions
Function, ensure-symbol: Public ordinary functions
Function, equal-lengths: Public ordinary functions
Function, eval-const-expr: Private ordinary functions
Function, expand-binding: Private ordinary functions
Function, expand-destructuring-case: Private ordinary functions
Function, expand-predicate-case: Private ordinary functions
Function, expr-type-only: Private ordinary functions
Function, expression-type: Private ordinary functions
Function, extract-function-name: Private ordinary functions
Function, extract-var: Private ordinary functions
Function, extract-vars: Private ordinary functions
Function, finally: Private ordinary functions
Function, finally-protected: Private ordinary functions
Function, finish: Private ordinary functions
Function, first-iteration-p: Private ordinary functions
Function, first-time-p: Private ordinary functions
Function, flat-map: Public ordinary functions
Function, flatten: Public ordinary functions
Function, fmt: Public ordinary functions
Function, free-variables: Private ordinary functions
Function, free-vars: Private ordinary functions
Function, free-vars-fspec: Private ordinary functions
Function, free-vars-list: Private ordinary functions
Function, function-quoted?: Private ordinary functions
Function, generate-function-step-code: Private ordinary functions
Function, generate-switch-body: Private ordinary functions
Function, genvar: Private ordinary functions
Function, get#: Public ordinary functions
Function, get-clause-info: Private ordinary functions
Function, group: Public ordinary functions
Function, hash-set: Public ordinary functions
Function, hash-table-from-alist: Public ordinary functions
Function, hash-table-from-plist: Public ordinary functions
Function, hash-table-keys: Public ordinary functions
Function, hash-table-to-alist: Public ordinary functions
Function, hash-table-to-plist: Public ordinary functions
Function, hash-table-vals: Public ordinary functions
Function, ht->alist: Public ordinary functions
Function, ht->pairs: Public ordinary functions
Function, ht->plist: Public ordinary functions
Function, ht-count: Public ordinary functions
Function, ht-keys: Public ordinary functions
Function, ht-vals: Public ordinary functions
Function, if-1st-time: Private ordinary functions
Function, in: Private ordinary functions
Function, in#: Public ordinary functions
Function, index-add: Private ordinary functions
Function, index-lookup: Private ordinary functions
Function, index?: Private ordinary functions
Function, initially: Private ordinary functions
Function, insert-previous-code: Private ordinary functions
Function, install-clause-info: Private ordinary functions
Function, install-clause-info-1: Private ordinary functions
Function, install-special-clause-function: Private ordinary functions
Function, inter#: Public ordinary functions
Function, interleave: Public ordinary functions
Function, intern-previous-info: Private ordinary functions
Function, internal-variable?: Private ordinary functions
Function, interpose: Public ordinary functions
Function, is-iter-clause?: Private ordinary functions
Function, is-save-var: Private ordinary functions
Function, just: Public ordinary functions
Function, keep: Public ordinary functions
Function, keep-if: Public ordinary functions
Function, keep-if-not: Public ordinary functions
Function, lambda-expression?: Private ordinary functions
Function, lambda-list-vars: Private ordinary functions
Function, last-char: Public ordinary functions
Function, last-elt: Public ordinary functions
Function, last1: Public ordinary functions
Function, leave: Private ordinary functions
Function, length=: Public ordinary functions
Function, less: Public ordinary functions
Function, list-of-forms?: Private ordinary functions
Function, local-binding-check: Private ordinary functions
Function, lt: Public ordinary functions
Function, m1: Public ordinary functions
Function, make-accum-var-binding: Private ordinary functions
Function, make-accum-var-binding-internal: Private ordinary functions
Function, make-accum-var-default-binding: Private ordinary functions
Function, make-application: Private ordinary functions
Function, make-binding: Private ordinary functions
Function, make-binding-internal: Private ordinary functions
Function, make-clause-info: Private ordinary functions
Function, make-default-binding: Private ordinary functions
Function, make-destructuring-bindings: Private ordinary functions
Function, make-driver-info: Private ordinary functions
Function, make-dsetqs: Private ordinary functions
Function, make-funcall: Private ordinary functions
Function, make-function-name: Private ordinary functions
Function, make-gensym-list: Public ordinary functions
Function, make-initial-value: Private ordinary functions
Function, make-mv-dsetqs: Private ordinary functions
Function, make-next-code: Private ordinary functions
Function, make-pair: Public ordinary functions
Function, make-post-save-var: Private ordinary functions
Function, make-prev-code: Private ordinary functions
Function, make-previous-info: Private ordinary functions
Function, make-save-info: Private ordinary functions
Function, make-save-previous-code: Private ordinary functions
Function, make-save-vars: Private ordinary functions
Function, make-shared-binding: Private ordinary functions
Function, make-var-and-binding: Private ordinary functions
Function, make-var-and-default-binding: Private ordinary functions
Function, map*: Public ordinary functions
Function, mapcanindex: Public ordinary functions
Function, mapcat: Public ordinary functions
Function, mapindex: Public ordinary functions
Function, mapleaves: Public ordinary functions
Function, mappend: Public ordinary functions
Function, maptimes: Public ordinary functions
Function, maptree: Public ordinary functions
Function, merge-hash-tables: Public ordinary functions
Function, merge-hash-tables-with: Public ordinary functions
Function, merge-hts: Public ordinary functions
Function, merge-hts-with: Public ordinary functions
Function, mkeyw: Public ordinary functions
Function, mklist: Public ordinary functions
Function, mksym: Public ordinary functions
Function, more: Public ordinary functions
Function, next: Private ordinary functions
Function, next-iteration: Private ordinary functions
Function, not-less: Public ordinary functions
Function, not-more: Public ordinary functions
Function, nshuffle: Public ordinary functions
Function, or2: Public ordinary functions
Function, p#: Public ordinary functions
Function, package-external-symbols: Public ordinary functions
Function, package-internal-symbols: Public ordinary functions
Function, package-symbols: Public ordinary functions
Function, pair: Public ordinary functions
Function, pair-left: Public ordinary functions
Function, pair-right: Private ordinary functions
Function, pairs->ht: Public ordinary functions
Function, partition-with: Public ordinary functions
Function, permutations: Public ordinary functions
Function, plist->ht: Public ordinary functions
Function, plist-to-alist: Public ordinary functions
Function, plistp: Public ordinary functions
Function, preprocess-clause: Private ordinary functions
Function, previous-info-class: Private ordinary functions
Function, previous-info-code: Private ordinary functions
Function, previous-info-p: Private ordinary functions
Function, previous-info-save-info-list: Private ordinary functions
Function, previous-info-var: Private ordinary functions
Function, print-hash-table: Public ordinary functions
Function, print-ht: Public ordinary functions
Function, process-clause: Private ordinary functions
Function, process-top-level-decls: Private ordinary functions
Function, product: Public ordinary functions
Function, progn-wrap: Private ordinary functions
Function, pushx: Public ordinary functions
Function, quoted?: Private ordinary functions
Function, range: Public ordinary functions
Function, re-export-symbols: Public ordinary functions
Function, read-file: Public ordinary functions
Function, register-previous-code: Private ordinary functions
Function, rem#: Public ordinary functions
Function, remove-clause: Private ordinary functions
Function, remove-from-plist: Public ordinary functions
Function, remove-idx: Public ordinary functions
Function, remove/swapped-arguments: Private ordinary functions
Function, return-code: Private ordinary functions
Function, return-code-modifying-body: Private ordinary functions
Function, return-collection-code: Private ordinary functions
Function, return-extremum-code: Private ordinary functions
Function, return-find-extremum-code: Private ordinary functions
Function, return-reduction-code: Private ordinary functions
Function, return-seq-code: Private ordinary functions
Function, return-stream-driver-code: Private ordinary functions
Function, rotate: Public ordinary functions
Function, rotate-head-to-tail: Private ordinary functions
Function, rotate-tail-to-head: Private ordinary functions
Function, rt: Public ordinary functions
Function, safe-sort: Public ordinary functions
Function, save-info-iv-ref: Private ordinary functions
Function, save-info-p: Private ordinary functions
Function, save-info-save-var: Private ordinary functions
Function, save-info-save-vars: Private ordinary functions
Function, self-evaluating?: Private ordinary functions
Function, set#: Public ordinary functions
Function, set-equal: Public ordinary functions
Function, sethash: Public ordinary functions
Function, shuffle: Public ordinary functions
Function, single: Public ordinary functions
Function, slice: Public ordinary functions
Function, slurp: Public ordinary functions
Function, special-form?: Private ordinary functions
Function, splice-in-code: Private ordinary functions
Function, split: Public ordinary functions
Function, split-clause-template: Private ordinary functions
Function, split-if: Public ordinary functions
Function, split-if-not: Public ordinary functions
Function, split-list-odd-even: Private ordinary functions
Function, split-sequence: Public ordinary functions
Function, split-sequence-if: Public ordinary functions
Function, split-sequence-if-not: Public ordinary functions
Function, split-string: Public ordinary functions
Function, starts-clause?: Private ordinary functions
Function, starts-with: Public ordinary functions
Function, strcat: Public ordinary functions
Function, strjoin: Public ordinary functions
Function, sub: Public ordinary functions
Function, subst-ignore: Private ordinary functions
Function, substr: Public ordinary functions
Function, sum: Public ordinary functions
Function, synonym: Private ordinary functions
Function, take: Public ordinary functions
Function, take#: Public ordinary functions
Function, takehash: Public ordinary functions
Function, terminate: Private ordinary functions
Function, the-expression?: Private ordinary functions
Function, toggle-print-hash-table: Public ordinary functions
Function, top-level-check: Private ordinary functions
Function, tree-depth: Public ordinary functions
Function, tree-size: Public ordinary functions
Function, true: Public ordinary functions
Function, tryadic: Public ordinary functions
Function, union#: Public ordinary functions
Function, var-binding?: Private ordinary functions
Function, var-declaration: Private ordinary functions
Function, var-spec?: Private ordinary functions
Function, var-type: Private ordinary functions
Function, var-value-returned: Private ordinary functions
Function, vec: Public ordinary functions
Function, walk: Private ordinary functions
Function, walk-arglist: Private ordinary functions
Function, walk-cddr: Private ordinary functions
Function, walk-cddr-with-declarations: Private ordinary functions
Function, walk-cdr: Private ordinary functions
Function, walk-cdr-with-declarations: Private ordinary functions
Function, walk-declare: Private ordinary functions
Function, walk-expr: Private ordinary functions
Function, walk-flet: Private ordinary functions
Function, walk-fspec: Private ordinary functions
Function, walk-function: Private ordinary functions
Function, walk-let: Private ordinary functions
Function, walk-let*-bindings: Private ordinary functions
Function, walk-let-binding: Private ordinary functions
Function, walk-let-bindings: Private ordinary functions
Function, walk-list: Private ordinary functions
Function, walk-list-nconcing: Private ordinary functions
Function, walk-macrolet: Private ordinary functions
Function, walk-multiple-value-bind: Private ordinary functions
Function, walk-progn: Private ordinary functions
Function, walk-setq: Private ordinary functions
Function, walk-special-form: Private ordinary functions
Function, white-char-p: Public ordinary functions
Function, wrap-form: Private ordinary functions
Function, xor#: Public ordinary functions
Function, xor2: Public ordinary functions
Function, zip: Public ordinary functions
Function, zip*: Public ordinary functions
Function, zip*-with: Public ordinary functions
Function, zip-with: Public ordinary functions
Function, ^-reader: Private ordinary functions
function-quoted?: Private ordinary functions

G
generate-function-step-code: Private ordinary functions
generate-switch-body: Private ordinary functions
Generic Function, (setf generic-elt-error-key): Public generic functions
Generic Function, (setf generic-elt-error-obj): Public generic functions
Generic Function, ?: Public generic functions
Generic Function, bind-dispatch: Public generic functions
Generic Function, case-failure-name: Private generic functions
Generic Function, case-failure-possibilities: Private generic functions
Generic Function, copy: Public generic functions
Generic Function, eq-test: Public generic functions
Generic Function, generic-elt: Public generic functions
Generic Function, generic-elt-error-key: Public generic functions
Generic Function, generic-elt-error-obj: Public generic functions
Generic Function, generic-setf: Private generic functions
Generic Function, keys: Public generic functions
Generic Function, kvs: Public generic functions
Generic Function, make: Public generic functions
Generic Function, mapkv: Public generic functions
Generic Function, pairs: Public generic functions
Generic Function, smart-set-slot-value: Private generic functions
Generic Function, smart-slot-value: Public generic functions
Generic Function, tally: Public generic functions
Generic Function, vals: Public generic functions
generic-elt: Public generic functions
generic-elt: Public generic functions
generic-elt: Public generic functions
generic-elt: Public generic functions
generic-elt: Public generic functions
generic-elt: Public generic functions
generic-elt: Public generic functions
generic-elt: Public generic functions
generic-elt: Public generic functions
generic-elt: Public generic functions
generic-elt: Public generic functions
generic-elt-error-key: Public generic functions
generic-elt-error-key: Public generic functions
generic-elt-error-obj: Public generic functions
generic-elt-error-obj: Public generic functions
generic-setf: Private generic functions
generic-setf: Private generic functions
generic-setf: Private generic functions
generic-setf: Private generic functions
generic-setf: Private generic functions
generic-setf: Private generic functions
generic-setf: Private generic functions
generic-setf: Private generic functions
generic-setf: Private generic functions
genvar: Private ordinary functions
get#: Public ordinary functions
get-clause-info: Private ordinary functions
getset#: Public macros
getsethash: Public macros
group: Public ordinary functions

H
hash-set: Public ordinary functions
hash-table-from-alist: Public ordinary functions
hash-table-from-plist: Public ordinary functions
hash-table-keys: Public ordinary functions
hash-table-to-alist: Public ordinary functions
hash-table-to-plist: Public ordinary functions
hash-table-vals: Public ordinary functions
ht->alist: Public ordinary functions
ht->pairs: Public ordinary functions
ht->plist: Public ordinary functions
ht-count: Public ordinary functions
ht-keys: Public ordinary functions
ht-vals: Public ordinary functions

I
if-1st-time: Private ordinary functions
if-bind: Public macros
if-it: Public macros
if-let: Public macros
in: Private ordinary functions
in#: Public ordinary functions
index-add: Private ordinary functions
index-lookup: Private ordinary functions
index?: Private ordinary functions
initially: Private ordinary functions
insert-previous-code: Private ordinary functions
install-clause-info: Private ordinary functions
install-clause-info-1: Private ordinary functions
install-special-clause-function: Private ordinary functions
inter#: Public ordinary functions
interleave: Public ordinary functions
intern-previous-info: Private ordinary functions
internal-variable?: Private ordinary functions
interpose: Public ordinary functions
is-iter-clause?: Private ordinary functions
is-save-var: Private ordinary functions
iter: Public macros

J
just: Public ordinary functions

K
keep: Public ordinary functions
keep-if: Public ordinary functions
keep-if-not: Public ordinary functions
keys: Public generic functions
keys: Public generic functions
keys: Public generic functions
kvs: Public generic functions
kvs: Public generic functions

L
lambda-expression?: Private ordinary functions
lambda-list-vars: Private ordinary functions
last-char: Public ordinary functions
last-elt: Public ordinary functions
last1: Public ordinary functions
leave: Private ordinary functions
length=: Public ordinary functions
less: Public ordinary functions
list-of-forms?: Private ordinary functions
listcase: Public macros
local-binding-check: Private ordinary functions
lt: Public ordinary functions

M
m1: Public ordinary functions
Macro, ->: Public macros
Macro, ->>: Public macros
Macro, 2nd: Public macros
Macro, <-: Public macros
Macro, =>: Public macros
Macro, aand: Public macros
Macro, abbr: Public macros
Macro, acond: Public macros
Macro, adding-smart-slot-methods: Private macros
Macro, adowhile: Public macros
Macro, aif: Public macros
Macro, and-bind: Public macros
Macro, and-it: Public macros
Macro, and-let: Public macros
Macro, appendf: Public macros
Macro, augment: Private macros
Macro, awhen: Public macros
Macro, bind: Public macros
Macro, clause-for-in-package-13: Private macros
Macro, coercef: Public macros
Macro, cond-bind: Public macros
Macro, cond-it: Public macros
Macro, cond-let: Public macros
Macro, cswitch: Public macros
Macro, dcase: Public macros
Macro, dccase: Public macros
Macro, decase: Public macros
Macro, def-special-clause: Private macros
Macro, defclause: Public macros
Macro, defclause-driver: Public macros
Macro, defclause-sequence: Public macros
Macro, defmacro-clause: Public macros
Macro, defmacro-driver: Public macros
Macro, defpar: Public macros
Macro, defsynonym: Private macros
Macro, deletef: Public macros
Macro, doindex: Public macros
Macro, dokv: Public macros
Macro, doleaves: Public macros
Macro, dolines: Public macros
Macro, doplist: Public macros
Macro, dotable: Public macros
Macro, dotree: Public macros
Macro, dovec: Public macros
Macro, dowhile-bind: Public macros
Macro, dowhile-it: Public macros
Macro, dowhile-let: Public macros
Macro, ds-bind: Public macros
Macro, dsetq: Public macros
Macro, eswitch: Public macros
Macro, eval-always: Public macros
Macro, flet*: Public macros
Macro, fn: Public macros
Macro, getset#: Public macros
Macro, getsethash: Public macros
Macro, if-bind: Public macros
Macro, if-it: Public macros
Macro, if-let: Public macros
Macro, iter: Public macros
Macro, listcase: Public macros
Macro, multiple-value-prog2: Public macros
Macro, mv-bind: Public macros
Macro, named-lambda: Public macros
Macro, nconcf: Public macros
Macro, nreversef: Public macros
Macro, nunionf: Public macros
Macro, once-only: Public macros
Macro, pcase: Public macros
Macro, pccase: Public macros
Macro, pecase: Public macros
Macro, prepend: Private macros
Macro, re-setf: Public macros
Macro, removef: Public macros
Macro, return-driver-code: Private macros
Macro, return-sequence-code: Private macros
Macro, reversef: Public macros
Macro, switch: Public macros
Macro, trivial-positional-lambda: Private macros
Macro, unionf: Public macros
Macro, void: Public macros
Macro, w/instr: Public macros
Macro, w/outstr: Public macros
Macro, w/uniqs: Public macros
Macro, when-bind: Public macros
Macro, when-it: Public macros
Macro, when-let: Public macros
Macro, with: Public macros
Macro, with-gensyms: Public macros
Macro, with-keys: Public macros
Macro, with-out-file: Public macros
Macro, with-output-to-list: Public macros
Macro, with-pair: Public macros
Macro, with-temporary: Private macros
Macro, with-unique-names: Public macros
Macro, xor: Public macros
make: Public generic functions
make-accum-var-binding: Private ordinary functions
make-accum-var-binding-internal: Private ordinary functions
make-accum-var-default-binding: Private ordinary functions
make-application: Private ordinary functions
make-binding: Private ordinary functions
make-binding-internal: Private ordinary functions
make-clause-info: Private ordinary functions
make-default-binding: Private ordinary functions
make-destructuring-bindings: Private ordinary functions
make-driver-info: Private ordinary functions
make-dsetqs: Private ordinary functions
make-funcall: Private ordinary functions
make-function-name: Private ordinary functions
make-gensym-list: Public ordinary functions
make-initial-value: Private ordinary functions
make-mv-dsetqs: Private ordinary functions
make-next-code: Private ordinary functions
make-pair: Public ordinary functions
make-post-save-var: Private ordinary functions
make-prev-code: Private ordinary functions
make-previous-info: Private ordinary functions
make-save-info: Private ordinary functions
make-save-previous-code: Private ordinary functions
make-save-vars: Private ordinary functions
make-shared-binding: Private ordinary functions
make-var-and-binding: Private ordinary functions
make-var-and-default-binding: Private ordinary functions
map*: Public ordinary functions
mapcanindex: Public ordinary functions
mapcat: Public ordinary functions
mapindex: Public ordinary functions
mapkv: Public generic functions
mapkv: Public generic functions
mapkv: Public generic functions
mapleaves: Public ordinary functions
mappend: Public ordinary functions
maptimes: Public ordinary functions
maptree: Public ordinary functions
merge-hash-tables: Public ordinary functions
merge-hash-tables-with: Public ordinary functions
merge-hts: Public ordinary functions
merge-hts-with: Public ordinary functions
Method, (setf generic-elt-error-key): Public generic functions
Method, (setf generic-elt-error-obj): Public generic functions
Method, bind-dispatch: Public generic functions
Method, bind-dispatch: Public generic functions
Method, bind-dispatch: Public generic functions
Method, bind-dispatch: Public generic functions
Method, case-failure-name: Private generic functions
Method, case-failure-possibilities: Private generic functions
Method, copy: Public generic functions
Method, copy: Public generic functions
Method, copy: Public generic functions
Method, copy: Public generic functions
Method, eq-test: Public generic functions
Method, eq-test: Public generic functions
Method, generic-elt: Public generic functions
Method, generic-elt: Public generic functions
Method, generic-elt: Public generic functions
Method, generic-elt: Public generic functions
Method, generic-elt: Public generic functions
Method, generic-elt: Public generic functions
Method, generic-elt: Public generic functions
Method, generic-elt: Public generic functions
Method, generic-elt: Public generic functions
Method, generic-elt: Public generic functions
Method, generic-elt-error-key: Public generic functions
Method, generic-elt-error-obj: Public generic functions
Method, generic-setf: Private generic functions
Method, generic-setf: Private generic functions
Method, generic-setf: Private generic functions
Method, generic-setf: Private generic functions
Method, generic-setf: Private generic functions
Method, generic-setf: Private generic functions
Method, generic-setf: Private generic functions
Method, generic-setf: Private generic functions
Method, keys: Public generic functions
Method, keys: Public generic functions
Method, kvs: Public generic functions
Method, mapkv: Public generic functions
Method, mapkv: Public generic functions
Method, pairs: Public generic functions
Method, pairs: Public generic functions
Method, print-object: Public standalone methods
Method, smart-set-slot-value: Private generic functions
Method, smart-slot-value: Public generic functions
Method, tally: Public generic functions
Method, tally: Public generic functions
Method, vals: Public generic functions
Method, vals: Public generic functions
mkeyw: Public ordinary functions
mklist: Public ordinary functions
mksym: Public ordinary functions
more: Public ordinary functions
multiple-value-prog2: Public macros
mv-bind: Public macros

N
named-lambda: Public macros
nconcf: Public macros
next: Private ordinary functions
next-iteration: Private ordinary functions
not-less: Public ordinary functions
not-more: Public ordinary functions
nreversef: Public macros
nshuffle: Public ordinary functions
nunionf: Public macros

O
once-only: Public macros
or2: Public ordinary functions

P
p#: Public ordinary functions
package-external-symbols: Public ordinary functions
package-internal-symbols: Public ordinary functions
package-symbols: Public ordinary functions
pair: Public ordinary functions
pair-left: Public ordinary functions
pair-right: Private ordinary functions
pairs: Public generic functions
pairs: Public generic functions
pairs: Public generic functions
pairs->ht: Public ordinary functions
partition-with: Public ordinary functions
pcase: Public macros
pccase: Public macros
pecase: Public macros
permutations: Public ordinary functions
plist->ht: Public ordinary functions
plist-to-alist: Public ordinary functions
plistp: Public ordinary functions
prepend: Private macros
preprocess-clause: Private ordinary functions
previous-info-class: Private ordinary functions
previous-info-code: Private ordinary functions
previous-info-p: Private ordinary functions
previous-info-save-info-list: Private ordinary functions
previous-info-var: Private ordinary functions
print-hash-table: Public ordinary functions
print-ht: Public ordinary functions
print-object: Public standalone methods
process-clause: Private ordinary functions
process-top-level-decls: Private ordinary functions
product: Public ordinary functions
progn-wrap: Private ordinary functions
pushx: Public ordinary functions

Q
quoted?: Private ordinary functions

R
range: Public ordinary functions
re-export-symbols: Public ordinary functions
re-setf: Public macros
read-file: Public ordinary functions
register-previous-code: Private ordinary functions
rem#: Public ordinary functions
remove-clause: Private ordinary functions
remove-from-plist: Public ordinary functions
remove-idx: Public ordinary functions
remove/swapped-arguments: Private ordinary functions
removef: Public macros
return-code: Private ordinary functions
return-code-modifying-body: Private ordinary functions
return-collection-code: Private ordinary functions
return-driver-code: Private macros
return-extremum-code: Private ordinary functions
return-find-extremum-code: Private ordinary functions
return-reduction-code: Private ordinary functions
return-seq-code: Private ordinary functions
return-sequence-code: Private macros
return-stream-driver-code: Private ordinary functions
reversef: Public macros
rotate: Public ordinary functions
rotate-head-to-tail: Private ordinary functions
rotate-tail-to-head: Private ordinary functions
rt: Public ordinary functions

S
safe-sort: Public ordinary functions
save-info-iv-ref: Private ordinary functions
save-info-p: Private ordinary functions
save-info-save-var: Private ordinary functions
save-info-save-vars: Private ordinary functions
self-evaluating?: Private ordinary functions
set#: Public ordinary functions
set-equal: Public ordinary functions
Setf Expander, (setf ?): Public setf expanders
Setf Expander, (setf generic-elt): Public setf expanders
Setf Expander, (setf get#): Public setf expanders
Setf Expander, (setf smart-slot-value): Public setf expanders
sethash: Public ordinary functions
shuffle: Public ordinary functions
single: Public ordinary functions
slice: Public ordinary functions
slurp: Public ordinary functions
smart-set-slot-value: Private generic functions
smart-set-slot-value: Private generic functions
smart-slot-value: Public generic functions
smart-slot-value: Public generic functions
special-form?: Private ordinary functions
splice-in-code: Private ordinary functions
split: Public ordinary functions
split-clause-template: Private ordinary functions
split-if: Public ordinary functions
split-if-not: Public ordinary functions
split-list-odd-even: Private ordinary functions
split-sequence: Public ordinary functions
split-sequence-if: Public ordinary functions
split-sequence-if-not: Public ordinary functions
split-string: Public ordinary functions
starts-clause?: Private ordinary functions
starts-with: Public ordinary functions
strcat: Public ordinary functions
strjoin: Public ordinary functions
sub: Public ordinary functions
subst-ignore: Private ordinary functions
substr: Public ordinary functions
sum: Public ordinary functions
switch: Public macros
synonym: Private ordinary functions

T
take: Public ordinary functions
take#: Public ordinary functions
takehash: Public ordinary functions
tally: Public generic functions
tally: Public generic functions
tally: Public generic functions
terminate: Private ordinary functions
the-expression?: Private ordinary functions
toggle-print-hash-table: Public ordinary functions
top-level-check: Private ordinary functions
tree-depth: Public ordinary functions
tree-size: Public ordinary functions
trivial-positional-lambda: Private macros
true: Public ordinary functions
tryadic: Public ordinary functions

U
union#: Public ordinary functions
unionf: Public macros

V
vals: Public generic functions
vals: Public generic functions
vals: Public generic functions
var-binding?: Private ordinary functions
var-declaration: Private ordinary functions
var-spec?: Private ordinary functions
var-type: Private ordinary functions
var-value-returned: Private ordinary functions
vec: Public ordinary functions
void: Public macros

W
w/instr: Public macros
w/outstr: Public macros
w/uniqs: Public macros
walk: Private ordinary functions
walk-arglist: Private ordinary functions
walk-cddr: Private ordinary functions
walk-cddr-with-declarations: Private ordinary functions
walk-cdr: Private ordinary functions
walk-cdr-with-declarations: Private ordinary functions
walk-declare: Private ordinary functions
walk-expr: Private ordinary functions
walk-flet: Private ordinary functions
walk-fspec: Private ordinary functions
walk-function: Private ordinary functions
walk-let: Private ordinary functions
walk-let*-bindings: Private ordinary functions
walk-let-binding: Private ordinary functions
walk-let-bindings: Private ordinary functions
walk-list: Private ordinary functions
walk-list-nconcing: Private ordinary functions
walk-macrolet: Private ordinary functions
walk-multiple-value-bind: Private ordinary functions
walk-progn: Private ordinary functions
walk-setq: Private ordinary functions
walk-special-form: Private ordinary functions
when-bind: Public macros
when-it: Public macros
when-let: Public macros
white-char-p: Public ordinary functions
with: Public macros
with-gensyms: Public macros
with-keys: Public macros
with-out-file: Public macros
with-output-to-list: Public macros
with-pair: Public macros
with-temporary: Private macros
with-unique-names: Public macros
wrap-form: Private ordinary functions

X
xor: Public macros
xor#: Public ordinary functions
xor2: Public ordinary functions

Z
zip: Public ordinary functions
zip*: Public ordinary functions
zip*-with: Public ordinary functions
zip-with: Public ordinary functions

Jump to:   #   (   -   2   <   =   ?   @   ^  
A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Z  

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

A.3 Variables

Jump to:   *   +  
C   D   F   G   I   K   N   O   P   R   S   U   V  
Index Entry  Section

*
*accum-var-alist*: Private special variables
*all-packages*: Private special variables
*always-declare-variables*: Private special variables
*bind-ignores*: Private special variables
*bindings*: Private special variables
*block-name*: Private special variables
*clause*: Private special variables
*clause-info-index*: Private special variables
*declaration-context?*: Private special variables
*declarations*: Private special variables
*declare-variables*: Private special variables
*decls*: Private special variables
*driver-info-alist*: Private special variables
*env*: Private special variables
*final*: Private special variables
*finalp*: Private special variables
*genvar-counter*: Private special variables
*initial*: Private special variables
*internal-variables*: Private special variables
*list-end-test*: Private special variables
*loop-body-wrappers*: Private special variables
*loop-end*: Private special variables
*loop-end-used?*: Private special variables
*loop-step*: Private special variables
*loop-step-used?*: Private special variables
*loop-top*: Private special variables
*previous-vars-alist*: Private special variables
*result-var*: Private special variables
*shared-bindings-alist*: Private special variables
*special-clause-alist*: Private special variables
*special-form-alist*: Private special variables
*step*: Private special variables
*temps*: Private special variables
*temps-in-use*: Private special variables
*top-level?*: Private special variables
*type-alist*: Private special variables

+
+default-opts+: Public special variables
+fill-col+: Private special variables
+sequence-keyword-list+: Private special variables
+standard-type-symbols+: Private special variables

C
class: Private structures
code: Private structures

D
doc-string: Private structures

F
function: Private structures

G
generator?: Private structures
generator?: Private structures

I
iter-version: Public special variables
iv-ref: Private structures

K
key: Public conditions
keywords: Private structures

N
name: Public conditions
next-code: Private structures

O
obj: Public conditions

P
possibilities: Public conditions

R
req-keywords: Private structures

S
save-info-list: Private structures
save-var: Private structures
save-vars: Private structures
Slot, class: Private structures
Slot, code: Private structures
Slot, doc-string: Private structures
Slot, function: Private structures
Slot, generator?: Private structures
Slot, generator?: Private structures
Slot, iv-ref: Private structures
Slot, key: Public conditions
Slot, keywords: Private structures
Slot, name: Public conditions
Slot, next-code: Private structures
Slot, obj: Public conditions
Slot, possibilities: Public conditions
Slot, req-keywords: Private structures
Slot, save-info-list: Private structures
Slot, save-var: Private structures
Slot, save-vars: Private structures
Slot, used: Private structures
Slot, var: Private structures
Special Variable, *accum-var-alist*: Private special variables
Special Variable, *all-packages*: Private special variables
Special Variable, *always-declare-variables*: Private special variables
Special Variable, *bind-ignores*: Private special variables
Special Variable, *bindings*: Private special variables
Special Variable, *block-name*: Private special variables
Special Variable, *clause*: Private special variables
Special Variable, *clause-info-index*: Private special variables
Special Variable, *declaration-context?*: Private special variables
Special Variable, *declarations*: Private special variables
Special Variable, *declare-variables*: Private special variables
Special Variable, *decls*: Private special variables
Special Variable, *driver-info-alist*: Private special variables
Special Variable, *env*: Private special variables
Special Variable, *final*: Private special variables
Special Variable, *finalp*: Private special variables
Special Variable, *genvar-counter*: Private special variables
Special Variable, *initial*: Private special variables
Special Variable, *internal-variables*: Private special variables
Special Variable, *list-end-test*: Private special variables
Special Variable, *loop-body-wrappers*: Private special variables
Special Variable, *loop-end*: Private special variables
Special Variable, *loop-end-used?*: Private special variables
Special Variable, *loop-step*: Private special variables
Special Variable, *loop-step-used?*: Private special variables
Special Variable, *loop-top*: Private special variables
Special Variable, *previous-vars-alist*: Private special variables
Special Variable, *result-var*: Private special variables
Special Variable, *shared-bindings-alist*: Private special variables
Special Variable, *special-clause-alist*: Private special variables
Special Variable, *special-form-alist*: Private special variables
Special Variable, *step*: Private special variables
Special Variable, *temps*: Private special variables
Special Variable, *temps-in-use*: Private special variables
Special Variable, *top-level?*: Private special variables
Special Variable, *type-alist*: Private special variables
Special Variable, +default-opts+: Public special variables
Special Variable, +fill-col+: Private special variables
Special Variable, +sequence-keyword-list+: Private special variables
Special Variable, +standard-type-symbols+: Private special variables
Special Variable, iter-version: Public special variables

U
used: Private structures

V
var: Private structures

Jump to:   *   +  
C   D   F   G   I   K   N   O   P   R   S   U   V  

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

A.4 Data types

Jump to:   A   B   C   D   F   G   H   I   K   L   M   P   R   S   T  
Index Entry  Section

A
abbr.lisp: The rutils/core/abbr․lisp file
anaphora.lisp: The rutils/core/anaphora․lisp file
array-index: Public types
array-length: Public types
array.lisp: The rutils/core/array․lisp file

B
bind.lisp: The rutils/core/bind․lisp file

C
case-failure: Public conditions
clause-info: Private structures
Condition, case-failure: Public conditions
Condition, generic-elt-error: Public conditions
Condition, rutils-style-warning: Public conditions
core: The rutils/core module

D
driver-info: Private structures

F
File, abbr.lisp: The rutils/core/abbr․lisp file
File, anaphora.lisp: The rutils/core/anaphora․lisp file
File, array.lisp: The rutils/core/array․lisp file
File, bind.lisp: The rutils/core/bind․lisp file
File, generic.lisp: The rutils/core/generic․lisp file
File, hash-set.lisp: The rutils/core/hash-set․lisp file
File, hash-table.lisp: The rutils/core/hash-table․lisp file
File, iter.lisp: The rutils/core/iter․lisp file
File, kv.lisp: The rutils/core/kv․lisp file
File, list.lisp: The rutils/core/list․lisp file
File, misc.lisp: The rutils/core/misc․lisp file
File, packages.lisp: The rutils/core/packages․lisp file
File, pair.lisp: The rutils/core/pair․lisp file
File, readtable.lisp: The rutils/core/readtable․lisp file
File, rutils.asd: The rutils/rutils․asd file
File, rutils.lisp: The rutils/core/rutils․lisp file
File, sequence.lisp: The rutils/core/sequence․lisp file
File, string.lisp: The rutils/core/string․lisp file
File, symbol.lisp: The rutils/core/symbol․lisp file
File, tree.lisp: The rutils/core/tree․lisp file

G
generic-elt-error: Public conditions
generic.lisp: The rutils/core/generic․lisp file

H
hash-set.lisp: The rutils/core/hash-set․lisp file
hash-table.lisp: The rutils/core/hash-table․lisp file

I
iter.lisp: The rutils/core/iter․lisp file

K
kv.lisp: The rutils/core/kv․lisp file

L
list.lisp: The rutils/core/list․lisp file

M
misc.lisp: The rutils/core/misc․lisp file
Module, core: The rutils/core module

P
Package, rtl: The rtl package
Package, rtl-user: The rtl-user package
Package, rutils: The rutils package
Package, rutils-user: The rutils-user package
Package, rutils.abbr: The rutils․abbr package
Package, rutils.anaphora: The rutils․anaphora package
Package, rutils.array: The rutils․array package
Package, rutils.bind: The rutils․bind package
Package, rutils.generic: The rutils․generic package
Package, rutils.hash-set: The rutils․hash-set package
Package, rutils.hash-table: The rutils․hash-table package
Package, rutils.iter: The rutils․iter package
Package, rutils.kv: The rutils․kv package
Package, rutils.list: The rutils․list package
Package, rutils.misc: The rutils․misc package
Package, rutils.pair: The rutils․pair package
Package, rutils.readtable: The rutils․readtable package
Package, rutils.sequence: The rutils․sequence package
Package, rutils.string: The rutils․string package
Package, rutils.symbol: The rutils․symbol package
Package, rutils.tree: The rutils․tree package
packages.lisp: The rutils/core/packages․lisp file
pair.lisp: The rutils/core/pair․lisp file
previous-info: Private structures

R
readtable.lisp: The rutils/core/readtable․lisp file
rtl: The rtl package
rtl-user: The rtl-user package
rutils: The rutils system
rutils: The rutils package
rutils-style-warning: Public conditions
rutils-user: The rutils-user package
rutils.abbr: The rutils․abbr package
rutils.anaphora: The rutils․anaphora package
rutils.array: The rutils․array package
rutils.asd: The rutils/rutils․asd file
rutils.bind: The rutils․bind package
rutils.generic: The rutils․generic package
rutils.hash-set: The rutils․hash-set package
rutils.hash-table: The rutils․hash-table package
rutils.iter: The rutils․iter package
rutils.kv: The rutils․kv package
rutils.lisp: The rutils/core/rutils․lisp file
rutils.list: The rutils․list package
rutils.misc: The rutils․misc package
rutils.pair: The rutils․pair package
rutils.readtable: The rutils․readtable package
rutils.sequence: The rutils․sequence package
rutils.string: The rutils․string package
rutils.symbol: The rutils․symbol package
rutils.tree: The rutils․tree package

S
save-info: Private structures
sequence.lisp: The rutils/core/sequence․lisp file
string-designator: Public types
string.lisp: The rutils/core/string․lisp file
Structure, clause-info: Private structures
Structure, driver-info: Private structures
Structure, previous-info: Private structures
Structure, save-info: Private structures
symbol.lisp: The rutils/core/symbol․lisp file
System, rutils: The rutils system

T
tree.lisp: The rutils/core/tree․lisp file
Type, array-index: Public types
Type, array-length: Public types
Type, string-designator: Public types

Jump to:   A   B   C   D   F   G   H   I   K   L   M   P   R   S   T