The method-hooks Reference Manual

Table of Contents

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

The method-hooks Reference Manual

This is the method-hooks Reference Manual, version 0.1.0, generated automatically by Declt version 2.4 patchlevel 1 "Will Decker" on Mon Jul 29 16:15:02 2019 GMT+0.


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

1 Introduction

Method Hooks

method-hooks provides simple hooks dispatched by methods and supports method combination and qualifiers.

documentation can be viewed here

Motivation

A friend thought that methods qualified with progn with the same type specializer lists would accumulate to run like hooks,

Which could be quite useful so here we are.

Features

Usage

Getting started

You can jump straight into defining hooks, they will by default (where define-hook-generic hasn't been used for the generic you're using) be unqualified just like normal methods.

(ql:quickload :method-hooks)

(defgeneric foo (a))

(method-hooks:defhook foo user ((a string))
  (print a))
  
(method-hooks:defhook foo hey :before ((a string))
  (print "hey"))
  
> (foo "me")
"hey" 
"me" 

Using define-hook-generic with defhook

If you want to defhook to remember what qualifier to use for a generic, you can use define-hook-generic which takes all the same options as defgeneric and optionally takes :default-qualifier which by default will be the method-combination type supplied. If no method combination type has been supplied then by default define-hook-generic will use progn as the default qualifier & combination.

(define-hook-generic baz ()) ; defaults to progn for least astonishment
(defhook baz meow () (print "meow"))
(defhook baz woof () (print "woof"))

> (baz)

"woof" 
"meow" 
(WOOF MEOW)

Here is an example where we will use the + combination-type to show that defhook by default will use the combination-type supplied as the default qualifier.

(define-hook-generic adding (x) ; remembers the method combination type and uses that as default.
  (:method-combination +))      ; can be overridden with (:default-qualifier :unqualified) (or another combination type)
  
(defhook adding once ((x integer)) x)
(defhook adding twice ((x integer)) x)

> (adding 3)

6

The keyword :unqualified can be supplied as a qualifier to defhook, define-hook-generic, set-dispatch-for-qualifier and anything else exported by this system as this is how unqualified methods are distinguished internally, however this will likely never be unnecessary.

defining a new dispatcher

There are some dispatchers already defined in /src/known-dispatchers.lisp and these are good examples to go by.

Using finalize-dispatch-method

defhook expands with a definition for the dispatch method, this is so that each dispatch-method doesn't have to be finalized. If you wanted to edit the dispatch method you can and you can do anything you want in there, you must however dispatch the hooks yourself with dispatch or by hand.

(finalize-dispatch-method adding ((x integer))
  (format t "dispatching hooks")
  (dispatch adding + ((x integer))))

dispatching without a dispatcher

To dispatch by hand you would as of writing have to understand internals. The definition for dispatch shows you how to do this, I think I will make this easier if there is demand in future.

what are specialized-lambda-list, vanilla-lambda-list, type-list, descriptive-lambda-list?

using method-hooks::destructure-specialized-lambda list will give you a good idea e.g.

> (destructure-specialized-lambda-list descriptive-lambda-list vanilla-lambda-list type-list '((x integer) y)
    (values descriptive-lambda-list type-list vanilla-lambda-list))
((X INTEGER) (Y T))
(INTEGER T)
(X Y)

It's also important to note that hooks are interned by the gf-name and type-list not the specialized-lambda-list as the variable symbols in the specialized-lambda-list can change.

More (and more practical) examples

Here is a version of cl-matrix where event listening is done with method-hooks.

Here is a version where I badly abuse deeds for comparison.


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 method-hooks

Maintainer

Gnuxie <Gnuxie@protonmail.com>

Author

Gnuxie <Gnuxie@protonmail.com>

Home Page

https://gnuxie.gitlab.io/method-hooks/

Bug Tracker

https://gitlab.com/Gnuxie/method-hooks/issues

License

Mozilla Public License Version 2.0

Description

simple qualifiable hooks defined like methods with the option to modify the dispatch method and how dispatch happens

Version

0.1.0

Source

method-hooks.asd (file)

Component

src (module)


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

3 Modules

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


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

3.1 method-hooks/src

Parent

method-hooks (system)

Location

src/

Components

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

