optional method interface via type casting and/or closures

[AmitKumarDas]

 type eventHandle interface {
     eventHookTypeA
     eventHookTypeB
     // DON'T add TypeC interface.
     someOtherMethod() results
 }
 type eventHookTypeA interface {
     // method definitions
     HandleEventA() results
 }
 type eventHookTypeB interface {
     // method definitions
     HandleEventB() results
 }
 type eventHookTypeC interface {
     HandleEventC() results
 }

 func handleEvents(eventType string, handle eventHandle) results {
      if eventType == "eventA" {
         return handle.HandleEventA()
      } else if eventType == "eventB" {
         return handle.HandleEventB()
      } else if eventType == "eventC" {
         if c,ok := handle.(eventHookTypeC); ok {
             return c.HandleEventC()
         } else {
             log.Println("somewhat bad happen")
         }
      }
      return nil
 }

[AmitKumarDas]

An approach that some code pieces in Kubernetes follows is:

 // LeaseDuration is the duration that non-leader candidates will
 // wait to force acquire leadership. This is measured against time of
 // last observed ack. Defaults to 15 seconds.
 func LeaseDuration(leaseDuration time.Duration) func(*ProvisionController) error {
    return func(c *ProvisionController) error {
        if c.HasRun() {
            return errRuntime
        }
        c.leaseDuration = leaseDuration
        return nil
    }
 }

• Above removes the necessity of adding arguments to existing methods & hence more code churn
• Typical way is to use a new interface & a interface level method & add this interface as an argument
• Above inverts the problem:
  • Make use of function closure
  • Mutate the instance that needs to make use of this
  • This mutation will be done typically against a property of a common struct
  • HasRun() is a cool check that determines if this closure is run at an invalid point of execution