The defenum Reference Manual

This is the defenum Reference Manual, generated automatically by Declt version 3.0 "Montgomery Scott" on Tue Apr 28 11:39:57 2020 GMT+0.

1 Introduction

DEFENUM
=======

Copyright (c) 2014-2020 Marco Antoniotti, all rights reserved.

The DEFENUM facility provides C++ and Java styled 'enum' in Common
Lisp.  Please refer to the HTML documentation for more information.


A NOTE ON FORKING
-----------------

Of course you are free to fork the project subject to the current
licensing scheme.  However, before you do so, I ask you to consider
plain old "cooperation" by asking me to become a developer.
It helps keeping the entropy level at an acceptable level.


Enjoy

2 Systems

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

2.1 `defenum`

Author

Marco Antoniotti

License

BSD

Description

The DEFENUM facility provides C++ and Java styled ’enum’ in Common Lisp.

Source

defenum.asd (file)

Components

defenum-package.lisp (file)
lambda-list-parsing.lisp (file)
defenum.lisp (file)

3 Files

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

3.1 Lisp

3.1.1 `defenum.asd`

Location: defenum.asd
Systems: defenum (system)

3.1.2 `defenum/defenum-package.lisp`

Parent: defenum (system)
Location: defenum-package.lisp
Packages: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum

3.1.3 `defenum/lambda-list-parsing.lisp`

Dependency

defenum-package.lisp (file)

Parent

defenum (system)

Location

lambda-list-parsing.lisp

Internal Definitions

copy-destructuring-lambda-list (function)
copy-generic-function-lambda-list (function)
copy-lambda-list-item (function)
copy-lambda-list-var (function)
copy-macro-lambda-list (function)
copy-ordinary-lambda-list (function)
copy-specialized-lambda-list (function)
destructuring-lambda-list (structure)
destructuring-lambda-list-allow-other-keys (function)
destructuring-lambda-list-auxiliary-vars (function)
destructuring-lambda-list-keyword-vars (function)
destructuring-lambda-list-optional-vars (function)
destructuring-lambda-list-ordinary-vars (function)
destructuring-lambda-list-p (function)
destructuring-lambda-list-rest-var (function)
generic-function-lambda-list (structure)
generic-function-lambda-list-allow-other-keys (function)
generic-function-lambda-list-auxiliary-vars (function)
generic-function-lambda-list-keyword-vars (function)
generic-function-lambda-list-optional-vars (function)
generic-function-lambda-list-ordinary-vars (function)
generic-function-lambda-list-p (function)
generic-function-lambda-list-rest-var (function)
lambda-list-item (structure)
lambda-list-item-p (function)
lambda-list-type (type)
lambda-list-var (structure)
lambda-list-var-p (function)
lambda-list-var-type (type)
ll-allow-other-keys (function)
ll-auxiliary-vars (function)
ll-keyword-vars (function)
ll-optional-vars (function)
ll-ordinary-vars (function)
ll-recall (generic function)
ll-recall (method)
ll-rest-var (function)
ll-vars (generic function)
ll-vars (method)
ll-vars (method)
ll-vars (method)
ll-vars (method)
lli-form (function)
lli-item (function)
lli-kind (function)
lli-name (function)
llv-form (function)
llv-item (function)
llv-kind (function)
llv-name (function)
macro-lambda-list (structure)
macro-lambda-list-allow-other-keys (function)
macro-lambda-list-auxiliary-vars (function)
macro-lambda-list-body-var (function)
macro-lambda-list-env-var (function)
macro-lambda-list-keyword-vars (function)
macro-lambda-list-optional-vars (function)
macro-lambda-list-ordinary-vars (function)
macro-lambda-list-p (function)
macro-lambda-list-rest-var (function)
macro-lambda-list-whole-var (function)
make-destructuring-lambda-list (function)
make-generic-function-lambda-list (function)
make-macro-lambda-list (function)
make-ordinary-lambda-list (function)
make-specialized-lambda-list (function)
mkllitem (function)
mkllvar (function)
ordinary-lambda-list (structure)
ordinary-lambda-list-allow-other-keys (function)
ordinary-lambda-list-auxiliary-vars (function)
ordinary-lambda-list-keyword-vars (function)
ordinary-lambda-list-optional-vars (function)
ordinary-lambda-list-ordinary-vars (function)
ordinary-lambda-list-p (function)
ordinary-lambda-list-rest-var (function)
parse-ll (generic function)
parse-ll (method)
parse-ll (method)
parse-ll (method)
parse-ll (method)
parse-ll (method)
pll (function)
specialized-lambda-list (structure)
specialized-lambda-list-allow-other-keys (function)
specialized-lambda-list-auxiliary-vars (function)
specialized-lambda-list-keyword-vars (function)
specialized-lambda-list-optional-vars (function)
specialized-lambda-list-ordinary-vars (function)
specialized-lambda-list-p (function)
specialized-lambda-list-rest-var (function)
t_lambda-list (structure)
t_lambda-list-p (function)

3.1.4 `defenum/defenum.lisp`

Dependencies

defenum-package.lisp (file)
lambda-list-parsing.lisp (file)

Parent

defenum (system)

Location

defenum.lisp

Exported Definitions

defenum (macro)
enum (structure)
enum-name (function)
find-enum (function)
(setf find-enum) (function)
next-enum-tag (function)
nth-enum-tag (function)
previous-enum-tag (function)
tag-name (function)
tag-of (function)
tag-p (function)
tags (function)

Internal Definitions

%tag-enum (function)
(setf %tag-enum) (function)
%tag-name (function)
%tag-p (function)
*enums-namespace* (special variable)
build-enum-defstruct (function)
build-enum-deftype (function)
build-enum-fixnum-method (function)
build-enum-function (function)
build-enum-initialization (function)
build-enum-method (function)
build-enum-method-body (function)
build-enum-method-redispatch-body (function)
build-enum-methods (function)
build-enum-predicate (function)
build-enum-tag-defstruct (function)
build-enum-tag-method (function)
build-enum-tag-methods (function)
build-enum-tag-slot-readers (function)
canonicalize-tags-specs (function)
enum-constructor-arguments (function)
enum-designator (type)
enum-id-map (function)
(setf enum-id-map) (function)
enum-length (function)
enum-p (function)
enum-tags (function)
get-tag-from-id (function)
(setf get-tag-from-id) (function)
make-method-spec (function)
make-tag-spec (function)
method-spec-args (function)
method-spec-body (function)
method-spec-method-keyword (function)
method-spec-name (function)
method-spec-quals (function)
new-symbol (function)
parse-method-spec (function)
tag (structure)
tag-designator (type)
tag-enum (function)
tag-name-internal (function)
tag-spec-args (function)
tag-spec-id (function)
tag-spec-methods (function)
tag-spec-tag (function)

4 Packages

Packages are listed by definition order.

4.1 `it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum`

