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

import extensions;
import system'routines;
 
interface IOperable
{
    abstract operate() {}
}
 
class Operable : IOperable
{
    constructor() {}
 
    operate()
        = "delegate implementation";
}
 
class Delegator
{
    object theDelegate;
 
    set Delegate(object)
    {
        theDelegate := object
    }
 
    internal operate(operable)
        = "default implementation";
 
    internal operate(IOperable operable)
        = operable.operate();
 
    operate()
        <= operate(theDelegate);
}
 
public program()
{
    var delegator := new Delegator();
 
    new object[]{nil, new Object(), new Operable()}.forEach:(o)
    {
       delegator.Delegate := o;
 
       console.printLine(delegator.operate())
    }
}