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 , 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.

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 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:

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:

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 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.