The package containing the DEFENUM reference implementation.

Source

defenum-package.lisp (file)

Nicknames

enum-types
cl.ext.defenum
common-lisp.extensions.defenum
defenum

Use List

common-lisp

Exported Definitions

defenum (macro)
enum (structure)
enum-name (function)
find-enum (function)
(setf find-enum) (function)
next-enum-tag (function)
nth-enum-tag (function)
previous-enum-tag (function)
tag-name (function)
tag-of (function)
tag-p (function)
tags (function)

Internal Definitions

%tag-enum (function)
(setf %tag-enum) (function)
%tag-name (function)
%tag-p (function)
*enums-namespace* (special variable)
build-enum-defstruct (function)
build-enum-deftype (function)
build-enum-fixnum-method (function)
build-enum-function (function)
build-enum-initialization (function)
build-enum-method (function)
build-enum-method-body (function)
build-enum-method-redispatch-body (function)
build-enum-methods (function)
build-enum-predicate (function)
build-enum-tag-defstruct (function)
build-enum-tag-method (function)
build-enum-tag-methods (function)
build-enum-tag-slot-readers (function)
canonicalize-tags-specs (function)
copy-destructuring-lambda-list (function)
copy-generic-function-lambda-list (function)
copy-lambda-list-item (function)
copy-lambda-list-var (function)
copy-macro-lambda-list (function)
copy-method-spec (function)
copy-ordinary-lambda-list (function)
copy-specialized-lambda-list (function)
copy-tag-spec (function)
destructuring-lambda-list (structure)
destructuring-lambda-list-allow-other-keys (function)
destructuring-lambda-list-auxiliary-vars (function)
destructuring-lambda-list-keyword-vars (function)
destructuring-lambda-list-optional-vars (function)
destructuring-lambda-list-ordinary-vars (function)
destructuring-lambda-list-p (function)
destructuring-lambda-list-rest-var (function)
enum-constructor-arguments (function)
enum-designator (type)
enum-id-map (function)
(setf enum-id-map) (function)
enum-length (function)
enum-p (function)
enum-tags (function)
generic-function-lambda-list (structure)
generic-function-lambda-list-allow-other-keys (function)
generic-function-lambda-list-auxiliary-vars (function)
generic-function-lambda-list-keyword-vars (function)
generic-function-lambda-list-optional-vars (function)
generic-function-lambda-list-ordinary-vars (function)
generic-function-lambda-list-p (function)
generic-function-lambda-list-rest-var (function)
get-tag-from-id (function)
(setf get-tag-from-id) (function)
lambda-list-item (structure)
lambda-list-item-p (function)
lambda-list-type (type)
lambda-list-var (structure)
lambda-list-var-p (function)
lambda-list-var-type (type)
ll-allow-other-keys (function)
ll-auxiliary-vars (function)
ll-keyword-vars (function)
ll-optional-vars (function)
ll-ordinary-vars (function)
ll-recall (generic function)
ll-recall (method)
ll-rest-var (function)
ll-vars (generic function)
ll-vars (method)
ll-vars (method)
ll-vars (method)
ll-vars (method)
lli-form (function)
lli-item (function)
lli-kind (function)
lli-name (function)
llv-form (function)
llv-item (function)
llv-kind (function)
llv-name (function)
macro-lambda-list (structure)
macro-lambda-list-allow-other-keys (function)
macro-lambda-list-auxiliary-vars (function)
macro-lambda-list-body-var (function)
macro-lambda-list-env-var (function)
macro-lambda-list-keyword-vars (function)
macro-lambda-list-optional-vars (function)
macro-lambda-list-ordinary-vars (function)
macro-lambda-list-p (function)
macro-lambda-list-rest-var (function)
macro-lambda-list-whole-var (function)
make-destructuring-lambda-list (function)
make-generic-function-lambda-list (function)
make-macro-lambda-list (function)
make-method-spec (function)
make-ordinary-lambda-list (function)
make-specialized-lambda-list (function)
make-tag-spec (function)
method-spec-args (function)
method-spec-body (function)
method-spec-method-keyword (function)
method-spec-name (function)
method-spec-quals (function)
mkllitem (function)
mkllvar (function)
new-symbol (function)
ordinary-lambda-list (structure)
ordinary-lambda-list-allow-other-keys (function)
ordinary-lambda-list-auxiliary-vars (function)
ordinary-lambda-list-keyword-vars (function)
ordinary-lambda-list-optional-vars (function)
ordinary-lambda-list-ordinary-vars (function)
ordinary-lambda-list-p (function)
ordinary-lambda-list-rest-var (function)
parse-ll (generic function)
parse-ll (method)
parse-ll (method)
parse-ll (method)
parse-ll (method)
parse-ll (method)
parse-method-spec (function)
pll (function)
specialized-lambda-list (structure)
specialized-lambda-list-allow-other-keys (function)
specialized-lambda-list-auxiliary-vars (function)
specialized-lambda-list-keyword-vars (function)
specialized-lambda-list-optional-vars (function)
specialized-lambda-list-ordinary-vars (function)
specialized-lambda-list-p (function)
specialized-lambda-list-rest-var (function)
t_lambda-list (structure)
t_lambda-list-p (function)
tag (structure)
tag-designator (type)
tag-enum (function)
tag-name-internal (function)
tag-spec-args (function)
tag-spec-id (function)
tag-spec-methods (function)
tag-spec-tag (function)

5 Definitions

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

5.1 Exported definitions

5.1.1 Macros

Macro: defenum NAME (&rest TAGS-SPECS) &optional SLOTS &rest OPTIONS-AND-METHODS

The DEFENUM macro defines an extended enumerated type in the environment.

The extended enumerated types are called ’enums’ and are akin to
both C/C++ and Java (5.0 and later) enums. The main idea is to provide an enumerated type with symbolic tags and auxiliary
functionality in order to make this concept available in Common Lisp.

The DEFENUM macro is the entry point to the enum type’s definition.
The syntax accommodates both simple and sophisticated cases.

NAME names the enum type and eventually also a
function that maps ’tags’ to their ’implementation’. Tags can be
’simple’, i.e., symbolic, or ’structured’, in which case they are
actually structure objects that are themselves the ’range’ of an
implicit ’map’ with symbols in the ’domain’.

TAGS-SPECS is a list of tag specifications (tag-spec). A tag-spec has
the following (Common Lisp) syntax:

<pre>
tag-spec ::= SYMBOL
| (SYMBOL)
| (SYMBOL N)
| (SYMBOL (&rest args) &rest tag-methods)
| (SYMBOL N (&rest args) &rest tag-methods)
</pre>