4 Files

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


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

4.1 Lisp


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

4.1.1 method-hooks.asd

Location

method-hooks.asd

Systems

method-hooks (system)


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

4.1.2 method-hooks/src/package.lisp

Parent

src (module)

Location

src/package.lisp

Packages

method-hooks


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

4.1.3 method-hooks/src/macro-utils.lisp

Parent

src (module)

Location

src/macro-utils.lisp

Internal Definitions

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

4.1.4 method-hooks/src/combination-management.lisp

Parent

src (module)

Location

src/combination-management.lisp

Exported Definitions
Internal Definitions

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

4.1.5 method-hooks/src/known-dispatchers.lisp

Parent

src (module)

Location

src/known-dispatchers.lisp


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

4.1.6 method-hooks/src/hook-management.lisp

Parent

src (module)

Location

src/hook-management.lisp

Exported Definitions
Internal Definitions

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

4.1.7 method-hooks/src/method-hooks.lisp

Parent

src (module)

Location

src/method-hooks.lisp

Exported Definitions
Internal Definitions

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

5 Packages

Packages are listed by definition order.


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

5.1 method-hooks

Source

package.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

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

6 Definitions

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


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

6.1 Exported definitions


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

6.1.1 Macros

Macro: defhook GENERIC-FUNCTION HOOK-NAME &rest ARGS

define a hook to be to be called by the effective method.

This macro has roughly the same signature as defmethod ‘(DEFHOOK GENERIC-FUNCTION HOOK-NAME {QUALIFIER} SPECIALIZED-LAMBDA-LIST &BODY BODY)‘ creates a function ‘hook-name‘ with the ‘body‘ then creates a method to dispatch all hooks matching
the type-list for the given generic-function.

See define-hook-generic
See finalize-dispatch-method

Package

method-hooks

Source

method-hooks.lisp (file)

Macro: define-dispatch NAME LAMBDA-LIST &body BODY

the lambda list should accept two arguments:
the list of arguments given by the current method call.
the specific hooks (as named or unamed functions) for the qualified method (that we will be dispatching from).

you should then use the arguments to dispatch the specific hooks as you wish in the body.
if the body returns a result, by default the method will also return that result, this can be overriden with finalize-dispatch-method.

See finalize-dispatch-method
See dispatch

Package

method-hooks

Source

combination-management.lisp (file)

Macro: define-hook-generic NAME GF-LAMBDA-LIST &rest OPTIONS

utility to help with gf’s with method combination by remembering the combination type

by default the combination type becomes the default qualifier for any newly defined hooks
this can be overriden by not using this and using defgeneric or supplying the option :default-qualifier.

supplying ‘:hook-point t‘ will create a method qualified with the default-qualifier so that the generic acts like an extensible hook point and will not signal no-applicable-method error when no hooks have been defined.
See defhook

Package

method-hooks

Source

method-hooks.lisp (file)

Macro: dispatch GENERIC-FUNCTION QUALIFIER SPECIALIZED-LAMBDA-LIST

dispatch the hooks using the default dispatcher for the given qualified specific method.

See define-dispatch
See dispatch-function
See set-dispatch-for-qualifier

Package

method-hooks

Source

combination-management.lisp (file)

Macro: finalize-dispatch-method GENERIC-FUNCTION &rest ARGS

add a body to the method which dispatched the hooks for the given specialized-lambda-list
useful if you wanted to use call-next-method

For the definition to be effective, it must be defined after every specific hook for the same method hence finalize.

See defhook

Package

method-hooks

Source

method-hooks.lisp (file)

Macro: make-dispatcher FUNCTION-CONSTRUCTOR
Package

method-hooks

Source

combination-management.lisp (file)


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

6.1.2 Functions

Function: clear-hook-table ()

will not require recompilation of all the forms unless an existing hook definition is redefined or a method is redefined

Package

method-hooks

Source

hook-management.lisp (file)

Function: dispatch-for-qualifier QUALIFIER

the dispatcher used for the given qualifier

See define-dispatch
See dispatcher

Package

method-hooks

Source

combination-management.lisp (file)

Function: set-dispatch-for-qualifier QUALIFIER DISPATCH

accepts two symbols, sets the dispatcher to be used for the given qualifier

