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

trait Thingable {
  def thing: String
}
 
class Delegator {
  var delegate: Thingable = _
 
  def operation: String = if (delegate == null) "default implementation"
  else delegate.thing
}
 
class Delegate extends Thingable {
  override def thing = "delegate implementation"
}
 
// Example usage
// Memory management ignored for simplification
object DelegateExample extends App {
 
  val a = new Delegator
  assert(a.operation == "default implementation")
  // With a delegate:
  val d = new Delegate
  a.delegate = d
  assert(a.operation == "delegate implementation")
  // Same as the above, but with an anonymous class:
  a.delegate = new Thingable() {
    override def thing = "anonymous delegate implementation"
  }
  assert(a.operation == "anonymous delegate implementation")
 
}