A delegate is a helper object used by another object. The delegator may send the delegate certain messages, and provide a default implementation when there is no delegate or the delegate does not respond to a message. This pattern is heavily used in Cocoa framework on Mac OS X. See also wp:Delegation pattern.

Objects responsibilities:

Delegator:

 Keep an optional delegate instance.
 Implement "operation" method, returning the delegate "thing" if the delegate respond to "thing", or the string "default implementation".
Delegate:

 Implement "thing" and return the string "delegate implementation"
Show how objects are created and used. First, without a delegate, then with a delegate that does not implement "thing", and last with a delegate that implements "thing".

(defgeneric thing (object)
  (:documentation "Thing the object."))
 
(defmethod thing (object)
  "default implementation")
 
(defclass delegator ()
  ((delegate
    :initarg :delegate
    :reader delegator-delegate)))
 
(defmethod thing ((delegator delegator))
  "If delegator has a delegate, invoke thing on the delegate,
otherwise return \"no delegate\"."
  (if (slot-boundp delegator 'delegate)
    (thing (delegator-delegate delegator))
    "no delegate"))
 
(defclass delegate () ())
 
(defmethod thing ((delegate delegate))
  "delegate implementation")
 
(let ((d1 (make-instance 'delegator))
      (d2 (make-instance 'delegator :delegate nil))
      (d3 (make-instance 'delegator :delegate (make-instance 'delegate))))
  (assert (string= "no delegate" (thing d1)))
  (assert (string= "default implementation" (thing d2)))
  (assert (string= "delegate implementation" (thing d3))))