Each SYMBOL is the symbolic tag. N is an integer constant. The first
three forms are the ’simple’ case, which corresponds to the
traditional C/C++ case. The other two cases correspond to
the ’structured’ case. ’args’ is a list of arguments to be passed
to the structured tag constructor. ’tag-methods’ is a list of method
specs similar to the ’enum methods’ specified in OPTIONS-AND-METHODS (see below) that will be EQL-specialized on the symbolic and associated fixnum
values; these method specifications admit a simplified lambda
argument list, which has an implicit first argument provided by DEFENUM.

SLOTS is a list of ’slot specifications’ like those in DEFSTRUCT.
Specifing any slot ensures that the implementation will generate a
number of specialized functions and methods that will be able to deal
with ’structured tags’. Each slot has a ’slot-name’ and is specified as read-only. Each slot has a reader named NAME-slot-name; all slots are automatically declared ’read only’.

OPTIONS-AND-METHODS is a list of ’options’ and ’enum methods’. The options are lists with a keyword in first position. The only option
recognized at this time is :DOCUMENTATION, with a second argument a
(doc) string, which will be associated to the enum type. The ’enum
methods’ specifications have the following form:

<pre>
enum-meth-spec ::= (:method M-NAME QUAL* ARGS &BODY M-BODY)
</pre>

M-NAME is the method name, QUAL is a method qualifier (zero or more),
ARGS is a specialized lambda-list, whose first argument is treated specially, and M-BODY is a normal method body. The first argument of
the lambda list is treated specially if it is specialized on T (cfr.,
not specialized) or it is specialized on the enum type NAME.
References to slot names in M-BODY are substituted with appropriate
calls to the slot reader functions.

Arguments and Values:

NAME : a SYMBOL.
TAG-SPECS : a list of ’enum tags’ specifications.
SLOTS : a list of ’slot specifications’.
OPTIONS-AND-METHODS : a list of ’options’ and (enum specific) ’methods’.

Examples:

cl-prompt> (defenum seasons (spring summer autumn winter))
#<ENUM SEASONS (SPRING SUMMER AUTUMN WINTER)>

cl-prompt> (seasons ’spring)
SPRING

cl-prompt> winter
3

cl-prompt> (seasons-p ’winter)
T

cl-prompt> (seasons winter) ; No quote.
WINTER

cl-prompt> (defenum operation
((PLUS () (:method evaluate (x y) (+ x y)))
(MINUS () (:method evaluate (x y) (- x y)))
(TIMES () (:method evaluate (x y) (* x y)))
(DIVIDE () (:method evaluate (x y) (/ x y))) ))
#<ENUM OPERATION (PLUS MINUS TIMES DIVIDE)>

cl-prompt> (typep ’divide ’operation)
T

cl-prompt> (evaluate times 2 pi)
6.283185307179586D0

cl-prompt> (evaluate ’plus 40 2)
42

cl-prompt> (defenum (colors (:initargs (r g b)))
((red (255 0 0))
(green (0 255 0))
(blue (0 0 255))
(white (255 255 255))
(black (0 0 0))
)
((r 0 :type (integer 0 255) :read-only t)
(g 0 :type (integer 0 255) :read-only t)
(b 0 :type (integer 0 255) :read-only t) )
(:documentation "The Colors Enum."))
#<ENUM COLORS (RED GREEN BLUE WHITE BLACK)>

cl-prompt> (colors-r red)
255

cl-prompt> (colors-g white)
255

cl-prompt> (documentation ’colors ’type)
"The Colors Enum."

cl-prompt> (previous-enum-tag ’colors ’green)
#<COLORS TAG RED>

cl-prompt> (previous-enum-tag ’colors *)
NIL

Notes:

The DEFENUM macro is inspired by Java ’enum’ classes; it offers
all the facilities of the Java version, while also retaining the C/C++
’enum tags are integers’ feature.

The use of the DEFENUM enumeration types has some limitations, due, of course, to Common Lisp’s slack typing and a few implementation choices.

The slot name references in the enum and tag methods are done via SYMBOL-MACROLET.

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

5.1.2 Functions

Function: enum-name INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: find-enum NAME &optional ERRORP ENVIRONMENT

Finds an enum with name NAME in the system.

FIND-ENUM behaves like FIND-CLASS. If ERRORP is true and no enum is found in the system an error is signaled. ENVIRONMENT is present for symmetry with FIND-CLASS and it is currently unused.

Arguments and Values:

NAME : a SYMBOL
ERRORP : a generalized boolean
ENVIRONMENT : an environment object (or NIL)
result : an ENUM instance or NIL.

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)
Writer: (setf find-enum) (function)

Function: (setf find-enum) ENUM-OBJECT NAME &optional ERRORP ENVIRONMENT

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)
Reader: find-enum (function)

Function: next-enum-tag E TAG

Given a tag designator TAG, returns the ’next’ tag in the enum E or NIL.

Arguments and Values:

enum : an enum designator (either an ENUM object or a SYMBOL).
tag : a tag designator (either a TAG object or a SYMBOL) or a FIXNUM. result : a tag designator or NIL.

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: nth-enum-tag N ENUM

Returns the N-th tag in enum ENUM.

Arguments and Values:

N : a FIXNUM
ENUM : an enum designator (either an ENUM object or a SYMBOL). result1 : a tag designator.
result2 : whether a tag was actually found.

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: previous-enum-tag E TAG

Given a tag designator TAG, returns the ’previous’ tag in the enum E or NIL.

Arguments and Values:

enum : an enum designator (either an ENUM object or a SYMBOL). tag : a tag designator (either a TAG object or a SYMBOL) or a FIXNUM. result : a tag designator or NIL.

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: tag-name E

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: tag-of E TAG &optional ERRORP

Returns the tag object designated by TAG in enum E.

Arguments and Values:

E : an enum designator (either an ENUM object or a SYMBOL).
TAG : a tag designator (either a TAG object or a SYMBOL) or a FIXNUM. ERRORP : a boolean.
RESULT : a tag designator.

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: tag-p S

Checks whether the argument is a valid tag for an enum.

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: tags E

Returns the tags of an enum.

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

5.1.3 Structures

Structure: enum ()

The (abstract) Enum Structure.

Every enum will be derived from this structure, which cannot be instantiated. All enums will be singletons and stored in an ’enum namespace’.

Package

it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum

Source

defenum.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots

Slot: name

Type: symbol
Readers: enum-name (function)
Writers: (setf enum-name) (function)

Slot: tags

Type: list
Readers: enum-tags (function)
Writers: (setf enum-tags) (function)

Slot: constructor-arguments

Type: list
Readers: enum-constructor-arguments (function)
Writers: (setf enum-constructor-arguments) (function)

Slot: length

Type: fixnum
Initform: 0
Readers: enum-length (function)
Writers: (setf enum-length) (function)

Slot: id-map

Initform: (make-hash-table :test (function eql))
Readers: enum-id-map (function)
Writers: (setf enum-id-map) (function)

5.2 Internal definitions

5.2.1 Special variables

Special Variable: *enums-namespace*

The ’enum namespace’.

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

