The context-lite Reference Manual

Table of Contents

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

The context-lite Reference Manual

This is the context-lite Reference Manual, version 0.1.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Wed Oct 13 10:34:56 2021 GMT+0.


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

1 Introduction

#+TITLE: Context Lite

Context Lite is a Common Lisp library for writing generic functions and methods that specialize on
special/dynamic variables. For instance, if you are writing a method that should behave differently
on Monday, but you do not wish to pass the day of the week as an explicit argument:

#+BEGIN_SRC lisp
  (defvar *day-of-week* nil)

  (defmethod* motd () ()
    "It's boring today.")
  (defmethod* motd () ((*day-of-week* (eql 'monday))
    "It's Monday!!!")

  (let ((*day-of-week* 'monday))
    (motd) ; => "It's Monday!!!"
    )
#+END_SRC

Context Lite is in the same vein as [[https://github.com/pcostanza/contextl][ContextL]], but focuses only on generic functions and methods, not
class slots or anything else. Additionally, Context Lite thinks in terms of special variables, while
ContextL uses "layers", which are less natural in my opinion.

A major feature of Context Lite is that ~defmethod*~ forms can specialize on special variables that
were not mentioned in ~defgeneric*~ or any previous ~defmethod*~. Thus, a library author who is
exporting a Context Lite generic function need not know which special variables the library's
consumers will specialize on.

Context Lite methods can handle a mix of "normal" arguments and special variables, with separate
precedence orders.

* Installation
  Context Lite is available on Ultralisp and will soon be available on Quicklisp.
* Usage
  Context lite exports 2 macros: ~defgeneric*~ and ~defmethod*~. Read the docstrings to learn how to
  use them. There's also an ~ensure-generic*-function~ which is similar to
  ~ensure-generic-function~, but you probably shouldn't use it.

  Pulled from ~tests.lisp~:

  #+BEGIN_SRC lisp
    (defvar *indicator* nil)

    (defmethod* do-the-thing (a) ()
      0)
    (defmethod* do-the-thing (a) ((*indicator* (eql :active)))
      1)
    (defmethod* do-the-thing ((a string)) ((*indicator* number))
      2)

    (is (= 0 (do-the-thing "hello")))
    (is (= 0 (let ((*indicator* 42)) (do-the-thing 999))))
    (is (= 1 (let ((*indicator* :active)) (do-the-thing 5))))
    (is (= 2 (let ((*indicator* 42)) (do-the-thing "heyhi"))))
  #+END_SRC

  Here's another example, demonstrating custom precedence order among the special variable
  arguments:

  #+BEGIN_SRC lisp
    (defvar *a* nil)
    (defvar *b* nil)

    (defmethod* do-the-thing () ((*a* (eql 42)))
      0)
    (defmethod* do-the-thing () ((*b* (eql 42)))
      1)

    (is (= 0 (let ((*a* 42) (*b* 42)) (do-the-thing))))

    (defgeneric* do-the-thing () (:special-variable-precedence-order *b* *a*))

    (is (= 1 (let ((*a* 42) (*b* 42)) (do-the-thing)))))
  #+END_SRC

  ~generic*~ functions can specialize on both normal arguments and on special variables. In this
  case, ~:argument-precedence-order~ and ~:special-variable-precedence-order~ can be supplied
  separately. Normal arguments always get precedence over any special variable.

  Look in ~tests.lisp~ to get a better feel for everything Context Lite can do.
#   Here's an example of how failing to specify the argument precedence can lead to problems:

#   #+BEGIN_SRC lisp
#     (defclass user () ())
#     (defclass admin-user (user) ())

#     (defmethod* colors-alist () ()
#       '((background . "white")
#         (text . "black")
#         (restricted-links . "gray")))

#     (defmethod* colors-alist () ((*logged-in-user* user))
#       "Logged in users who are not admins should have red links"
#       '((background . "white")
#         (text . "black")
#         (restricted-links . "red")))

#     (defmethod* colors-alist () ((*logged-in-user* admin-user))
#       "Admin users should have blue links to restricted parts of the site"
#       (cons '(restricted-links . "blue")
#             (call-next-method)))

#     (defmethod* colors-alist () ((*color-scheme* (eql 'dark)))
#       (append '((background . "black")
#                 (text . "white"))
#               (call-next-method))
#   #+END_SRC

#   The first method to be defined on ~colors-alist~ specializes on ~*logged-in-user*~, so
#   ~*logged-in-user*~ is placed before ~*color-scheme*~ in the argument precedence list. When an
#   admin user with a dark color scheme loads the site, the ~admin-user~ method will run, followed by
#   the ~user~ method, but the ~(eql 'dark)~ method won't run!

#   The quickest way to fix this is to add a ~defgeneric*~ form that puts ~*color-scheme*~ at a higher
#   precedence, but here's a more elegant way that doesn't depend on precedence at all:

#   #+BEGIN_SRC lisp
#     (defclass user () ())
#     (defclass admin-user (user) ())

#     (defmethod* colors-alist () ()
#       '((background . "white")
#         (text . "black")
#         (restricted-links . "gray")))

#     (defmethod* colors-alist () ((*logged-in-user* user))
#       "Logged in users who are not admins should have red links"
#       (cons '(restricted-links . "red")
#             (call-next-method)))

#     (defmethod* colors-alist () ((*logged-in-user* admin-user))
#       "Admin users should have blue links to restricted parts of the site"
#       (cons '(restricted-links . "blue")
#             (call-next-method)))

#     (defmethod* colors-alist () ((*color-scheme* (eql 'dark)))
#       (append '((background . "black")
#                 (text . "white"))
#               (call-next-method))
#   #+END_SRC

#   Note that it does not matter here which order of precedence the different arguments get. If an
#   admin user has a dark color scheme, it does not matter whether the dark or admin method runs
#   before the other.

#   Precedence issues are not unique to Context Lite, but they're more insidious since methods might
#   not list all the special variables that /other/ methods specialize on in their lambda lists.
** Running Tests
   Load the ~context-lite/test~ system, then eval ~(fiveam:run! 'context-lite/test:context-lite)~.
* Performance
  As you'd expect, Context Lite internally uses CLOS' method dispatch, so performance should be
  pretty good. The biggest cost comes when there is a long chain of next-methods, because Context
  Lite wraps each ~next-method~ in a closure.

  TODO: small benchmark
* What works
  + ~declare~-ations and docstrings.
  + Implicit block around method body with correct name.
  + ~setf~ functions.
  + ~call-next-method~.
  + Method redefinitions overwrite the old one.
  + Argument precedence orders, including interaction between normal and special arguments.
  + Tested in SBCL, CLISP, ECL, CCL, and ABCL. Theoretically should work in any fully MOP-compliant
    implementation (but there's no such thing).
* What doesn't work
  + Impossible to find or remove methods.
  + The generic function will signal an error if a special variable used by any method is unbound.


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 context-lite

Author

Mark Polyakov

License

MIT

Description

A CLOS extension to support specializing methods on special/dynamic variables.

Version

0.1.0

Dependency

closer-mop

Source

context-lite.asd (file)

Component

context-lite.lisp (file)


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 context-lite.asd

Location

context-lite.asd

Systems

context-lite (system)


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

3.1.2 context-lite/context-lite.lisp

Parent

context-lite (system)

Location

context-lite.lisp

Packages

context-lite

Exported Definitions
Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 context-lite

Source

context-lite.lisp (file)

Nickname

clite

Use List

common-lisp

Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Macros

Macro: defgeneric* NAME LAMBDA-LIST &rest OPTIONS

Create or modify a Context Lite generic*-function. Methods defined on a generic* function can specialize on both explicit arguments and the value of special/dynamic variables at call time, enabling context-based programming.

One method* may specialize on a different set of special variables than another method*. That being said, the generic* function does internally store a list of all special variables that are used in any method*, and the order of this list is important – it determines which method*s take precedence over others when multiple method*s are applicable. This "special variable precedence order" can be controlled by providing the :special-variable-precedence-order option to defgeneric*. When this option is specified, the internal list of special variables will be reordered so that the given special variables appear in the given order. You need not mention every special variable used by method*s of the generic* function in :special-variable-precedence-order, but beware that in this case defgeneric* may be forced to change the relative precedence order between the provided special variables and other special variables.

The normal lambda-list precedence is controlled in the same way as for standard generic functions. When multiple method*s that specialize on both their normal arguments and on special variables are applicable, the normal arguments always take precedence.

If not given explicitly, the special variable precedence order is determined like so: Whenever a method* is added, any special variables given in the method*’s special variable lambda list which were not used in any previous method* (or previously provided to :special-variable-precedence-order) are added to the end of the special variable precedence order, in the order given in the special variable lambda list.

See also: defmethod*

Package

context-lite

Source

context-lite.lisp (file)

Macro: defmethod* NAME &rest ARGS

Define or redefine a Context Lite method*. A method* can specialize on both its explicit arguments, and the value of special/dynamic variables at call time. The syntax is much the same as for the standard defmethod, except that a (possibly empty) "special variable lambda list" must be provided immediately after the normal lambda list. The special variable lambda list shall have names of special variables in the place of argument names, and each argument can have class or eql specializers, all with the usual syntax. A method is considered applicable when the explicit arguments match the specializers in the normal lambda list, and when each special variable mentioned in the special variable lambda list matches its specializer. No &optional, &key, etc options are allowed in the special variable lambda list.

Much of the power of Context Lite stems from the fact that the method*s defined on a generic* function may specialize on different sets of special variables. I.e., the special variable lambda list for a method* may include special variables that are not mentioned in the special variable lambda list of any other method* on the same generic* function.

Example:

(defvar *day-of-week* nil)

(defmethod* motd () ()
"It’s boring today.")
(defmethod* motd () ((*day-of-week* (eql ’monday))
"It’s Monday!!!")

(let ((*day-of-week* ’monday))
(motd) ; => "It’s Monday!!!"
)

See the documentation for defgeneric* to learn how precedence order works.

Package

context-lite

Source

context-lite.lisp (file)


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

5.1.2 Functions

Function: ensure-generic*-function FN-NAME &rest INITARGS
Package

context-lite

Source

context-lite.lisp (file)


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

5.2 Internal definitions


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

5.2.1 Functions

Function: combine-special-variable-precedence-ordered OLD-ORDER NEW-ORDER
Package

context-lite

Source

context-lite.lisp (file)

Function: combine-special-variable-precedence-unordered OLD-ORDER NEW-VARS
Package

context-lite

Source

context-lite.lisp (file)

Function: lambda-list-required-arguments LAMBDA-LIST

Given a full lambda list, with specializers, return a list of the required arguments.

Package

context-lite

Source

context-lite.lisp (file)

Function: remove-from-plist PLIST &rest KEYS

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

Package

context-lite

Source

context-lite.lisp (file)


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

5.2.2 Generic functions

Generic Function: add-all-wrapper-methods GF
Package

context-lite

Methods
Method: add-all-wrapper-methods (GF generic*-function)
Source

context-lite.lisp (file)

Generic Function: add-method* GF METHOD
Package

context-lite

Methods
Method: add-method* (GF generic*-function) (METHOD method*)
Source

context-lite.lisp (file)

Generic Function: ensure-generic*-function-using-class GF FN-NAME &rest OPTIONS &key ARGUMENT-PRECEDENCE-ORDER SPECIAL-VARIABLE-PRECEDENCE-ORDER SPECIAL-VARIABLES LAMBDA-LIST GENERIC-FUNCTION-CLASS METHOD-CLASS &allow-other-keys
Package

context-lite

Methods
Method: ensure-generic*-function-using-class (GF generic*-function) FN-NAME &rest OPTIONS &key ARGUMENT-PRECEDENCE-ORDER SPECIAL-VARIABLE-PRECEDENCE-ORDER SPECIAL-VARIABLES LAMBDA-LIST GENERIC-FUNCTION-CLASS METHOD-CLASS &allow-other-keys
Source

context-lite.lisp (file)

Generic Function: generic*-gf OBJECT
Generic Function: (setf generic*-gf) NEW-VALUE OBJECT
Package

context-lite

Methods
Method: generic*-gf (GENERIC*-FUNCTION generic*-function)

automatically generated reader method

Source

context-lite.lisp (file)

Method: (setf generic*-gf) NEW-VALUE (GENERIC*-FUNCTION generic*-function)

automatically generated writer method

Source

context-lite.lisp (file)

Generic Function: generic*-inner-methods OBJECT
Generic Function: (setf generic*-inner-methods) NEW-VALUE OBJECT
Package

context-lite

Methods
Method: generic*-inner-methods (GENERIC*-FUNCTION generic*-function)

automatically generated reader method

Source

context-lite.lisp (file)

Method: (setf generic*-inner-methods) NEW-VALUE (GENERIC*-FUNCTION generic*-function)

automatically generated writer method

Source

context-lite.lisp (file)

Generic Function: generic*-inner-precedence-order GF
Package

context-lite

Methods
Method: generic*-inner-precedence-order (GF generic*-function)
Source

context-lite.lisp (file)

Generic Function: generic*-install-discriminating-function GF
Package

context-lite

Methods
Method: generic*-install-discriminating-function (GF generic*-function)
Source

context-lite.lisp (file)

Generic Function: generic*-name OBJECT
Generic Function: (setf generic*-name) NEW-VALUE OBJECT
Package

context-lite

Methods
Method: generic*-name (GENERIC*-FUNCTION generic*-function)

automatically generated reader method

Source

context-lite.lisp (file)

Method: (setf generic*-name) NEW-VALUE (GENERIC*-FUNCTION generic*-function)

automatically generated writer method

Source

context-lite.lisp (file)

Generic Function: generic*-normal-argument-precedence-order OBJECT
Generic Function: (setf generic*-normal-argument-precedence-order) NEW-VALUE OBJECT
Package

context-lite

Methods
Method: generic*-normal-argument-precedence-order (GENERIC*-FUNCTION generic*-function)

automatically generated reader method

Source

context-lite.lisp (file)

Method: (setf generic*-normal-argument-precedence-order) NEW-VALUE (GENERIC*-FUNCTION generic*-function)

automatically generated writer method

Source

context-lite.lisp (file)

Generic Function: generic*-normal-lambda-list OBJECT
Generic Function: (setf generic*-normal-lambda-list) NEW-VALUE OBJECT
Package

context-lite

Methods
Method: generic*-normal-lambda-list (GENERIC*-FUNCTION generic*-function)

automatically generated reader method

Source

context-lite.lisp (file)

Method: (setf generic*-normal-lambda-list) NEW-VALUE (GENERIC*-FUNCTION generic*-function)

automatically generated writer method

Source

context-lite.lisp (file)

Generic Function: generic*-special-variable-precedence-order OBJECT
Generic Function: (setf generic*-special-variable-precedence-order) NEW-VALUE OBJECT
Package

context-lite

Methods
Method: generic*-special-variable-precedence-order (GENERIC*-FUNCTION generic*-function)

automatically generated reader method

Source

context-lite.lisp (file)

Method: (setf generic*-special-variable-precedence-order) NEW-VALUE (GENERIC*-FUNCTION generic*-function)

automatically generated writer method

Source

context-lite.lisp (file)

Generic Function: generic*-wrapper-method-table OBJECT
Generic Function: (setf generic*-wrapper-method-table) NEW-VALUE OBJECT
Package

context-lite

Methods
Method: generic*-wrapper-method-table (GENERIC*-FUNCTION generic*-function)

automatically generated reader method

Source

context-lite.lisp (file)

Method: (setf generic*-wrapper-method-table) NEW-VALUE (GENERIC*-FUNCTION generic*-function)

automatically generated writer method

Source

context-lite.lisp (file)

Generic Function: method*-special-variables OBJECT
Generic Function: (setf method*-special-variables) NEW-VALUE OBJECT
Package

context-lite

Methods
Method: method*-special-variables (METHOD* method*)
Method: (setf method*-special-variables) NEW-VALUE (METHOD* method*)

The special lambda list, each element (*special-variable-name* . specializer),
where specializer is either a class metaobject or an eql-specializer (just like a normal method specializer)

Source

context-lite.lisp (file)

Generic Function: remove-all-wrapper-methods GF
Package

context-lite

Methods
Method: remove-all-wrapper-methods (GF generic*-function)
Source

context-lite.lisp (file)

Generic Function: wrap-method-function GF METHOD NUM-SPECIAL-VARS
Package

context-lite

Methods
Method: wrap-method-function (GF generic*-function) (METHOD method*) NUM-SPECIAL-VARS
Source

context-lite.lisp (file)

Generic Function: wrapper-method-specializers GF METHOD
Package

context-lite

Methods
Method: wrapper-method-specializers (GF generic*-function) (METHOD method*)

Given a method* and a gf that already has at least all the special variables required by the method*, generate the full specializers list for the wrapper method.

Source

context-lite.lisp (file)


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

5.2.3 Classes

Class: generic*-function ()
Package

context-lite

Source

context-lite.lisp (file)

Direct superclasses

funcallable-standard-object (class)

Direct methods
Direct slots
Slot: name
Initargs

:name

Initform

(error "generic* functions need a :name")

Readers

generic*-name (generic function)

Writers

(setf generic*-name) (generic function)

Slot: normal-lambda-list
Readers

generic*-normal-lambda-list (generic function)

Writers

(setf generic*-normal-lambda-list) (generic function)

Slot: normal-argument-precedence-order
Readers

generic*-normal-argument-precedence-order (generic function)

Writers

(setf generic*-normal-argument-precedence-order) (generic function)

Slot: special-variable-precedence-order
Readers

generic*-special-variable-precedence-order (generic function)

Writers

(setf generic*-special-variable-precedence-order) (generic function)

Slot: inner-methods
Readers

generic*-inner-methods (generic function)

Writers

(setf generic*-inner-methods) (generic function)

Slot: inner-gf
Readers

generic*-gf (generic function)

Writers

(setf generic*-gf) (generic function)

Slot: wrapper-method-table
Initform

(make-hash-table)

Readers

generic*-wrapper-method-table (generic function)

Writers

(setf generic*-wrapper-method-table) (generic function)

Class: method* ()
Package

context-lite

Source

context-lite.lisp (file)

Direct superclasses

standard-method (class)

Direct methods
Direct slots
Slot: special-variables

The special lambda list, each element (*special-variable-name* . specializer),
where specializer is either a class metaobject or an eql-specializer (just like a normal method specializer)

Initargs

:special-variables

Readers

method*-special-variables (generic function)

Writers

(setf method*-special-variables) (generic function)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   C   F   L  
Index Entry  Section

C
context-lite.asd: The context-lite․asd file
context-lite/context-lite.lisp: The context-lite/context-lite․lisp file

F
File, Lisp, context-lite.asd: The context-lite․asd file
File, Lisp, context-lite/context-lite.lisp: The context-lite/context-lite․lisp file

L
Lisp File, context-lite.asd: The context-lite․asd file
Lisp File, context-lite/context-lite.lisp: The context-lite/context-lite․lisp file

Jump to:   C   F   L  

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

A.2 Functions

Jump to:   (  
A   C   D   E   F   G   L   M   R   W  
Index Entry  Section

(
(setf generic*-gf): Internal generic functions
(setf generic*-gf): Internal generic functions
(setf generic*-inner-methods): Internal generic functions
(setf generic*-inner-methods): Internal generic functions
(setf generic*-name): Internal generic functions
(setf generic*-name): Internal generic functions
(setf generic*-normal-argument-precedence-order): Internal generic functions
(setf generic*-normal-argument-precedence-order): Internal generic functions
(setf generic*-normal-lambda-list): Internal generic functions
(setf generic*-normal-lambda-list): Internal generic functions
(setf generic*-special-variable-precedence-order): Internal generic functions
(setf generic*-special-variable-precedence-order): Internal generic functions
(setf generic*-wrapper-method-table): Internal generic functions
(setf generic*-wrapper-method-table): Internal generic functions
(setf method*-special-variables): Internal generic functions
(setf method*-special-variables): Internal generic functions

A
add-all-wrapper-methods: Internal generic functions
add-all-wrapper-methods: Internal generic functions
add-method*: Internal generic functions
add-method*: Internal generic functions

C
combine-special-variable-precedence-ordered: Internal functions
combine-special-variable-precedence-unordered: Internal functions

D
defgeneric*: Exported macros
defmethod*: Exported macros

E
ensure-generic*-function: Exported functions
ensure-generic*-function-using-class: Internal generic functions
ensure-generic*-function-using-class: Internal generic functions

F
Function, combine-special-variable-precedence-ordered: Internal functions
Function, combine-special-variable-precedence-unordered: Internal functions
Function, ensure-generic*-function: Exported functions
Function, lambda-list-required-arguments: Internal functions
Function, remove-from-plist: Internal functions

G
Generic Function, (setf generic*-gf): Internal generic functions
Generic Function, (setf generic*-inner-methods): Internal generic functions
Generic Function, (setf generic*-name): Internal generic functions
Generic Function, (setf generic*-normal-argument-precedence-order): Internal generic functions
Generic Function, (setf generic*-normal-lambda-list): Internal generic functions
Generic Function, (setf generic*-special-variable-precedence-order): Internal generic functions
Generic Function, (setf generic*-wrapper-method-table): Internal generic functions
Generic Function, (setf method*-special-variables): Internal generic functions
Generic Function, add-all-wrapper-methods: Internal generic functions
Generic Function, add-method*: Internal generic functions
Generic Function, ensure-generic*-function-using-class: Internal generic functions
Generic Function, generic*-gf: Internal generic functions
Generic Function, generic*-inner-methods: Internal generic functions
Generic Function, generic*-inner-precedence-order: Internal generic functions
Generic Function, generic*-install-discriminating-function: Internal generic functions
Generic Function, generic*-name: Internal generic functions
Generic Function, generic*-normal-argument-precedence-order: Internal generic functions
Generic Function, generic*-normal-lambda-list: Internal generic functions
Generic Function, generic*-special-variable-precedence-order: Internal generic functions
Generic Function, generic*-wrapper-method-table: Internal generic functions
Generic Function, method*-special-variables: Internal generic functions
Generic Function, remove-all-wrapper-methods: Internal generic functions
Generic Function, wrap-method-function: Internal generic functions
Generic Function, wrapper-method-specializers: Internal generic functions
generic*-gf: Internal generic functions
generic*-gf: Internal generic functions
generic*-inner-methods: Internal generic functions
generic*-inner-methods: Internal generic functions
generic*-inner-precedence-order: Internal generic functions
generic*-inner-precedence-order: Internal generic functions
generic*-install-discriminating-function: Internal generic functions
generic*-install-discriminating-function: Internal generic functions
generic*-name: Internal generic functions
generic*-name: Internal generic functions
generic*-normal-argument-precedence-order: Internal generic functions
generic*-normal-argument-precedence-order: Internal generic functions
generic*-normal-lambda-list: Internal generic functions
generic*-normal-lambda-list: Internal generic functions
generic*-special-variable-precedence-order: Internal generic functions
generic*-special-variable-precedence-order: Internal generic functions
generic*-wrapper-method-table: Internal generic functions
generic*-wrapper-method-table: Internal generic functions

L
lambda-list-required-arguments: Internal functions

M
Macro, defgeneric*: Exported macros
Macro, defmethod*: Exported macros
method*-special-variables: Internal generic functions
method*-special-variables: Internal generic functions
Method, (setf generic*-gf): Internal generic functions
Method, (setf generic*-inner-methods): Internal generic functions
Method, (setf generic*-name): Internal generic functions
Method, (setf generic*-normal-argument-precedence-order): Internal generic functions
Method, (setf generic*-normal-lambda-list): Internal generic functions
Method, (setf generic*-special-variable-precedence-order): Internal generic functions
Method, (setf generic*-wrapper-method-table): Internal generic functions
Method, (setf method*-special-variables): Internal generic functions
Method, add-all-wrapper-methods: Internal generic functions
Method, add-method*: Internal generic functions
Method, ensure-generic*-function-using-class: Internal generic functions
Method, generic*-gf: Internal generic functions
Method, generic*-inner-methods: Internal generic functions
Method, generic*-inner-precedence-order: Internal generic functions
Method, generic*-install-discriminating-function: Internal generic functions
Method, generic*-name: Internal generic functions
Method, generic*-normal-argument-precedence-order: Internal generic functions
Method, generic*-normal-lambda-list: Internal generic functions
Method, generic*-special-variable-precedence-order: Internal generic functions
Method, generic*-wrapper-method-table: Internal generic functions
Method, method*-special-variables: Internal generic functions
Method, remove-all-wrapper-methods: Internal generic functions
Method, wrap-method-function: Internal generic functions
Method, wrapper-method-specializers: Internal generic functions

R
remove-all-wrapper-methods: Internal generic functions
remove-all-wrapper-methods: Internal generic functions
remove-from-plist: Internal functions

W
wrap-method-function: Internal generic functions
wrap-method-function: Internal generic functions
wrapper-method-specializers: Internal generic functions
wrapper-method-specializers: Internal generic functions

Jump to:   (  
A   C   D   E   F   G   L   M   R   W  

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

A.3 Variables

Jump to:   I   N   S   W  
Index Entry  Section

I
inner-gf: Internal classes
inner-methods: Internal classes

N
name: Internal classes
normal-argument-precedence-order: Internal classes
normal-lambda-list: Internal classes

S
Slot, inner-gf: Internal classes
Slot, inner-methods: Internal classes
Slot, name: Internal classes
Slot, normal-argument-precedence-order: Internal classes
Slot, normal-lambda-list: Internal classes
Slot, special-variable-precedence-order: Internal classes
Slot, special-variables: Internal classes
Slot, wrapper-method-table: Internal classes
special-variable-precedence-order: Internal classes
special-variables: Internal classes

W
wrapper-method-table: Internal classes

Jump to:   I   N   S   W  

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

A.4 Data types

Jump to:   C   G   M   P   S  
Index Entry  Section

C
Class, generic*-function: Internal classes
Class, method*: Internal classes
context-lite: The context-lite system
context-lite: The context-lite package

G
generic*-function: Internal classes

M
method*: Internal classes

P
Package, context-lite: The context-lite package

S
System, context-lite: The context-lite system

Jump to:   C   G   M   P   S