Interfaces

1234567891011121314151617181920212223242526272829

package main

import "fmt"

// Built-in interface, defined in fmt:
//   type Stringer interface { String() string }
// Anything that has a String() string method satisfies it.

type Money struct{ Cents int }

func (m Money) String() string {
    return fmt.Sprintf("$%.2f", float64(m.Cents)/100)
}

type Greeting struct{ Name string }

func (g Greeting) String() string {
    return "Hi, " + g.Name + "!"
}

// Accepts anything Stringer
func describe(s fmt.Stringer) {
    fmt.Println(s)  // Println calls String() if available
}

func main() {
    describe(Money{Cents: 1999})
    describe(Greeting{Name: "Go"})
}

12345678910111213141516171819202122232425

package main

import "fmt"

// A tiny interface — one method.
type Greeter interface {
    Greet() string
}

// Concrete types implement it.
type English struct{ Name string }
type Klingon struct{ Name string }

func (e English) Greet() string  { return "Hello, " + e.Name }
func (k Klingon) Greet() string  { return "nuqneH, " + k.Name }

// Function accepts Greeter — works on any concrete type.
func welcome(g Greeter) {
    fmt.Println(g.Greet())
}

func main() {
    welcome(English{Name: "Alice"})
    welcome(Klingon{Name: "Worf"})
}

12345678910111213141516171819202122232425262728293031323334353637

package main

import "fmt"

func main() {
    var v interface{} = "hello"

    // Type assertion — single-arrow form (panics if wrong)
    s := v.(string)
    fmt.Println(s)

    // Comma-ok form — safe
    if n, ok := v.(int); ok {
        fmt.Println("int:", n)
    } else {
        fmt.Println("not an int")
    }

    // Type switch — for many cases
    inspect := func(x interface{}) {
        switch t := x.(type) {
        case nil:        fmt.Println("nil")
        case bool:       fmt.Println("bool:", t)
        case int:        fmt.Println("int:", t)
        case string:     fmt.Println("str:", t)
        case []byte:     fmt.Println("bytes:", string(t))
        case fmt.Stringer: fmt.Println("stringer:", t.String())
        default:         fmt.Printf("other: %T
", x)
        }
    }

    inspect(42)
    inspect("go")
    inspect([]byte("bytes"))
    inspect(3.14)
}

1234567891011121314

package main

import "fmt"

func printAll(items ...any) {
    for i, x := range items {
        fmt.Printf("%d: %T = %v
", i, x, x)
    }
}

func main() {
    printAll(1, "hello", true, 3.14, []int{1, 2, 3})
}

1234567891011121314151617181920212223242526

package main

import (
    "fmt"
    "io"
    "strings"
)

// One function works with anything io.Reader-shaped:
// strings.NewReader, *os.File, *bytes.Buffer, *http.Response.Body, ...
func dump(r io.Reader) {
    buf := make([]byte, 1024)
    n, _ := r.Read(buf)
    fmt.Printf("%q
", buf[:n])
}

func main() {
    dump(strings.NewReader("from a string"))

    // Compose: TeeReader wraps a Reader and copies what's read to a Writer.
    var copied strings.Builder
    tee := io.TeeReader(strings.NewReader("hi there"), &copied)
    dump(tee)
    fmt.Println("copied:", copied.String())
}

1234567891011121314151617181920

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

// HandlerFunc adapts a plain function to Handler — pure Go pattern.
type HandlerFunc func(ResponseWriter, *Request)

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r)
}

// The entire HTTP server contract is one method. Middleware = a function
// that wraps a Handler and returns a Handler. Composition is trivial.

func logging(next Handler) Handler {
    return HandlerFunc(func(w ResponseWriter, r *Request) {
        log.Printf("%s %s", r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}