sketch interfaces

examples.txt

@@ -17,7 +17,7 @@ Recursion
 Pointers
 Structs
 Methods
-# Interfaces
+Interfaces
 # Embedding
 # Errors
 Goroutines

examples/interfaces/interfaces.go

@@ -1,9 +1,60 @@
+// _Interfaces_ are named collections of methods.
+
 package main
 
 import "fmt"
+import "math"
 
-type Shape interface {
+// Here's a basic interface for geometric shapes.
+type geometry interface {
     area() float64
+    perim() float64
 }
 
-// todo: that great blog post on interfaces
+// For our example we'll implement this interface on
+// `square` and `circle` types.
+type square struct {
+    width, height float64
+}
+type circle struct {
+    radius float64
+}
+
+// To implement an interface in Go, we just need to
+// implement all the methods in the interface. Here we
+// implement `geometry` on `square`s.
+func (s square) area() float64 {
+    return s.width * s.height
+}
+func (s square) perim() float64 {
+    return 2*s.width + 2*s.height
+}
+
+// The implementation for `circle`s.
+func (c circle) area() float64 {
+    return math.Pi * c.radius * c.radius
+}
+func (c circle) perim() float64 {
+    return 2 * math.Pi * c.radius
+}
+
+// If a variable has an interface type, then we can call
+// methods that are in the named interface. Here's a
+// generic `measure` function taking advantage of this
+// to work on any `geometry`.
+func measure(g geometry) {
+    fmt.Println(g)
+    fmt.Println(g.area())
+    fmt.Println(g.perim())
+}
+
+func main() {
+    s := square{width: 3, height: 4}
+    c := circle{radius: 5}
+
+    // The `circle` and `square` struct types both satisfy
+    // the `geometry` interface so we can use instances of
+    // these structs as arguments to `measure.
+    measure(s)
+    measure(c)
+}

examples/interfaces/interfaces.sh

@@ -0,0 +1,10 @@
+$ go run interfaces.go
+{3 4}
+12
+14
+{5}
+78.53981633974483
+31.41592653589793
+
+# To learn more about Go's interfaces, check out this
+# [great blog post](...).

examples/methods/methods.sh

@@ -3,3 +3,6 @@ area:  50
 perim: 30
 area:  50
 perim: 30
+
+# Next we'll look at Go's mechanism for grouping and
+# naming related sets of methods: interfaces.