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

interface Thingable {
  method : virtual : public : Thing() ~ String;
}
 
class Delegator {
  @delegate : Thingable;
 
  New() {
  }   
 
  method : public : SetDelegate(delegate : Thingable) ~ Nil {
    @delegate := delegate;
  }
 
  method : public : Operation() ~ String {
    if(@delegate = Nil) {
      return "default implementation";
    }
    else {
      return @delegate->Thing();
    };
  }
}
 
class Delegate implements Thingable {
  New() {
  }   
 
  method : public : Thing() ~ String {
    return "delegate implementation";
  }
}
 
class Example {
  function : Main(args : String[]) ~ Nil {
    # Without a delegate:
    a := Delegator->New();
    Runtime->Assert(a->Operation()->Equals("default implementation"));
 
    # With a delegate:
    d := Delegate->New();
    a->SetDelegate(d);
    Runtime->Assert(a->Operation()->Equals("delegate implementation"));
 
    # Same as the above, but with an anonymous class:
    a->SetDelegate(Base->New() implements Thingable {
      method : public : Thing() ~ String {
        return "anonymous delegate implementation";
      }
    });
 
    Runtime->Assert(a->Operation()->Equals("anonymous delegate implementation"));
  }
}
 