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

package main
import "fmt"
 
type Delegator struct {
    delegate interface{} // the delegate may be any type
}
 
// interface that represents anything that supports thing()
type Thingable interface {
    thing() string
}
 
func (self Delegator) operation() string {
    if v, ok := self.delegate.(Thingable); ok {
        return v.thing()
    }
    return "default implementation"
}
 
type Delegate int // any dummy type
 
func (Delegate) thing() string {
    return "delegate implementation"
}
 
func main() {
    // Without a delegate:
    a := Delegator{}
    fmt.Println(a.operation()) // prints "default implementation"
 
    // With a delegate that does not implement "thing"
    a.delegate = "A delegate may be any object"
    fmt.Println(a.operation()) // prints "default implementation"
 
    // With a delegate:
    var d Delegate
    a.delegate = d
    fmt.Println(a.operation()) // prints "delegate implementation"
}