See define-dispatch
See dispatcher

Package

method-hooks

Source

combination-management.lisp (file)

Function: specific-hooks-for-generic TYPE-LIST GENERIC-FUNCTION QUALIFIER

get the hooks specific to the type specializer list and qualifier

Package

method-hooks

Source

hook-management.lisp (file)


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

6.1.3 Generic functions

Generic Function: dispatch-function OBJECT
Generic Function: (setf dispatch-function) NEW-VALUE OBJECT
Package

method-hooks

Methods
Method: dispatch-function (DISPATCHER dispatcher)
Method: (setf dispatch-function) NEW-VALUE (DISPATCHER dispatcher)

a function object for the current environment

Source

combination-management.lisp (file)

Generic Function: dispatch-function-constructor OBJECT
Generic Function: (setf dispatch-function-constructor) NEW-VALUE OBJECT
Package

method-hooks

Methods
Method: dispatch-function-constructor (DISPATCHER dispatcher)
Method: (setf dispatch-function-constructor) NEW-VALUE (DISPATCHER dispatcher)

a lambda expression used to construct the function object for dispatch-function.

Source

combination-management.lisp (file)

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

method-hooks

Methods
Method: hook-name (HOOK hook)

automatically generated reader method

Source

hook-management.lisp (file)

Method: (setf hook-name) NEW-VALUE (HOOK hook)

automatically generated writer method

Source

hook-management.lisp (file)

Generic Function: qualifier OBJECT
Generic Function: (setf qualifier) NEW-VALUE OBJECT
Package

method-hooks

Methods
Method: qualifier (HOOK hook)

automatically generated reader method

Source

hook-management.lisp (file)

Method: (setf qualifier) NEW-VALUE (HOOK hook)

automatically generated writer method

Source

hook-management.lisp (file)


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

6.1.4 Classes

Class: dispatcher ()
Package

method-hooks

Source

combination-management.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: dispatch-function-constructor

a lambda expression used to construct the function object for dispatch-function.

Type

list

Initargs

:dispatch-function-constructor

Readers

dispatch-function-constructor (generic function)

Writers

(setf dispatch-function-constructor) (generic function)

Slot: dispatch-function

a function object for the current environment

Type

function

Initargs

:dispatch-function

Readers

dispatch-function (generic function)

Writers

(setf dispatch-function) (generic function)

Class: hook ()
Package

method-hooks

Source

hook-management.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: qualifier
Type

symbol

Initargs

:qualifier

Readers

qualifier (generic function)

Writers

(setf qualifier) (generic function)

Slot: hook-name
Type

symbol

Initargs

:hook-name

Readers

hook-name (generic function)

Writers

(setf hook-name) (generic function)


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

6.2 Internal definitions


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

6.2.1 Special variables

Special Variable: *dispatch-for-qualifier*

used to lookup the symbol for a dispatcher

Package

method-hooks

Source

combination-management.lisp (file)

Special Variable: *dispatch-table*

used to lookup the dispatcher for a symbol

Package

method-hooks

Source

combination-management.lisp (file)

Special Variable: *hook-generics*

hash table holding information on all of the generics used either indirectly with defhook or directly with define-hook-generic

Package

method-hooks

Source

hook-management.lisp (file)

Special Variable: *hooks*

information about all the hooks used in the image

Package

method-hooks

Source

hook-management.lisp (file)


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

6.2.2 Macros

Macro: %defhook-fun HOOK-NAME VANILLA-LAMBDA-LIST &body BODY

this is literally just a copy of defun atm.

Package

method-hooks

Source

method-hooks.lisp (file)

Macro: %define-method-dispatch GENERIC-FUNCTION QUALIFIER SPECIALIZED-LAMBDA-LIST &body BODY

defines the dispatch method for hooks, will remember the qualifier for the gf

Package

method-hooks

Source

method-hooks.lisp (file)

Macro: %destructure-defhook-args ARGS &body BODY
Package

method-hooks

Source

macro-utils.lisp (file)

Macro: %lay-method-base-for-dispatch GENERIC-FUNCTION QUALIFIER TYPE-LIST DESCRIPTIVE-LAMBDA-LIST &body BODY
Package

method-hooks

Source

method-hooks.lisp (file)