5.2.2 Functions

Function: %tag-enum INSTANCE

Function: (setf %tag-enum) VALUE INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: %tag-name INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: %tag-p OBJECT

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: build-enum-defstruct NAME ENUM-DEFSTRUCT-NAME ENUM-DEFSTRUCT-CONS-NAME

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: build-enum-deftype NAME TAGS DOCUMENTATION

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: build-enum-fixnum-method NAME M

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: build-enum-function NAME

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: build-enum-initialization NAME SYMBOLIC-TAGS-P ENUM-DEFSTRUCT-CONS-NAME TAG-DEFSTRUCT-CONS-NAME TAGS-SPECS

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: build-enum-method NAME M TAG-DEFSTRUCT-NAME SLOT-NAMES SLOT-ACCESSORS

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: build-enum-method-body NAME SELF-VARIABLE SLOT-NAMES SLOT-ACCESSORS M-BODY

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: build-enum-method-redispatch-body NAME METHOD-NAME TAG-SELF-VAR ARGS

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: build-enum-methods NAME METHODS TAG-DEFSTRUCT-NAME TAG-NAMES TAG-SPECS SLOTS

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: build-enum-predicate NAME

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: build-enum-tag-defstruct ENUM-NAME TAG-DEFSTRUCT-NAME TAG-DEFSTRUCT-CONS-NAME SYMBOLIC-TAGS-P INITARGS SLOTS

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: build-enum-tag-method NAME M TAG-DEFSTRUCT-NAME TAG

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: build-enum-tag-methods NAME M TAG-DEFSTRUCT-NAME TAGS-NAMES TAGS-METHODS-TABLE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: build-enum-tag-slot-readers NAME TAGS TAG-DEFSTRUCT-NAME SLOTS

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: canonicalize-tags-specs TAGS-SPECS

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: copy-destructuring-lambda-list INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: copy-generic-function-lambda-list INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: copy-lambda-list-item INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: copy-lambda-list-var INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: copy-macro-lambda-list INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: copy-method-spec SEQUENCE

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

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: SYS:SRC;CODE;SEQ.LISP (not found)

Function: copy-ordinary-lambda-list INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: copy-specialized-lambda-list INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: copy-tag-spec SEQUENCE

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

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: SYS:SRC;CODE;SEQ.LISP (not found)

Function: destructuring-lambda-list-allow-other-keys INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: destructuring-lambda-list-auxiliary-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: destructuring-lambda-list-keyword-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: destructuring-lambda-list-optional-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: destructuring-lambda-list-ordinary-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: destructuring-lambda-list-p OBJECT

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: destructuring-lambda-list-rest-var INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: enum-constructor-arguments INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: enum-id-map INSTANCE

Function: (setf enum-id-map) VALUE INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: enum-length INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: enum-p OBJECT

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: enum-tags INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: generic-function-lambda-list-allow-other-keys INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: generic-function-lambda-list-auxiliary-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: generic-function-lambda-list-keyword-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: generic-function-lambda-list-optional-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: generic-function-lambda-list-ordinary-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: generic-function-lambda-list-p OBJECT

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: generic-function-lambda-list-rest-var INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: get-tag-from-id ENUM ID

Function: (setf get-tag-from-id) TAG ENUM ID

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: lambda-list-item-p OBJECT

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: lambda-list-var-p OBJECT

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: ll-allow-other-keys INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: ll-auxiliary-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: ll-keyword-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: ll-optional-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: ll-ordinary-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: ll-rest-var INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: lli-form INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: lli-item INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: lli-kind INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: lli-name LLI

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: llv-form INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: llv-item INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: llv-kind INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: llv-name LLI

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: macro-lambda-list-allow-other-keys INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: macro-lambda-list-auxiliary-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: macro-lambda-list-body-var INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: macro-lambda-list-env-var INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: macro-lambda-list-keyword-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: macro-lambda-list-optional-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: macro-lambda-list-ordinary-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: macro-lambda-list-p OBJECT

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: macro-lambda-list-rest-var INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: macro-lambda-list-whole-var INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: make-destructuring-lambda-list &optional ORDINARY-VARS OPTIONAL-VARS REST-VAR KEYWORD-VARS ALLOW-OTHER-KEYS AUXILIARY-VARS

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: make-generic-function-lambda-list &optional ORDINARY-VARS OPTIONAL-VARS REST-VAR KEYWORD-VARS ALLOW-OTHER-KEYS AUXILIARY-VARS

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: make-macro-lambda-list &optional WHOLE-VAR ENV-VAR ORDINARY-VARS OPTIONAL-VARS REST-VAR BODY-VAR KEYWORD-VARS ALLOW-OTHER-KEYS AUXILIARY-VARS

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: make-method-spec NAME QUALS ARGS &rest BODY

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: make-ordinary-lambda-list &optional ORDINARY-VARS OPTIONAL-VARS REST-VAR KEYWORD-VARS ALLOW-OTHER-KEYS AUXILIARY-VARS

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: make-specialized-lambda-list &optional ORDINARY-VARS OPTIONAL-VARS REST-VAR KEYWORD-VARS ALLOW-OTHER-KEYS AUXILIARY-VARS

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: make-tag-spec TAG ID &optional ARGS &rest METHODS

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: method-spec-args STRUCTURE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: method-spec-body STRUCTURE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: method-spec-method-keyword STRUCTURE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: method-spec-name STRUCTURE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: method-spec-quals STRUCTURE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: mkllitem ITEM KIND &optional FORM

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: mkllvar ITEM KIND &optional FORM

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: new-symbol TEMPLATE &rest ARGS

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: ordinary-lambda-list-allow-other-keys INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: ordinary-lambda-list-auxiliary-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: ordinary-lambda-list-keyword-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: ordinary-lambda-list-optional-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: ordinary-lambda-list-ordinary-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: ordinary-lambda-list-p OBJECT

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: ordinary-lambda-list-rest-var INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: parse-method-spec MS

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: pll LL-TYPE LL &optional RECUR

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: specialized-lambda-list-allow-other-keys INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: specialized-lambda-list-auxiliary-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: specialized-lambda-list-keyword-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: specialized-lambda-list-optional-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: specialized-lambda-list-ordinary-vars INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: specialized-lambda-list-p OBJECT

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: specialized-lambda-list-rest-var INSTANCE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: t_lambda-list-p OBJECT

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Function: tag-enum TD &optional ERRORP

Returns the enum type where the tag designator TD belongs.

If TD is not a tag in an enum and ERRORP is non-NIL, an error is signaled. Otherwise NIL is returned.

Arguments and Values:

TD : a ’tag designator’
ERRORP : a generalized boolean (default NIL).
result : the ENUM object or NULL

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: tag-name-internal E

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: tag-spec-args STRUCTURE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: tag-spec-id STRUCTURE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: tag-spec-methods STRUCTURE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Function: tag-spec-tag STRUCTURE

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

