cl-hooks README

A hook is an extension point consisting of the following pieces:

• A name (a symbol or some form)
• A list of handlers
• ftype?
• A result combination
• A documentation string

New kinds of hooks can easily be defined by adding methods to the generic functions that form the hook protocol:

(defgeneric hook-handlers (hook))
(defgeneric (setf hook-handlers) (new-value hook))
(defgeneric hook-combination (hook))
(defgeneric (setf hook-combination) (new-value hook))
(defgeneric documentation (hook type))
(defgeneric (setf documentation) (new-value hook type))

(mapcar
 (lambda (name)
   (format nil "(defgeneric ~S (hook)~%(:documentation ~S))"
           name (documentation name 'function)))
 '(hook-handlers hook-combination))

(defgeneric HOOK-HANDLERS (hook)\n(:documentation NIL))

(defgeneric HOOK-COMBINATION (hook)\n(:documentation NIL))

The following sections briefly discuss the kinds of hooks that are currently defined in the library.

The most straightforward approach to implementing a hook is to use a variable. The variable is used as followed

Symbol Name

name of the hook

Symbol Value

list of handlers currently attached to the hook

Symbol Documentation

if no dedicated hook documentation is installed using (setf (hook-documentation ...) ...), the documentation of the symbol as a variable is used

Consider the following example

(defvar *my-hook* nil
  "My hook is only run for educational purposes.")

(hooks:add-to-hook '*my-hook*
                   (lambda (x)
                     (format t "my-hook called with argument ~S~%" x)))

(hooks:run-hook '*my-hook* 1)

NIL

(documentation '*my-hook* 'hooks::hook)

My hook is only run for educational purposes.

Hooks can also live in other places like object slots:

(defclass my-class ()
  ((my-hook :initarg  :my-hook
            :type     list
            :initform nil
            :documentation
            "This hook bla bla")))

(defvar *my-object* (make-instance 'my-class))

(hooks:object-hook *my-object* 'my-hook)

#<HOOKS:OBJECT-HOOK MY-HOOK PROGN (0) {AFC90C1}>

Operation on an intern object hook work in the usual way:

(hooks:add-to-hook (hooks:object-hook *my-object* 'my-hook)
                   (lambda (x)
                     (format t "my-hook called with argument ~S~%" x)))

(hooks:object-hook *my-object* 'my-hook)

#<HOOKS:OBJECT-HOOK MY-HOOK PROGN (1) {AFC90C1}>

(format t "bla~%")
(hooks:run-hook (hooks:object-hook *my-object* 'my-hook) 1)

NIL

For object internal hooks, the documentation of the backing slot is used as the hook's documentation:

(documentation (hooks:object-hook *my-object* 'my-hook) 'hooks::hook)

This hook bla bla

Or outside of objects:

(defparameter *external-hook* (hooks:external-hook *my-object* 'my-external-hook))

*external-hook*

#<HOOKS:EXTERNAL-HOOK MY-EXTERNAL-HOOK PROGN (0) {BB80B49}>

We stored the hook object in a variable since we are going to use it in some other examples.

(hooks:add-to-hook *external-hook*
                   (lambda (x)
                     (format t "my-external-hook called with argument ~S~%" x)))

(hooks:run-hook *external-hook* 1)

NIL

Hook combination refers to the different possible way of constructing the resulting value of running a hook. While bearing a strong resemblance to method combination in CLOS namewise, hook combination is a much more restricted and less powerful concept.

The default hook combination is progn:

(hooks:hook-combination (hooks:external-hook *my-object* 'my-external-hook))

PROGN

progn hook combination means the final result is the return value of the handler run last: TODO

Let's set up the hook to test some other combinations

(hooks:clear-hook *external-hook*)
(hooks:add-to-hook *external-hook* #'(lambda (x) (mod x 5)))
(hooks:add-to-hook *external-hook* #'(lambda (x) (- x)))

(#<FUNCTION (LAMBDA #) {BBF56F5}> #<FUNCTION (LAMBDA #) {BBE42C5}>)
NIL

Combination using list

(setf (hooks:hook-combination *external-hook*) #'list)

(list
 (hooks:run-hook *external-hook* -3)
 (hooks:run-hook *external-hook* 1)
 (hooks:run-hook *external-hook* 7))

3	2
-1	1
-7	2

Combination using max

(setf (hooks:hook-combination *external-hook*) #'max)

(list
 (hooks:run-hook *external-hook* -3)
 (hooks:run-hook *external-hook* 1)
 (hooks:run-hook *external-hook* 7))

3

1

2

Note:

Some functions can be used for hook combination, but will not work as expected in all cases. max is one such examples. Running a hook with max hook combination that does not have any handlers will result in an error because max cannot be called without any arguments (which is the result of calling zero handlers).

retry

When this restart is invoked, the hook is ran again.

use-value

When this restart is invoked, the hook is not ran and a replacement value is read interactively and returned in place of the result of running the hook.

retry

When this restart is invoked, the handler is executed again.

use-value

When this restart is invoked, the handler is not executed and a replacement value is read interactively and returned in place of the result of executing the handler.

skip

When this restart is invoked, the handler is skipped without producing any return value. If there are other handlers, the hook may still produce a return value.