Macro: %load-specializers-to-table GENERIC-FUNCTION TYPE-LIST QUALIFIER

creates a form to load the hooks specific to the gf/type-list/qualifier
from the compilation environment into the internal table inside the runtime environment.

Package

method-hooks

Source

method-hooks.lisp (file)

Macro: destructure-specialized-lambda-list DESCRIPTIVE-LAMBDA-LIST-SYM VANILLA-LAMBDA-LIST-SYM TYPE-LIST-SYM SPECIALIZED-LAMBDA-LIST &body BODY

if specialized-lambda-list is ((a integer) b): descriptive-lambda-list will be ((x integer) (x t)) type-list will be (integer t) and vanilla-lambda-list is (a b)

Package

method-hooks

Source

macro-utils.lisp (file)

Macro: with-effective-qualifier GF-NAME QUALIFIER &body BODY

take generic function and a symbol bound to a qualifier and mask that symbol with the effective qualifier.

The effective qualifier is the default qualifier for the given generic function should there be one defined by a define-hook-generic form.

Package

method-hooks

Source

method-hooks.lisp (file)


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

6.2.3 Functions

Function: effective-qualifier GF-NAME QUALIFIER
Package

method-hooks

Source

hook-management.lisp (file)

Function: get-default-qualifier GF-NAME
Package

method-hooks

Source

hook-management.lisp (file)

Function: intern-hook GF-NAME HOOK-NAME TYPE-LIST QUALIFIER

intern the hook into the hooks hashtable by symbol name and into the generic functions table
by type-list and qualifier

as we are keeping references to hook objects in two places and due to the dificulty of keeping both
exactly up to date, specific-hooks-for-generic will remove old references from the hook functions method list before returning the result.

Package

method-hooks

Source

hook-management.lisp (file)

Function: intern-hook-generic GF-NAME METHOD-COMBINATION DEFAULT-QUALIFIER

will copy methods across if an existing gf is defined with them

Package

method-hooks

Source

hook-management.lisp (file)

Function: intern-undeclared-hook-generic GF-NAME

if we stumble across a generic which we don’t know about (ie from using defhook without define-hook-generic) then we must intern it in an appropriate way.

Package

method-hooks

Source

hook-management.lisp (file)


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

6.2.4 Generic functions

Generic Function: combination OBJECT
Generic Function: (setf combination) NEW-VALUE OBJECT
Package

method-hooks

Methods
Method: combination (HOOK-GENERIC hook-generic)

automatically generated reader method

Source

hook-management.lisp (file)

Method: (setf combination) NEW-VALUE (HOOK-GENERIC hook-generic)

automatically generated writer method

Source

hook-management.lisp (file)

Generic Function: default-qualifier OBJECT
Generic Function: (setf default-qualifier) NEW-VALUE OBJECT
Package

method-hooks

Methods
Method: default-qualifier (HOOK-GENERIC hook-generic)

automatically generated reader method

Source

hook-management.lisp (file)

Method: (setf default-qualifier) NEW-VALUE (HOOK-GENERIC hook-generic)

automatically generated writer method

Source

hook-management.lisp (file)

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

method-hooks

Methods
Method: methods (HOOK-GENERIC hook-generic)

automatically generated reader method

Source

hook-management.lisp (file)

Method: (setf methods) NEW-VALUE (HOOK-GENERIC hook-generic)

automatically generated writer method

Source

hook-management.lisp (file)


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

6.2.5 Classes

Class: hook-generic ()
Package

method-hooks

Source

hook-management.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: methods
Type

hash-table

Initargs

:methods

Initform

(make-hash-table :test (function equal))

Readers

methods (generic function)

Writers

(setf methods) (generic function)

Slot: combination
Type

symbol

Initargs

:combination

Readers

combination (generic function)

Writers

(setf combination) (generic function)

Slot: default-qualifier
Type

symbol

Initargs

:default-qualifier

Readers

default-qualifier (generic function)

Writers

(setf default-qualifier) (generic function)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   M  
Index Entry  Section