5.2.3 Generic functions

Generic Function: ll-recall LL

Produces an ’actual’ argument list using the lambda list variables.

This function is useful in order to write code transformers. It
produces a proper argument list suitable for use with APPLY.

Examples:

cl-prompt> (ll-recall (parse-ll :ordinary
’(a b &optional (c 42) &key (baz 42) &aux (foo 123)))) (A B C :BAZ BAZ ())

cl-prompt> (ll-recall (parse-ll :ordinary
’(a b &rest more)))
(A B MORE)

cl-prompt> (ll-recall (parse-ll :ordinary
’(a b &rest keys &key (foo 42))))
(A B :FOO FOO KEYS)

Package

it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum

Source

lambda-list-parsing.lisp (file)

Methods

Method: ll-recall (LL t_lambda-list)

Generic Function: ll-vars LL

Package

it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum

Source

lambda-list-parsing.lisp (file)

Methods

Method: ll-vars (LL macro-lambda-list)

Method: ll-vars (LL destructuring-lambda-list)

Method: ll-vars (LLI lambda-list-item)

Method: ll-vars (LL t_lambda-list)

Generic Function: parse-ll LLTYPE LL

Package

it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum

Source

lambda-list-parsing.lisp (file)

Methods

Method: parse-ll (LLTYPE (eql macro)) LL

Method: parse-ll (LLTYPE (eql destructuring)) LL

Method: parse-ll (LLTYPE (eql generic-function)) LL

Method: parse-ll (LLTYPE (eql specialized)) LL

Method: parse-ll (LLTYPE (eql ordinary)) LL

5.2.4 Structures

Structure: destructuring-lambda-list ()

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)
Direct superclasses: t_lambda-list (structure)
Direct subclasses: macro-lambda-list (structure)
Direct methods: ll-vars (method)

Structure: generic-function-lambda-list ()

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)
Direct superclasses: t_lambda-list (structure)

Structure: lambda-list-item ()

Package

it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum

Source

lambda-list-parsing.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses

lambda-list-var (structure)

Direct methods

ll-vars (method)

Direct slots

Slot: item

Type: (or symbol it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum::t_lambda-list list)
Readers: lli-item (function)
Writers: (setf lli-item) (function)

Slot: kind

Type: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum::lambda-list-var-type
Initform: (quote it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum::&reqvar)
Readers: lli-kind (function)
Writers: (setf lli-kind) (function)

Slot: form

Type: (or symbol cons)
Readers: lli-form (function)
Writers: (setf lli-form) (function)

Structure: lambda-list-var ()

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)
Direct superclasses: lambda-list-item (structure)

Structure: macro-lambda-list ()

Package

it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum

Source

lambda-list-parsing.lisp (file)

Direct superclasses

destructuring-lambda-list (structure)

Direct methods

ll-vars (method)

Direct slots

Slot: whole-var

Type: list
Readers: macro-lambda-list-whole-var (function)
Writers: (setf macro-lambda-list-whole-var) (function)

Slot: env-var

Type: list
Readers: macro-lambda-list-env-var (function)
Writers: (setf macro-lambda-list-env-var) (function)

Slot: body-var

Type: list
Readers: macro-lambda-list-body-var (function)
Writers: (setf macro-lambda-list-body-var) (function)

Structure: ordinary-lambda-list ()

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)
Direct superclasses: t_lambda-list (structure)

Structure: specialized-lambda-list ()

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)
Direct superclasses: t_lambda-list (structure)

Structure: t_lambda-list ()

Package

it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum

Source

lambda-list-parsing.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses

destructuring-lambda-list (structure)
ordinary-lambda-list (structure)
specialized-lambda-list (structure)
generic-function-lambda-list (structure)

Direct methods

ll-recall (method)
ll-vars (method)

Direct slots

Slot: ordinary-vars

Type: list
Readers: ll-ordinary-vars (function)
Writers: (setf ll-ordinary-vars) (function)

Slot: optional-vars

Type: list
Readers: ll-optional-vars (function)
Writers: (setf ll-optional-vars) (function)

Slot: keyword-vars

Type: list
Readers: ll-keyword-vars (function)
Writers: (setf ll-keyword-vars) (function)

Slot: rest-var

Type: list
Readers: ll-rest-var (function)
Writers: (setf ll-rest-var) (function)

Slot: auxiliary-vars

Type: list
Readers: ll-auxiliary-vars (function)
Writers: (setf ll-auxiliary-vars) (function)

Slot: allow-other-keys

Type: boolean
Readers: ll-allow-other-keys (function)
Writers: (setf ll-allow-other-keys) (function)

Structure: tag ()

Package

it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum

Source

defenum.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots

Slot: enum

Type: symbol
Readers: %tag-enum (function)
Writers: (setf %tag-enum) (function)

Slot: name

Type: symbol
Readers: %tag-name (function)
Writers: (setf %tag-name) (function)

5.2.5 Types

Type: enum-designator ()

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Type: lambda-list-type ()

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Type: lambda-list-var-type ()

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: lambda-list-parsing.lisp (file)

Type: tag-designator ()

Package: it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum
Source: defenum.lisp (file)

Appendix A Indexes

A.1 Concepts

Jump to:	D F L

	Index Entry	Section

D
	`defenum.asd`:	The defenum․asd file
	`defenum/defenum-package.lisp`:	The defenum/defenum-package․lisp file
	`defenum/defenum.lisp`:	The defenum/defenum․lisp file
	`defenum/lambda-list-parsing.lisp`:	The defenum/lambda-list-parsing․lisp file

F
	File, Lisp, `defenum.asd`:	The defenum․asd file
	File, Lisp, `defenum/defenum-package.lisp`:	The defenum/defenum-package․lisp file
	File, Lisp, `defenum/defenum.lisp`:	The defenum/defenum․lisp file
	File, Lisp, `defenum/lambda-list-parsing.lisp`:	The defenum/lambda-list-parsing․lisp file

L
	Lisp File, `defenum.asd`:	The defenum․asd file
	Lisp File, `defenum/defenum-package.lisp`:	The defenum/defenum-package․lisp file
	Lisp File, `defenum/defenum.lisp`:	The defenum/defenum․lisp file
	Lisp File, `defenum/lambda-list-parsing.lisp`:	The defenum/lambda-list-parsing․lisp file

Jump to:	D F L

A.2 Functions

