The let-plus Reference Manual

Table of Contents

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

The let-plus Reference Manual

This is the let-plus Reference Manual, version 0.2, generated automatically by Declt version 2.3 "Robert April" on Tue Jan 09 15:01:57 2018 GMT+0.


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

1 Introduction

#+TITLE: =let+=: destructuring extension of =let*=
#+AUTHOR: Tamás K. Papp

This library implements the =let+= macro, which is a dectructuring
extension of =let*=.

* Highlights

- clean, consistent syntax and small implementation (less than 300 LOC, not counting tests)

- placeholder macros allow editor hints and syntax highlighting

- =&ign= for ignored values (in forms where that makes sense)

- very easy to extend

* Similar libraries

This library was inspired by Gary King's excellent [[http://common-lisp.net/project/metabang-bind/][metabang-bind]].  I
have been using the latter for years now, but at some point I decided
to write a library of my own, aiming for a cleaner syntax, more
concise implementation and a more consistent interface (whether I have
succeeded is of course a matter of judgement --- try [[http://common-lisp.net/project/metabang-bind/][metabang-bind]] to
see if you like it better).

In my opinion the main advantages of this library, compared to
[[http://common-lisp.net/project/metabang-bind/][metabang-bind]], are the placeholder macros which provide editor hints
and the more consistent syntax of destructuring forms.  In particular,
when both read-write and read-only forms are available the latter
always have the =-r/o= suffix, =&flet= and =&labels= resemble the
Common Lisp syntax more closely, and the library should be easier to
extend.

You can find other pattern matching libraries on [[http://www.cliki.net/pattern%20matching][cliki]].

* Syntax

#+BEGIN_SRC lisp
let+ ({binding}*) body*
#+END_SRC
where
#+BEGIN_SRC lisp
binding ::= symbol || (form [init-form])
#+END_SRC

=LET+= is recursive: each binding is in the scope of the previous
ones.  Forms ignore =&ign= variables (where applicable).

** Built-in forms

Forms which provide both read-write and read-only access are available as =&form= and =&form-r/o=.  The first one always uses symbol macros, so you can use =setf=.  The second one reads the values at the beginning of the list from value: you can change these variables after that without having any effect on the original value.  Read-only forms may also provide a slight increase in speed, and promote good style --- you can use them to signal that you will not change the original structure.

The following forms are defined:

- =var=, =(var)=, =(var value)= :: These behave just like they do in =let*=.

- =(list value)= :: When =list= is not recognized as any of the forms below, it is simply destructured using =destructuring-bind=.  =&ign= are ignored.  Example:
#+BEGIN_SRC lisp
(let+ (((a (b &optional (c 3)) &ign &key (d 1 d?)) '(1 (2) 7 :d 4)))
  (list a b c d d?))  ; => (1 2 3 4 T)
#+END_SRC

- =((&slots slot*) value)=, also =&slots-r/o= :: Similarly to =with-slots=, each =slot= has the syntax =variable= or =(variable)= (for these, the variable name is also used for the slot name) or =(variable slot-name)=.  =&slots-r/o= provides read-only bindings.

     Example:
#+BEGIN_SRC lisp
(defclass foo-class ()
  ((a :accessor a :initarg :a)
   (b :accessor b-accessor :initarg :b)))

(let+ (((&slots a (my-b b)) (make-instance 'foo-class :a 1 :b 2)))
  (list a my-b))  ; => (1 2)
#+END_SRC

- =((&accessors accessor*) value)=, also =&accessors-r/o= :: Syntax similar to =&slots=, but uses accessors.  Continuing the example above:
#+BEGIN_SRC lisp
(let+ (((&accessors a (b b-accessor)) (make-instance 'foo-class :a 1 :b 2)))
  (list a b))  ; => (1 2)
#+END_SRC

- =((&structure conc-name slot*) value)=, also =&structure-r/o= :: Slot access for structures.  =Conc-name= is prepended to the accessors (you need to include the =-= if there is one).  Example:
#+BEGIN_SRC lisp
(defstruct foo-struct c d)
(let+ (((&structure foo-struct- c (my-d d)) (make-foo-struct :c 3 :d 4)))
  (list c my-d))  ; => (3 4)
#+END_SRC

- =((&values value*) form)= :: Similar to =multiple-value-bind=.  =&ign= are ignored.  Example:
#+BEGIN_SRC lisp
(let+ (((&values a &ign b) (values 1 2 3)))
  (list a b))  ; => (1 3)
#+END_SRC

- =(array value)= (only read-only version) :: The array is
     destructured to the given elements, =&ign= are ignored.  Indexes
     use row-major access, determined at macroexpansion time.
     Example:
#+BEGIN_SRC lisp
(let+ ((#(a &ign b) (vector 1 2 3)))
  (list a b))  ; => (1 3)
#+END_SRC

- =((&array-elements (variable subscript*)*) value)=, also =&array-elements-r/o= :: Array elements with given subscripts are assigned to the variables.  Example:
#+BEGIN_SRC lisp
(let+ (((&array-elements (a 0 1)
                         (b 2 0))
        #2A((0 1)
            (2 3)
            (4 5))))
  (list a b))  ; => (1 4)
#+END_SRC

- =((&flet name lambda-list forms*))=, also =&labels= :: Function bindings.  These have no value form. =&labels= allows the function to refer to itself -- note that since =let+= is always recursive, this is the only difference between the two forms.  Example:
#+BEGIN_SRC lisp
(let+ (((&flet add2 (x)
          (+ x 2))))
  (add2 5))  ; => 7
#+END_SRC

- =((&plist (variable key [default])*)=, also =&plist-r/o= :: Access to property lists.  When =key= is not given, =variable= is used instead, and =default= is used if the element does not exist in the value (note that default may be evaluated multiple times when using the read-write form which uses =symbol-macrolet=).  Example:
#+BEGIN_SRC lisp
(let+ (((&plist a (my-b b) (c nil 3)) '(a 1 b 2)))
  (list a my-b c))  ; => (1 2 3)
#+END_SRC

- =(((&hash-table (variable key [default])*)=, also =&hash-table-r/o= :: Access to the elements of hash tables, the semantics is the same as =&plist=.

- =(&complex real imaginary)= :: Destructures complex numbers.

** Nesting

You can nest =let+= expressions when it makes sense (it doesn't always, especially for read/write slots, the read only form should work).  For example,
#+BEGIN_SRC lisp
(let+ ((#((&complex a b)) (vector (complex 1 2))))
  (list a b))
#+END_SRC
should destructure the complex number that is the single element in the vector.

If you find that =let+= does not nest properly, please report it as a bug.

** Convenience macros

- =(defun+ name (argument*) form*)=, also =(lambda (argument*) form*)= :: Work like =defun= and =lambda=, but arguments are destructured using =let+=.  Example:
#+BEGIN_SRC lisp
(defun+ foo ((&plist a b c) #(d e))
  (list a b c d e))

(foo '(a 1 b 2 c 3) #(4 5))  ; => (1 2 3 4 5)
#+END_SRC
See also =&labels+= and =&lambda+=.

- =define-structure-let+= :: Can be used to provide destructuring forms for structures.

** Other forms

- =(&once-only symbols ...)= and =(&with-gensyms symbols)= are useful for writing macros.

* Extensions

Extending =let-plus= is very easy: if you want to use a form that
resembles a list, you just have to define a method for
=let+-expansion-for-list=.  There is a macro that helps you with that,
called =define-let+-expansion=.  If the library didn't have
=&complex=, we could define destructuring for the form like this:

#+BEGIN_SRC lisp
(define-let+-expansion (&complex (x y))
  "Access real and imaginary part of the value.  Read-only."
  `(let ((,x (realpart ,value))
         (,y (imagpart ,value)))
     ,@body))
#+END_SRC
Some highlights:

- this macro defines a "placeholder" macro =&complex= that should
  help with editor hints, but has no other purpose (it is not used in
  the expansion),
- the macro is anaphoric, capturing =value= (the value form) and
  =body= (the body inside the =let+= form), you can customize both of
  this using keyword arguments,
- unless required otherwise, =value= is wrapped in =once-only=
  preventing multiple evaluations of the same form.  See the arguments =:uses-value?= and =:once-only?= for =define-let+-expansion=.

If you want to extend =let+= with forms that are not lists (eg like
the array syntax above), have a look at =let+-expansion=.

* Reporting bugs

Please open an [[https://github.com/sharplispers/let-plus/issues][issue]] on Github for bugs.  Extensions are also welcome,
either as forks or small code snippets submitted as issues.  Wishlist
items are also welcome!

I ask you not to report bugs via e-mail if you can avoid it.  Tracking
bugs on Github makes it less likely that they get lost.


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

2 Systems

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


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

2.1 let-plus

Maintainer

Sharp Lispers <sharplispers@googlegroups.com>

Author

Tamas K. Papp <tkpapp@gmail.com>

License

Boost Software License - Version 1.0

Description

Destructuring extension of LET*.

Version

0.2

Dependencies
Source

let-plus.asd (file)

Components

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

3 Files

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


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

3.1 Lisp


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

3.1.1 let-plus.asd

Location

let-plus.asd

Systems

let-plus (system)


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

3.1.2 let-plus/package.lisp

Parent

let-plus (system)

Location

package.lisp

Packages

let-plus


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

3.1.3 let-plus/let-plus.lisp

Dependency

package.lisp (file)

Parent

let-plus (system)

Location

let-plus.lisp

Exported Definitions
Internal Definitions

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

3.1.4 let-plus/extensions.lisp

Dependency

let-plus.lisp (file)

Parent

let-plus (system)

Location

extensions.lisp

Exported Definitions
Internal Definitions

destructured-lambda-list-forms (function)


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

4 Packages

Packages are listed by definition order.


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

4.1 let-plus

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Macros

Macro: &accessors &rest ACCESSORS

LET+ form, similar to WITH-ACCESSORS.

Package

let-plus

Source

let-plus.lisp (file)

Macro: &accessors-r/o &rest ACCESSORS

LET+ form, similar to WITH-ACCESSORS, but read-only.

Package

let-plus

Source

let-plus.lisp (file)

Macro: &array-elements &rest ARRAY-ELEMENTS

LET+ form, mapping (variable &rest subscripts) specifications to array-elements. VARIABLE is an accessor, which can be used for reading and writing array elements.

Package

let-plus

Source

let-plus.lisp (file)

Macro: &array-elements-r/o &rest ARRAY-ELEMENTS

LET+ form, mapping (variable &rest subscripts) specifications to array-elements. Read-only accessor, values assigned to VARIABLEs.

Package

let-plus

Source

let-plus.lisp (file)

Macro: &complex X Y

Access real and imaginary part of the value. Read-only.

Package

let-plus

Source

extensions.lisp (file)

Macro: &flet FUNCTION-NAME LAMBDA-LIST &body FUNCTION-BODY

LET+ form for function definitions. Expands into an FLET.

Package

let-plus

Source

let-plus.lisp (file)

Macro: &flet+ FUNCTION-NAME LAMBDA-LIST &body FUNCTION-BODY

&FLET that destructures its arguments using LET+.

Package

let-plus

Source

extensions.lisp (file)

Macro: &fwrap NAME

Wrap closure in the local function NAME. Calls to NAME will call the closure.

Package

let-plus

Source

extensions.lisp (file)

Macro: &hash-table &rest ENTRIES

LET+ form for hash tables. Each entry is (variable &optional key default).

Package

let-plus

Source

let-plus.lisp (file)

Macro: &hash-table-r/o &rest ENTRIES

LET+ form for hash tables. Each entry is (variable &optional key default). Read only version.

Package

let-plus

Source

let-plus.lisp (file)

Macro: &labels FUNCTION-NAME LAMBDA-LIST &body FUNCTION-BODY

LET+ form for function definitions. Expands into an LABELS, thus allowing recursive functions.

Package

let-plus

Source

let-plus.lisp (file)

Macro: &labels+ FUNCTION-NAME LAMBDA-LIST &body FUNCTION-BODY

&LABELS that destructures its arguments using LET+.

Package

let-plus

Source

extensions.lisp (file)

Macro: &macrolet MACRO-NAME LAMBDA-LIST &body MACRO-BODY

LET+ form for local macro definitions. Expands into an MACROLET.

Package

let-plus

Source

let-plus.lisp (file)

Macro: &once-only &rest SPECS

Expand to (ONCE-ONLY SPECS ...).

Package

let-plus

Source

extensions.lisp (file)

Macro: &plist &rest ENTRIES

LET+ form for property lists. Each entry is (variable &optional key default).

Package

let-plus

Source

let-plus.lisp (file)

Macro: &plist-r/o &rest ENTRIES

LET+ form for property lists, read only version. Each entry is (variable &optional key default).

Package

let-plus

Source

let-plus.lisp (file)

Macro: &slots &rest SLOTS

LET+ form, similar to WITH-SLOTS.

Package

let-plus

Source

let-plus.lisp (file)

Macro: &slots-r/o &rest SLOTS

LET+ form, similar to WITH-SLOTS but read-only.

Package

let-plus

Source

let-plus.lisp (file)

Macro: &structure CONC-NAME &rest SLOTS

LET+ form for slots of a structure, with accessors generated using CONC-NAME.

Package

let-plus

Source

let-plus.lisp (file)

Macro: &structure-r/o CONC-NAME &rest SLOTS

LET+ form for slots of a structure, with accessors generated using CONC-NAME. Read-only version.

Package

let-plus

Source

let-plus.lisp (file)

Macro: &symbol-macrolet SYMBOL EXPANSION

LET+ form for local symbol macros. Expands into a SYMBOL-MACROLET.

Package

let-plus

Source

let-plus.lisp (file)

Macro: &values &rest VALUES

LET+ form for multiple values.

Package

let-plus

Source

let-plus.lisp (file)

Macro: &with-gensyms &rest NAMES

Expand to (WITH-GENSYMS NAMES ...).

Package

let-plus

Source

extensions.lisp (file)

Macro: define-let+-expansion (NAME ARGUMENTS &key VALUE-VAR BODY-VAR USES-VALUE? ONCE-ONLY?) &body BODY

Define an expansion for LET+ forms which are lists, starting with NAME. ARGUMENTS is destructured if a list. A placeholder macro is defined with NAME, using DOCSTRING and ARGUMENTS. The value form is bound to VALUE-VAR (wrapped in ONCE-ONLY when ONCE-ONLY?), while the body is bound to BODY-VAR. USES-VALUE? determines if the form uses a value, and generates the appropriate checks.

Package

let-plus

Source

let-plus.lisp (file)

Macro: define-structure-let+ (NAME &key CONC-NAME R/W R/O) &rest SLOT-NAMES

Define a LET+ expansion for accessing slots of a structure in a fixed order.

Package

let-plus

Source

extensions.lisp (file)

Macro: defun+ NAME LAMBDA-LIST &body BODY

DEFUN that destructures its arguments using LET+.

Package

let-plus

Source

extensions.lisp (file)

Macro: lambda+ LAMBDA-LIST &body BODY

LAMBDA that destructures its arguments using LET+.

Package

let-plus

Source

extensions.lisp (file)

Macro: let+ BINDINGS &body BODY

Destructuring bindings. See the documentation of the LET-PLUS library. Most accepted forms start with &.

Package

let-plus

Source

let-plus.lisp (file)


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

5.1.2 Generic functions

Generic Function: let+-expansion FORM VALUE BODY

Return an expansion for a LET+ form.

Package

let-plus

Source

let-plus.lisp (file)

Methods
Method: let+-expansion (ARRAY array) VALUE BODY

LET+ expansion for mapping array elements to variables.

Method: let+-expansion FORM VALUE BODY
Method: let+-expansion (VARIABLE null) VALUE BODY
Method: let+-expansion (VARIABLE symbol) VALUE BODY
Method: let+-expansion (FORM list) VALUE BODY
Generic Function: let+-expansion-for-list FIRST REST VALUE BODY

LET+-EXPANSION calls this for lists, see the latter for semantics of returned values.

Package

let-plus

Source

let-plus.lisp (file)

Methods
Method: let+-expansion-for-list (FIRST (eql &complex)) ARGUMENTS0 VALUE BODY
Source

extensions.lisp (file)

Method: let+-expansion-for-list (FIRST (eql &with-gensyms)) ARGUMENTS0 VALUE BODY
Source

extensions.lisp (file)

Method: let+-expansion-for-list (FIRST (eql &once-only)) ARGUMENTS0 VALUE BODY
Source

extensions.lisp (file)

Method: let+-expansion-for-list (FIRST (eql &fwrap)) ARGUMENTS0 VALUE BODY
Source

extensions.lisp (file)

Method: let+-expansion-for-list (FIRST (eql &labels+)) ARGUMENTS0 VALUE BODY
Source

extensions.lisp (file)

Method: let+-expansion-for-list (FIRST (eql &flet+)) ARGUMENTS0 VALUE BODY
Source

extensions.lisp (file)

Method: let+-expansion-for-list (FIRST (eql &hash-table-r/o)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list (FIRST (eql &hash-table)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list (FIRST (eql &plist-r/o)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list (FIRST (eql &plist)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list (FIRST (eql &symbol-macrolet)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list (FIRST (eql &macrolet)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list (FIRST (eql &labels)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list (FIRST (eql &flet)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list (FIRST (eql &array-elements-r/o)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list (FIRST (eql &array-elements)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list (FIRST (eql &values)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list (FIRST (eql &structure-r/o)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list (FIRST (eql &structure)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list (FIRST (eql &slots-r/o)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list (FIRST (eql &slots)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list (FIRST (eql &accessors-r/o)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list (FIRST (eql &accessors)) ARGUMENTS0 VALUE BODY
Method: let+-expansion-for-list FIRST REST VALUE BODY

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

5.2 Internal definitions


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

5.2.1 Functions

Function: &-symbol? SYMBOL

Test whether the symbol’s name starts with a & character.

Package

let-plus

Source

let-plus.lisp (file)

Function: destructured-lambda-list-forms LAMBDA-LIST BODY

Return a list that can be spliced into function definitions (eg DEFUN, LAMBDA, FLET, LABELS).

The list starts with a lambda list, and is followed by a docstring (when provided), then a LET+ form that wraps declarations (when provided) and BODY.

Used internally, not exported.

Package

let-plus

Source

extensions.lisp (file)

Function: expand-array-elements VALUE ARRAY-ELEMENTS &optional ACCESSOR

Expand a list of (BINDING &REST SUBSCRIPTS) forms to a list of bindings of the form (ACCESSOR VALUE SUBSCRIPTS).

Package

let-plus

Source

let-plus.lisp (file)

Function: expand-entry-forms ENTRIES ACCESSOR-GENERATOR

Return a list of expanded bindings from ENTRIES, calling (ACESSOR-GENERATOR KEY DEFAULT). Each entry is (VARIABLE &OPTIONAL KEY DEFAULT). When KEY is NIL, VARIABLE is used.

Package

let-plus

Source

let-plus.lisp (file)

Function: expand-slot-forms SLOTS ACCESSOR-GENERATOR

Return a list of expanded bindings, calling (ACCESSOR-GENERATOR KEY)

Package

let-plus

Source

let-plus.lisp (file)

Function: ignored? SYMBOL

Return a boolean determining if a variable is to be ignored.

NOTE: It is unlikely that you need to used this function, see the note above its definition.

Package

let-plus

Source

let-plus.lisp (file)

Function: replace-ignored TREE

Replace ignored variables in TREE with a gensym, return a list of these as the second value.

NOTE: It is unlikely that you need to used this function, see the note above its definition.

Package

let-plus

Source

let-plus.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L  
Index Entry  Section

F
File, Lisp, let-plus.asd: The let-plus<dot>asd file
File, Lisp, let-plus/extensions.lisp: The let-plus/extensions<dot>lisp file
File, Lisp, let-plus/let-plus.lisp: The let-plus/let-plus<dot>lisp file
File, Lisp, let-plus/package.lisp: The let-plus/package<dot>lisp file

L
let-plus.asd: The let-plus<dot>asd file
let-plus/extensions.lisp: The let-plus/extensions<dot>lisp file
let-plus/let-plus.lisp: The let-plus/let-plus<dot>lisp file
let-plus/package.lisp: The let-plus/package<dot>lisp file
Lisp File, let-plus.asd: The let-plus<dot>asd file
Lisp File, let-plus/extensions.lisp: The let-plus/extensions<dot>lisp file
Lisp File, let-plus/let-plus.lisp: The let-plus/let-plus<dot>lisp file
Lisp File, let-plus/package.lisp: The let-plus/package<dot>lisp file

Jump to:   F   L  

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

A.2 Functions

Jump to:   &  
D   E   F   G   I   L   M   R  
Index Entry  Section

&
&-symbol?: Internal functions
&accessors: Exported macros
&accessors-r/o: Exported macros
&array-elements: Exported macros
&array-elements-r/o: Exported macros
&complex: Exported macros
&flet: Exported macros
&flet+: Exported macros
&fwrap: Exported macros
&hash-table: Exported macros
&hash-table-r/o: Exported macros
&labels: Exported macros
&labels+: Exported macros
&macrolet: Exported macros
&once-only: Exported macros
&plist: Exported macros
&plist-r/o: Exported macros
&slots: Exported macros
&slots-r/o: Exported macros
&structure: Exported macros
&structure-r/o: Exported macros
&symbol-macrolet: Exported macros
&values: Exported macros
&with-gensyms: Exported macros

D
define-let+-expansion: Exported macros
define-structure-let+: Exported macros
defun+: Exported macros
destructured-lambda-list-forms: Internal functions

E
expand-array-elements: Internal functions
expand-entry-forms: Internal functions
expand-slot-forms: Internal functions

F
Function, &-symbol?: Internal functions
Function, destructured-lambda-list-forms: Internal functions
Function, expand-array-elements: Internal functions
Function, expand-entry-forms: Internal functions
Function, expand-slot-forms: Internal functions
Function, ignored?: Internal functions
Function, replace-ignored: Internal functions

G
Generic Function, let+-expansion: Exported generic functions
Generic Function, let+-expansion-for-list: Exported generic functions

I
ignored?: Internal functions

L
lambda+: Exported macros
let+: Exported macros
let+-expansion: Exported generic functions
let+-expansion: Exported generic functions
let+-expansion: Exported generic functions
let+-expansion: Exported generic functions
let+-expansion: Exported generic functions
let+-expansion: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions
let+-expansion-for-list: Exported generic functions

M
Macro, &accessors: Exported macros
Macro, &accessors-r/o: Exported macros
Macro, &array-elements: Exported macros
Macro, &array-elements-r/o: Exported macros
Macro, &complex: Exported macros
Macro, &flet: Exported macros
Macro, &flet+: Exported macros
Macro, &fwrap: Exported macros
Macro, &hash-table: Exported macros
Macro, &hash-table-r/o: Exported macros
Macro, &labels: Exported macros
Macro, &labels+: Exported macros
Macro, &macrolet: Exported macros
Macro, &once-only: Exported macros
Macro, &plist: Exported macros
Macro, &plist-r/o: Exported macros
Macro, &slots: Exported macros
Macro, &slots-r/o: Exported macros
Macro, &structure: Exported macros
Macro, &structure-r/o: Exported macros
Macro, &symbol-macrolet: Exported macros
Macro, &values: Exported macros
Macro, &with-gensyms: Exported macros
Macro, define-let+-expansion: Exported macros
Macro, define-structure-let+: Exported macros
Macro, defun+: Exported macros
Macro, lambda+: Exported macros
Macro, let+: Exported macros
Method, let+-expansion: Exported generic functions
Method, let+-expansion: Exported generic functions
Method, let+-expansion: Exported generic functions
Method, let+-expansion: Exported generic functions
Method, let+-expansion: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions
Method, let+-expansion-for-list: Exported generic functions

R
replace-ignored: Internal functions

Jump to:   &  
D   E   F   G   I   L   M   R  

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

A.3 Variables


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

A.4 Data types

Jump to:   L   P   S  
Index Entry  Section

L
let-plus: The let-plus system
let-plus: The let-plus package

P
Package, let-plus: The let-plus package

S
System, let-plus: The let-plus system

Jump to:   L   P   S