F
File, Lisp, method-hooks.asd: The method-hooks<dot>asd file
File, Lisp, method-hooks/src/combination-management.lisp: The method-hooks/src/combination-management<dot>lisp file
File, Lisp, method-hooks/src/hook-management.lisp: The method-hooks/src/hook-management<dot>lisp file
File, Lisp, method-hooks/src/known-dispatchers.lisp: The method-hooks/src/known-dispatchers<dot>lisp file
File, Lisp, method-hooks/src/macro-utils.lisp: The method-hooks/src/macro-utils<dot>lisp file
File, Lisp, method-hooks/src/method-hooks.lisp: The method-hooks/src/method-hooks<dot>lisp file
File, Lisp, method-hooks/src/package.lisp: The method-hooks/src/package<dot>lisp file

L
Lisp File, method-hooks.asd: The method-hooks<dot>asd file
Lisp File, method-hooks/src/combination-management.lisp: The method-hooks/src/combination-management<dot>lisp file
Lisp File, method-hooks/src/hook-management.lisp: The method-hooks/src/hook-management<dot>lisp file
Lisp File, method-hooks/src/known-dispatchers.lisp: The method-hooks/src/known-dispatchers<dot>lisp file
Lisp File, method-hooks/src/macro-utils.lisp: The method-hooks/src/macro-utils<dot>lisp file
Lisp File, method-hooks/src/method-hooks.lisp: The method-hooks/src/method-hooks<dot>lisp file
Lisp File, method-hooks/src/package.lisp: The method-hooks/src/package<dot>lisp file

M
method-hooks.asd: The method-hooks<dot>asd file
method-hooks/src: The method-hooks/src module
method-hooks/src/combination-management.lisp: The method-hooks/src/combination-management<dot>lisp file
method-hooks/src/hook-management.lisp: The method-hooks/src/hook-management<dot>lisp file
method-hooks/src/known-dispatchers.lisp: The method-hooks/src/known-dispatchers<dot>lisp file
method-hooks/src/macro-utils.lisp: The method-hooks/src/macro-utils<dot>lisp file
method-hooks/src/method-hooks.lisp: The method-hooks/src/method-hooks<dot>lisp file
method-hooks/src/package.lisp: The method-hooks/src/package<dot>lisp file
Module, method-hooks/src: The method-hooks/src module

Jump to:   F   L   M  

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

A.2 Functions