Jump to:	% ( B C D E F G L M N O P S T

	Index Entry	Section

%
	`%tag-enum`:	Internal functions
	`%tag-name`:	Internal functions
	`%tag-p`:	Internal functions

(
	`(setf %tag-enum)`:	Internal functions
	`(setf enum-id-map)`:	Internal functions
	`(setf find-enum)`:	Exported functions
	`(setf get-tag-from-id)`:	Internal functions

B
	`build-enum-defstruct`:	Internal functions
	`build-enum-deftype`:	Internal functions
	`build-enum-fixnum-method`:	Internal functions
	`build-enum-function`:	Internal functions
	`build-enum-initialization`:	Internal functions
	`build-enum-method`:	Internal functions
	`build-enum-method-body`:	Internal functions
	`build-enum-method-redispatch-body`:	Internal functions
	`build-enum-methods`:	Internal functions
	`build-enum-predicate`:	Internal functions
	`build-enum-tag-defstruct`:	Internal functions
	`build-enum-tag-method`:	Internal functions
	`build-enum-tag-methods`:	Internal functions
	`build-enum-tag-slot-readers`:	Internal functions

C
	`canonicalize-tags-specs`:	Internal functions
	`copy-destructuring-lambda-list`:	Internal functions
	`copy-generic-function-lambda-list`:	Internal functions
	`copy-lambda-list-item`:	Internal functions
	`copy-lambda-list-var`:	Internal functions
	`copy-macro-lambda-list`:	Internal functions
	`copy-method-spec`:	Internal functions
	`copy-ordinary-lambda-list`:	Internal functions
	`copy-specialized-lambda-list`:	Internal functions
	`copy-tag-spec`:	Internal functions

D
	`defenum`:	Exported macros
	`destructuring-lambda-list-allow-other-keys`:	Internal functions
	`destructuring-lambda-list-auxiliary-vars`:	Internal functions
	`destructuring-lambda-list-keyword-vars`:	Internal functions
	`destructuring-lambda-list-optional-vars`:	Internal functions
	`destructuring-lambda-list-ordinary-vars`:	Internal functions
	`destructuring-lambda-list-p`:	Internal functions
	`destructuring-lambda-list-rest-var`:	Internal functions

E
	`enum-constructor-arguments`:	Internal functions
	`enum-id-map`:	Internal functions
	`enum-length`:	Internal functions
	`enum-name`:	Exported functions
	`enum-p`:	Internal functions
	`enum-tags`:	Internal functions

F
	`find-enum`:	Exported functions
	`Function, %tag-enum`:	Internal functions
	`Function, %tag-name`:	Internal functions
	`Function, %tag-p`:	Internal functions
	`Function, (setf %tag-enum)`:	Internal functions
	`Function, (setf enum-id-map)`:	Internal functions
	`Function, (setf find-enum)`:	Exported functions
	`Function, (setf get-tag-from-id)`:	Internal functions
	`Function, build-enum-defstruct`:	Internal functions
	`Function, build-enum-deftype`:	Internal functions
	`Function, build-enum-fixnum-method`:	Internal functions
	`Function, build-enum-function`:	Internal functions
	`Function, build-enum-initialization`:	Internal functions
	`Function, build-enum-method`:	Internal functions
	`Function, build-enum-method-body`:	Internal functions
	`Function, build-enum-method-redispatch-body`:	Internal functions
	`Function, build-enum-methods`:	Internal functions
	`Function, build-enum-predicate`:	Internal functions
	`Function, build-enum-tag-defstruct`:	Internal functions
	`Function, build-enum-tag-method`:	Internal functions
	`Function, build-enum-tag-methods`:	Internal functions
	`Function, build-enum-tag-slot-readers`:	Internal functions
	`Function, canonicalize-tags-specs`:	Internal functions
	`Function, copy-destructuring-lambda-list`:	Internal functions
	`Function, copy-generic-function-lambda-list`:	Internal functions
	`Function, copy-lambda-list-item`:	Internal functions
	`Function, copy-lambda-list-var`:	Internal functions
	`Function, copy-macro-lambda-list`:	Internal functions
	`Function, copy-method-spec`:	Internal functions
	`Function, copy-ordinary-lambda-list`:	Internal functions
	`Function, copy-specialized-lambda-list`:	Internal functions
	`Function, copy-tag-spec`:	Internal functions
	`Function, destructuring-lambda-list-allow-other-keys`:	Internal functions
	`Function, destructuring-lambda-list-auxiliary-vars`:	Internal functions
	`Function, destructuring-lambda-list-keyword-vars`:	Internal functions
	`Function, destructuring-lambda-list-optional-vars`:	Internal functions
	`Function, destructuring-lambda-list-ordinary-vars`:	Internal functions
	`Function, destructuring-lambda-list-p`:	Internal functions
	`Function, destructuring-lambda-list-rest-var`:	Internal functions
	`Function, enum-constructor-arguments`:	Internal functions
	`Function, enum-id-map`:	Internal functions
	`Function, enum-length`:	Internal functions
	`Function, enum-name`:	Exported functions
	`Function, enum-p`:	Internal functions
	`Function, enum-tags`:	Internal functions
	`Function, find-enum`:	Exported functions
	`Function, generic-function-lambda-list-allow-other-keys`:	Internal functions
	`Function, generic-function-lambda-list-auxiliary-vars`:	Internal functions
	`Function, generic-function-lambda-list-keyword-vars`:	Internal functions
	`Function, generic-function-lambda-list-optional-vars`:	Internal functions
	`Function, generic-function-lambda-list-ordinary-vars`:	Internal functions
	`Function, generic-function-lambda-list-p`:	Internal functions
	`Function, generic-function-lambda-list-rest-var`:	Internal functions
	`Function, get-tag-from-id`:	Internal functions
	`Function, lambda-list-item-p`:	Internal functions
	`Function, lambda-list-var-p`:	Internal functions
	`Function, ll-allow-other-keys`:	Internal functions
	`Function, ll-auxiliary-vars`:	Internal functions
	`Function, ll-keyword-vars`:	Internal functions
	`Function, ll-optional-vars`:	Internal functions
	`Function, ll-ordinary-vars`:	Internal functions
	`Function, ll-rest-var`:	Internal functions
	`Function, lli-form`:	Internal functions
	`Function, lli-item`:	Internal functions
	`Function, lli-kind`:	Internal functions
	`Function, lli-name`:	Internal functions
	`Function, llv-form`:	Internal functions
	`Function, llv-item`:	Internal functions
	`Function, llv-kind`:	Internal functions
	`Function, llv-name`:	Internal functions
	`Function, macro-lambda-list-allow-other-keys`:	Internal functions
	`Function, macro-lambda-list-auxiliary-vars`:	Internal functions
	`Function, macro-lambda-list-body-var`:	Internal functions
	`Function, macro-lambda-list-env-var`:	Internal functions
	`Function, macro-lambda-list-keyword-vars`:	Internal functions
	`Function, macro-lambda-list-optional-vars`:	Internal functions
	`Function, macro-lambda-list-ordinary-vars`:	Internal functions
	`Function, macro-lambda-list-p`:	Internal functions
	`Function, macro-lambda-list-rest-var`:	Internal functions
	`Function, macro-lambda-list-whole-var`:	Internal functions
	`Function, make-destructuring-lambda-list`:	Internal functions
	`Function, make-generic-function-lambda-list`:	Internal functions
	`Function, make-macro-lambda-list`:	Internal functions
	`Function, make-method-spec`:	Internal functions
	`Function, make-ordinary-lambda-list`:	Internal functions
	`Function, make-specialized-lambda-list`:	Internal functions
	`Function, make-tag-spec`:	Internal functions
	`Function, method-spec-args`:	Internal functions
	`Function, method-spec-body`:	Internal functions
	`Function, method-spec-method-keyword`:	Internal functions
	`Function, method-spec-name`:	Internal functions
	`Function, method-spec-quals`:	Internal functions
	`Function, mkllitem`:	Internal functions
	`Function, mkllvar`:	Internal functions
	`Function, new-symbol`:	Internal functions
	`Function, next-enum-tag`:	Exported functions
	`Function, nth-enum-tag`:	Exported functions
	`Function, ordinary-lambda-list-allow-other-keys`:	Internal functions
	`Function, ordinary-lambda-list-auxiliary-vars`:	Internal functions
	`Function, ordinary-lambda-list-keyword-vars`:	Internal functions
	`Function, ordinary-lambda-list-optional-vars`:	Internal functions
	`Function, ordinary-lambda-list-ordinary-vars`:	Internal functions
	`Function, ordinary-lambda-list-p`:	Internal functions
	`Function, ordinary-lambda-list-rest-var`:	Internal functions
	`Function, parse-method-spec`:	Internal functions
	`Function, pll`:	Internal functions
	`Function, previous-enum-tag`:	Exported functions
	`Function, specialized-lambda-list-allow-other-keys`:	Internal functions
	`Function, specialized-lambda-list-auxiliary-vars`:	Internal functions
	`Function, specialized-lambda-list-keyword-vars`:	Internal functions
	`Function, specialized-lambda-list-optional-vars`:	Internal functions
	`Function, specialized-lambda-list-ordinary-vars`:	Internal functions
	`Function, specialized-lambda-list-p`:	Internal functions
	`Function, specialized-lambda-list-rest-var`:	Internal functions
	`Function, tag-enum`:	Internal functions
	`Function, tag-name`:	Exported functions
	`Function, tag-name-internal`:	Internal functions
	`Function, tag-of`:	Exported functions
	`Function, tag-p`:	Exported functions
	`Function, tag-spec-args`:	Internal functions
	`Function, tag-spec-id`:	Internal functions
	`Function, tag-spec-methods`:	Internal functions
	`Function, tag-spec-tag`:	Internal functions
	`Function, tags`:	Exported functions
	`Function, t_lambda-list-p`:	Internal functions

G
	`Generic Function, ll-recall`:	Internal generic functions
	`Generic Function, ll-vars`:	Internal generic functions
	`Generic Function, parse-ll`:	Internal generic functions
	`generic-function-lambda-list-allow-other-keys`:	Internal functions
	`generic-function-lambda-list-auxiliary-vars`:	Internal functions
	`generic-function-lambda-list-keyword-vars`:	Internal functions
	`generic-function-lambda-list-optional-vars`:	Internal functions
	`generic-function-lambda-list-ordinary-vars`:	Internal functions
	`generic-function-lambda-list-p`:	Internal functions
	`generic-function-lambda-list-rest-var`:	Internal functions
	`get-tag-from-id`:	Internal functions

L
	`lambda-list-item-p`:	Internal functions
	`lambda-list-var-p`:	Internal functions
	`ll-allow-other-keys`:	Internal functions
	`ll-auxiliary-vars`:	Internal functions
	`ll-keyword-vars`:	Internal functions
	`ll-optional-vars`:	Internal functions
	`ll-ordinary-vars`:	Internal functions
	`ll-recall`:	Internal generic functions
	`ll-recall`:	Internal generic functions
	`ll-rest-var`:	Internal functions
	`ll-vars`:	Internal generic functions
	`ll-vars`:	Internal generic functions
	`ll-vars`:	Internal generic functions
	`ll-vars`:	Internal generic functions
	`ll-vars`:	Internal generic functions
	`lli-form`:	Internal functions
	`lli-item`:	Internal functions
	`lli-kind`:	Internal functions
	`lli-name`:	Internal functions
	`llv-form`:	Internal functions
	`llv-item`:	Internal functions
	`llv-kind`:	Internal functions
	`llv-name`:	Internal functions

M
	`Macro, defenum`:	Exported macros
	`macro-lambda-list-allow-other-keys`:	Internal functions
	`macro-lambda-list-auxiliary-vars`:	Internal functions
	`macro-lambda-list-body-var`:	Internal functions
	`macro-lambda-list-env-var`:	Internal functions
	`macro-lambda-list-keyword-vars`:	Internal functions
	`macro-lambda-list-optional-vars`:	Internal functions
	`macro-lambda-list-ordinary-vars`:	Internal functions
	`macro-lambda-list-p`:	Internal functions
	`macro-lambda-list-rest-var`:	Internal functions
	`macro-lambda-list-whole-var`:	Internal functions
	`make-destructuring-lambda-list`:	Internal functions
	`make-generic-function-lambda-list`:	Internal functions
	`make-macro-lambda-list`:	Internal functions
	`make-method-spec`:	Internal functions
	`make-ordinary-lambda-list`:	Internal functions
	`make-specialized-lambda-list`:	Internal functions
	`make-tag-spec`:	Internal functions
	`Method, ll-recall`:	Internal generic functions
	`Method, ll-vars`:	Internal generic functions
	`Method, ll-vars`:	Internal generic functions
	`Method, ll-vars`:	Internal generic functions
	`Method, ll-vars`:	Internal generic functions
	`Method, parse-ll`:	Internal generic functions
	`Method, parse-ll`:	Internal generic functions
	`Method, parse-ll`:	Internal generic functions
	`Method, parse-ll`:	Internal generic functions
	`Method, parse-ll`:	Internal generic functions
	`method-spec-args`:	Internal functions
	`method-spec-body`:	Internal functions
	`method-spec-method-keyword`:	Internal functions
	`method-spec-name`:	Internal functions
	`method-spec-quals`:	Internal functions
	`mkllitem`:	Internal functions
	`mkllvar`:	Internal functions

N
	`new-symbol`:	Internal functions
	`next-enum-tag`:	Exported functions
	`nth-enum-tag`:	Exported functions

O
	`ordinary-lambda-list-allow-other-keys`:	Internal functions
	`ordinary-lambda-list-auxiliary-vars`:	Internal functions
	`ordinary-lambda-list-keyword-vars`:	Internal functions
	`ordinary-lambda-list-optional-vars`:	Internal functions
	`ordinary-lambda-list-ordinary-vars`:	Internal functions
	`ordinary-lambda-list-p`:	Internal functions
	`ordinary-lambda-list-rest-var`:	Internal functions

P
	`parse-ll`:	Internal generic functions
	`parse-ll`:	Internal generic functions
	`parse-ll`:	Internal generic functions
	`parse-ll`:	Internal generic functions
	`parse-ll`:	Internal generic functions
	`parse-ll`:	Internal generic functions
	`parse-method-spec`:	Internal functions
	`pll`:	Internal functions
	`previous-enum-tag`:	Exported functions

S
	`specialized-lambda-list-allow-other-keys`:	Internal functions
	`specialized-lambda-list-auxiliary-vars`:	Internal functions
	`specialized-lambda-list-keyword-vars`:	Internal functions
	`specialized-lambda-list-optional-vars`:	Internal functions
	`specialized-lambda-list-ordinary-vars`:	Internal functions
	`specialized-lambda-list-p`:	Internal functions
	`specialized-lambda-list-rest-var`:	Internal functions

T
	`tag-enum`:	Internal functions
	`tag-name`:	Exported functions
	`tag-name-internal`:	Internal functions
	`tag-of`:	Exported functions
	`tag-p`:	Exported functions
	`tag-spec-args`:	Internal functions
	`tag-spec-id`:	Internal functions
	`tag-spec-methods`:	Internal functions
	`tag-spec-tag`:	Internal functions
	`tags`:	Exported functions
	`t_lambda-list-p`:	Internal functions

Jump to:	% ( B C D E F G L M N O P S T

A.3 Variables

Jump to:	* A B C E F I K L N O R S T W

	Index Entry	Section

*
	`enums-namespace`:	Internal special variables

A
	`allow-other-keys`:	Internal structures
	`auxiliary-vars`:	Internal structures

B
	`body-var`:	Internal structures

C
	`constructor-arguments`:	Exported structures

E
	`enum`:	Internal structures
	`env-var`:	Internal structures

F
	`form`:	Internal structures

I
	`id-map`:	Exported structures
	`item`:	Internal structures

K
	`keyword-vars`:	Internal structures
	`kind`:	Internal structures

L
	`length`:	Exported structures

N
	`name`:	Exported structures
	`name`:	Internal structures

O
	`optional-vars`:	Internal structures
	`ordinary-vars`:	Internal structures

R
	`rest-var`:	Internal structures

S
	`Slot, allow-other-keys`:	Internal structures
	`Slot, auxiliary-vars`:	Internal structures
	`Slot, body-var`:	Internal structures
	`Slot, constructor-arguments`:	Exported structures
	`Slot, enum`:	Internal structures
	`Slot, env-var`:	Internal structures
	`Slot, form`:	Internal structures
	`Slot, id-map`:	Exported structures
	`Slot, item`:	Internal structures
	`Slot, keyword-vars`:	Internal structures
	`Slot, kind`:	Internal structures
	`Slot, length`:	Exported structures
	`Slot, name`:	Exported structures
	`Slot, name`:	Internal structures
	`Slot, optional-vars`:	Internal structures
	`Slot, ordinary-vars`:	Internal structures
	`Slot, rest-var`:	Internal structures
	`Slot, tags`:	Exported structures
	`Slot, whole-var`:	Internal structures
	`Special Variable, enums-namespace`:	Internal special variables

T
	`tags`:	Exported structures

W
	`whole-var`:	Internal structures

Jump to:	* A B C E F I K L N O R S T W

A.4 Data types

Jump to:	D E G I L M O P S T

	Index Entry	Section

D
	`defenum`:	The defenum system
	`destructuring-lambda-list`:	Internal structures

E
	`enum`:	Exported structures
	`enum-designator`:	Internal types

G
	`generic-function-lambda-list`:	Internal structures

I
	`it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum`:	The it․unimib․disco․ma․common-lisp․extensions․data-and-control-flow․defenum package

L
	`lambda-list-item`:	Internal structures
	`lambda-list-type`:	Internal types
	`lambda-list-var`:	Internal structures
	`lambda-list-var-type`:	Internal types

M
	`macro-lambda-list`:	Internal structures

O
	`ordinary-lambda-list`:	Internal structures

P
	`Package, it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum`:	The it․unimib․disco․ma․common-lisp․extensions․data-and-control-flow․defenum package

S
	`specialized-lambda-list`:	Internal structures
	`Structure, destructuring-lambda-list`:	Internal structures
	`Structure, enum`:	Exported structures
	`Structure, generic-function-lambda-list`:	Internal structures
	`Structure, lambda-list-item`:	Internal structures
	`Structure, lambda-list-var`:	Internal structures
	`Structure, macro-lambda-list`:	Internal structures
	`Structure, ordinary-lambda-list`:	Internal structures
	`Structure, specialized-lambda-list`:	Internal structures
	`Structure, tag`:	Internal structures
	`Structure, t_lambda-list`:	Internal structures
	`System, defenum`:	The defenum system

T
	`tag`:	Internal structures
	`tag-designator`:	Internal types
	`Type, enum-designator`:	Internal types
	`Type, lambda-list-type`:	Internal types
	`Type, lambda-list-var-type`:	Internal types
	`Type, tag-designator`:	Internal types
	`t_lambda-list`:	Internal structures

Jump to:	D E G I L M O P S T

• Introduction		What defenum is all about
• Systems		The systems documentation
• Files		The files documentation
• Packages		The packages documentation
• Definitions		The symbols documentation
• Indexes		Concepts, functions, variables and data types

• The defenum.asd file
• The defenum/defenum-package.lisp file
• The defenum/lambda-list-parsing.lisp file
• The defenum/defenum.lisp file

• Internal special variables
• Internal functions
• Internal generic functions
• Internal structures
• Internal types

• Concept index
• Function index
• Variable index
• Data type index

• Exported macros
• Exported functions
• Exported structures

The defenum Reference Manual

Table of Contents

The defenum Reference Manual

1 Introduction

2 Systems

2.1 defenum

3 Files

3.1 Lisp

3.1.1 defenum.asd

3.1.2 defenum/defenum-package.lisp

3.1.3 defenum/lambda-list-parsing.lisp

3.1.4 defenum/defenum.lisp

4 Packages

4.1 it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum

5 Definitions

5.1 Exported definitions

5.1.1 Macros

5.1.2 Functions

5.1.3 Structures

5.2 Internal definitions

5.2.1 Special variables

5.2.2 Functions

5.2.3 Generic functions

5.2.4 Structures

5.2.5 Types

Appendix A Indexes

A.1 Concepts

A.2 Functions

A.3 Variables

A.4 Data types

2.1 `defenum`

3.1.1 `defenum.asd`

3.1.2 `defenum/defenum-package.lisp`

3.1.3 `defenum/lambda-list-parsing.lisp`

3.1.4 `defenum/defenum.lisp`

4.1 `it.unimib.disco.ma.common-lisp.extensions.data-and-control-flow.defenum`