Other Method Combinations

In addition to the standard method combination, the language specifies nine other built-in method combinations known as the simple built-in method combinations. You can also define custom method combinations, though that’s a fairly esoteric feature and beyond the scope of this book. I’ll briefly cover how to use the simple built-in combinations to give you a sense of the possibilities.

All the simple combinations follow the same pattern: instead of invoking the most specific primary method and letting it invoke less-specific primary methods via **CALL-NEXT-METHOD**, the simple method combinations produce an effective method that contains the code of all the primary methods, one after another, all wrapped in a call to the function, macro, or special operator that gives the method combination its name. The nine combinations are named for the operators: **+**, **AND**, **OR**, **LIST**, **APPEND**, **NCONC**, **MIN**, **MAX**, and **PROGN**. The simple combinations also support only two kinds of methods, primary methods, which are combined as just described, and :around methods, which work like :around methods in the standard method combination.

For example, a generic function that uses the **+** method combination will return the sum of all the results returned by its primary methods. Note that the **AND** and **OR** method combinations won’t necessarily run all the primary methods because of those macros’ short-circuiting behavior—a generic function using the **AND** combination will return **NIL** as soon as one of the methods does and will return the value of the last method otherwise. Similarly, the **OR** combination will return the first non-**NIL** value returned by any of the methods.

To define a generic function that uses a particular method combination, you include a :method-combination option in the **DEFGENERIC** form. The value supplied with this option is the name of the method combination you want to use. For example, to define a generic function, priority, that returns the sum of values returned by individual methods using the **+** method combination, you might write this:

(defgeneric priority (job)
  (:documentation "Return the priority at which the job should be run.")
  (:method-combination +))

By default all these method combinations combine the primary methods in most-specific-first order. However, you can reverse the order by including the keyword :most-specific-last after the name of the method combination in the **DEFGENERIC** form. The order probably doesn’t matter if you’re using the **+** combination unless the methods have side effects, but for demonstration purposes you can change priority to use most-specific-last order like this:

(defgeneric priority (job)
  (:documentation "Return the priority at which the job should be run.")
  (:method-combination + :most-specific-last))

The primary methods on a generic function that uses one of these combinations must be qualified with the name of the method combination. Thus, a primary method defined on priority might look like this:

(defmethod priority + ((job express-job)) 10)

This makes it obvious when you see a method definition that it’s part of a particular kind of generic function.

All the simple built-in method combinations also support :around methods that work like :around methods in the standard method combination: the most specific :around method runs before any other methods, and **CALL-NEXT-METHOD** is used to pass control to less-and-less-specific :around methods until it reaches the combined primary methods. The :most-specific-last option doesn’t affect the order of :around methods. And, as I mentioned before, the built-in method combinations don’t support :before or :after methods.

Like the standard method combination, these method combinations don’t allow you to do anything you couldn’t do “by hand.” Rather, they allow you to express what you want and let the language take care of wiring everything together for you, making your code both more concise and more expressive.

That said, probably 99 percent of the time, the standard method combination will be exactly what you want. Of the remaining 1 percent, probably 99 percent of them will be handled by one of the simple built-in method combinations. If you run into one of the 1 percent of 1 percent of cases where none of the built-in combinations suffices, you can look up **DEFINE-METHOD-COMBINATION** in your favorite Common Lisp reference.