Jump to:   %   (  
C   D   E   F   G   H   I   M   Q   S   W  
Index Entry  Section

%
%defhook-fun: Internal macros
%define-method-dispatch: Internal macros
%destructure-defhook-args: Internal macros
%lay-method-base-for-dispatch: Internal macros
%load-specializers-to-table: Internal macros

(
(setf combination): Internal generic functions
(setf combination): Internal generic functions
(setf default-qualifier): Internal generic functions
(setf default-qualifier): Internal generic functions
(setf dispatch-function): Exported generic functions
(setf dispatch-function): Exported generic functions
(setf dispatch-function-constructor): Exported generic functions
(setf dispatch-function-constructor): Exported generic functions
(setf hook-name): Exported generic functions
(setf hook-name): Exported generic functions
(setf methods): Internal generic functions
(setf methods): Internal generic functions
(setf qualifier): Exported generic functions
(setf qualifier): Exported generic functions

C
clear-hook-table: Exported functions
combination: Internal generic functions
combination: Internal generic functions

D
default-qualifier: Internal generic functions
default-qualifier: Internal generic functions
defhook: Exported macros
define-dispatch: Exported macros
define-hook-generic: Exported macros
destructure-specialized-lambda-list: Internal macros
dispatch: Exported macros
dispatch-for-qualifier: Exported functions
dispatch-function: Exported generic functions
dispatch-function: Exported generic functions
dispatch-function-constructor: Exported generic functions
dispatch-function-constructor: Exported generic functions

E
effective-qualifier: Internal functions

F
finalize-dispatch-method: Exported macros
Function, clear-hook-table: Exported functions
Function, dispatch-for-qualifier: Exported functions
Function, effective-qualifier: Internal functions
Function, get-default-qualifier: Internal functions
Function, intern-hook: Internal functions
Function, intern-hook-generic: Internal functions
Function, intern-undeclared-hook-generic: Internal functions
Function, set-dispatch-for-qualifier: Exported functions
Function, specific-hooks-for-generic: Exported functions

G
Generic Function, (setf combination): Internal generic functions
Generic Function, (setf default-qualifier): Internal generic functions
Generic Function, (setf dispatch-function): Exported generic functions
Generic Function, (setf dispatch-function-constructor): Exported generic functions
Generic Function, (setf hook-name): Exported generic functions
Generic Function, (setf methods): Internal generic functions
Generic Function, (setf qualifier): Exported generic functions
Generic Function, combination: Internal generic functions
Generic Function, default-qualifier: Internal generic functions
Generic Function, dispatch-function: Exported generic functions
Generic Function, dispatch-function-constructor: Exported generic functions
Generic Function, hook-name: Exported generic functions
Generic Function, methods: Internal generic functions
Generic Function, qualifier: Exported generic functions
get-default-qualifier: Internal functions

H
hook-name: Exported generic functions
hook-name: Exported generic functions

I
intern-hook: Internal functions
intern-hook-generic: Internal functions
intern-undeclared-hook-generic: Internal functions

M
Macro, %defhook-fun: Internal macros
Macro, %define-method-dispatch: Internal macros
Macro, %destructure-defhook-args: Internal macros
Macro, %lay-method-base-for-dispatch: Internal macros
Macro, %load-specializers-to-table: Internal macros
Macro, defhook: Exported macros
Macro, define-dispatch: Exported macros
Macro, define-hook-generic: Exported macros
Macro, destructure-specialized-lambda-list: Internal macros
Macro, dispatch: Exported macros
Macro, finalize-dispatch-method: Exported macros
Macro, make-dispatcher: Exported macros
Macro, with-effective-qualifier: Internal macros
make-dispatcher: Exported macros
Method, (setf combination): Internal generic functions
Method, (setf default-qualifier): Internal generic functions
Method, (setf dispatch-function): Exported generic functions
Method, (setf dispatch-function-constructor): Exported generic functions
Method, (setf hook-name): Exported generic functions
Method, (setf methods): Internal generic functions
Method, (setf qualifier): Exported generic functions
Method, combination: Internal generic functions
Method, default-qualifier: Internal generic functions
Method, dispatch-function: Exported generic functions
Method, dispatch-function-constructor: Exported generic functions
Method, hook-name: Exported generic functions
Method, methods: Internal generic functions
Method, qualifier: Exported generic functions
methods: Internal generic functions
methods: Internal generic functions

Q
qualifier: Exported generic functions
qualifier: Exported generic functions

S
set-dispatch-for-qualifier: Exported functions
specific-hooks-for-generic: Exported functions

W
with-effective-qualifier: Internal macros

Jump to:   %   (  
C   D   E   F   G   H   I   M   Q   S   W  

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

A.3 Variables

Jump to:   *  
C   D   H   M   Q   S  
Index Entry  Section

*
*dispatch-for-qualifier*: Internal special variables
*dispatch-table*: Internal special variables
*hook-generics*: Internal special variables
*hooks*: Internal special variables

C
combination: Internal classes

D
default-qualifier: Internal classes
dispatch-function: Exported classes
dispatch-function-constructor: Exported classes

H
hook-name: Exported classes

M
methods: Internal classes

Q
qualifier: Exported classes

S
Slot, combination: Internal classes
Slot, default-qualifier: Internal classes
Slot, dispatch-function: Exported classes
Slot, dispatch-function-constructor: Exported classes
Slot, hook-name: Exported classes
Slot, methods: Internal classes
Slot, qualifier: Exported classes
Special Variable, *dispatch-for-qualifier*: Internal special variables
Special Variable, *dispatch-table*: Internal special variables
Special Variable, *hook-generics*: Internal special variables
Special Variable, *hooks*: Internal special variables

Jump to:   *  
C   D   H   M   Q   S  

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

A.4 Data types

Jump to:   C   D   H   M   P   S  
Index Entry  Section

C
Class, dispatcher: Exported classes
Class, hook: Exported classes
Class, hook-generic: Internal classes

D
dispatcher: Exported classes

H
hook: Exported classes
hook-generic: Internal classes

M
method-hooks: The method-hooks system
method-hooks: The method-hooks package

P
Package, method-hooks: The method-hooks package

S
System, method-hooks: The method-hooks system

Jump to:   C   D   H   M   P   S