Golang interfaces

Similar to other languages, interfaces in go define a contract of method-signatures that implementors must have.
Unlike other languages, golang interfaces are implicit -- an object with all of the required methods automatically satisfies an interface.

Similar to other languages, a param can be typed to accept an interface, which abstracts the actual type that is received.

Basics

In go, many interfaces expose just a single method, and are named after the method they expose.
Frequently, interfaces are implemented on structs (but they can be for any type).

// declare an interface
type Writer interface {
    Write([]byte) (int, error)
}

// implement an interface (automatic if methods match)
type PrinterWriter struct {}

func (w PrinterWriter) Write(data []byte) (int, error) {
    // ...
}

var w Writer = PrinterWriter{}  // <-- type 'Writer'
w.Write([]byte("Foobar"))

Libraries do not need to expose interfaces in go, you can create them for the subset of methods that are useful to you.

Primitive Interfaces

TODO:

test this code!

Interfaces can also be created on primitives.

type Doubler interface {
    Double() int
}

func (value *int) {
    *value = *value * 2
}

num := 10
var doubler Doubler = &num
num.Double() // 20

Embedding

Like structs, interfaces can be embedded.

type Walker interface {
    Walk nil
}

type BubblegumChewer interface {
    ChewGum nil
}

// includes all methods from previous two interfaces
type BubblegumChewingWalker interface {
    Walker
    BubblegumChewer
}