Interfaces

package main

import (
	"fmt"

	"example.com/shelf/catalog"
)

// Describer is satisfied by any type with a Describe method.
type Describer interface {
	Describe() string
}

// Book and Loan never mention Describer: they simply have the method.
type Book struct{ Title string }

func (b Book) Describe() string { return "book " + b.Title }

type Loan struct {
	Member string
	State  catalog.LoanState
}

func (l Loan) Describe() string { return fmt.Sprintf("loan to %s (%v)", l.Member, l.State) }

func main() {
	items := []Describer{
		Book{Title: "Dune"},
		Loan{Member: "ada", State: catalog.OnLoan},
	}
	for _, it := range items {
		fmt.Println(it.Describe())
	}
}

book Dune
loan to ada (on loan)

package main

import (
	"fmt"
	"strings"
)

type Reader interface {
	Read(p []byte) (n int, err error)
}

type Writer interface {
	Write(p []byte) (n int, err error)
}

type Closer interface {
	Close() error
}

// ReadWriter embeds two interfaces: its method set is the union.
type ReadWriter interface {
	Reader
	Writer
}

// ReadWriteCloser embeds ReadWriter and Closer.
type ReadWriteCloser interface {
	ReadWriter
	Closer
}

// Since Go 1.14 embedded interfaces may overlap on identical methods.
type Named interface{ Name() string }
type Titled interface{ Name() string }
type Both interface {
	Named
	Titled
}

type book struct{ title string }

func (b book) Name() string { return strings.ToUpper(b.title) }

type buf struct{ data []byte }

func (b *buf) Read(p []byte) (int, error)  { return copy(p, b.data), nil }
func (b *buf) Write(p []byte) (int, error) { b.data = append(b.data, p...); return len(p), nil }
func (b *buf) Close() error                { return nil }

func main() {
	var rwc ReadWriteCloser = &buf{}
	var rw ReadWriter = rwc // a ReadWriteCloser is assignable to its sub-interface
	fmt.Fprintf(rw, "hello")
	fmt.Println(string(rwc.(*buf).data))

	var both Both = book{"dune"}
	fmt.Println(both.Name())
}

hello
DUNE

package main

import (
	"fmt"
	"unsafe"
)

type shape interface{ Area() float64 }

type sq struct{ s float64 }

func (q sq) Area() float64 { return q.s * q.s }

func main() {
	var e any
	var s shape
	fmt.Println("sizeof any:", unsafe.Sizeof(e), "sizeof shape:", unsafe.Sizeof(s))
	fmt.Println("sizeof func value:", unsafe.Sizeof(func() {}))

	s = sq{3}
	fmt.Println(s.Area())
}

sizeof any: 16 sizeof shape: 16
sizeof func value: 8
9

package main

import (
	"fmt"

	"example.com/shelf/catalog"
)

func main() {
	var s fmt.Stringer // nil interface: no type, no value
	fmt.Printf("%T %v %t\n", s, s, s == nil)

	s = catalog.OnLoan // dynamic type catalog.LoanState, value 1
	fmt.Printf("%T %v %t\n", s, s, s == nil)

	isbn, _ := catalog.ParseISBN("978-0-306-40615-7")
	s = isbn // dynamic type catalog.ISBN, value is a string
	fmt.Printf("%T %v\n", s, s)

	var p *catalog.MemStore  // nil pointer of a concrete type
	var st catalog.Store = p // interface now holds (*catalog.MemStore, nil)
	fmt.Printf("%T %t\n", st, st == nil)
}

<nil> <nil> true
catalog.LoanState on loan false
catalog.ISBN 9780306406157
*catalog.MemStore false

package main

import (
	"errors"
	"fmt"
)

type ParseError struct{ Line int }

func (e *ParseError) Error() string { return fmt.Sprintf("parse error on line %d", e.Line) }

// bad returns a typed nil pointer wrapped in a non-nil error interface.
func bad(fail bool) error {
	var perr *ParseError
	if fail {
		perr = &ParseError{Line: 3}
	}
	return perr
}

// good returns the nil interface explicitly.
func good(fail bool) error {
	if fail {
		return &ParseError{Line: 3}
	}
	return nil
}

func main() {
	err := bad(false)
	fmt.Println("bad(false) == nil:", err == nil)
	fmt.Printf("dynamic type %T, value %v\n", err, err == (*ParseError)(nil))

	err = good(false)
	fmt.Println("good(false) == nil:", err == nil)

	var pe *ParseError
	fmt.Println(errors.As(bad(true), &pe), pe.Line)
}

bad(false) == nil: false
dynamic type *main.ParseError, value true
good(false) == nil: true
true 3

package main

import "fmt"

func main() {
	titles := []string{"Dune", "Ubik"}
	fmt.Println(titles...) // []string is not []any
}

./main.go:7:14: cannot use titles (variable of type []string) as []any value in argument to fmt.Println

package main

import (
	"fmt"
	"strings"
)

func main() {
	titles := []string{"Dune", "Ubik", "Solaris"}

	// []string is not []any, even though string is assignable to any:
	// the two slices have different memory layouts, so convert element by element.
	args := make([]any, len(titles))
	for i, t := range titles {
		args[i] = strings.ToUpper(t)
	}
	fmt.Println(args...)
	fmt.Println(len(args), cap(args))
}

DUNE UBIK SOLARIS
3 3

package main

import (
	"fmt"
	"io"
)

type book struct{ title string }

func main() {
	var r io.Reader
	b, ok := r.(book) // book has no Read method: this can never succeed
	fmt.Println(b, ok)

	switch r.(type) {
	case book:
	}
}

./main.go:12:11: impossible type assertion: r.(book)
	book does not implement io.Reader (missing method Read)
./main.go:16:7: impossible type switch case: book
	r (variable of interface type io.Reader) cannot have dynamic type book (missing method Read)

package main

import (
	"fmt"

	"example.com/shelf/catalog"
)

func main() {
	var v any = catalog.OnLoan

	// comma-ok form: no panic, ok reports success
	if s, ok := v.(catalog.LoanState); ok {
		fmt.Println("LoanState", int(s), s)
	}
	n, ok := v.(int)
	fmt.Println("int?", n, ok) // zero value and false

	// assertion to an interface type checks the method set at run time
	if st, ok := v.(fmt.Stringer); ok {
		fmt.Println("Stringer:", st.String())
	}

	// single-value form panics when the assertion fails
	defer func() {
		r := recover()
		fmt.Println("recovered:", r)
		if e, ok := r.(error); ok {
			fmt.Printf("%T\n", e)
		}
	}()
	_ = v.(string)
}

LoanState 1 on loan
int? 0 false
Stringer: on loan
recovered: interface conversion: interface {} is catalog.LoanState, not string
*runtime.TypeAssertionError

package main

import (
	"fmt"
	"time"

	"example.com/shelf/catalog"
)

func describe(v any) string {
	switch x := v.(type) {
	case nil:
		return "nil interface"
	case int, int64: // several types: x keeps the interface type any
		return fmt.Sprintf("integer %v (%T)", x, x)
	case string:
		return "string of length " + fmt.Sprint(len(x))
	case catalog.ISBN: // concrete defined type
		return "isbn " + string(x)
	case error: // interface case, matched by method set
		return "error: " + x.Error()
	case fmt.Stringer:
		return "stringer: " + x.String()
	case []catalog.Book:
		return fmt.Sprintf("%d books", len(x))
	case func() time.Time:
		return "a clock function"
	default:
		return fmt.Sprintf("something else: %T", x)
	}
}

func main() {
	var e error
	for _, v := range []any{
		nil, 42, int64(7), "dune", catalog.ISBN("9780306406157"),
		fmt.Errorf("boom"), catalog.Overdue, []catalog.Book{{}, {}},
		time.Now, 3.14, e,
	} {
		fmt.Println(describe(v))
	}
}

nil interface
integer 42 (int)
integer 7 (int64)
string of length 4
isbn 9780306406157
error: boom
stringer: overdue
2 books
a clock function
something else: float64
nil interface

package main

import "fmt"

func kind(v any) string {
	switch v.(type) {
	case int:
		return "int"
	case string, int:
		return "dup"
	}
	return ""
}

func main() { fmt.Println(kind(1)) }

./main.go:9:15: duplicate case int in type switch
	./main.go:7:7: previous case

package main

import (
	"fmt"
	"slices"
	"sort"
	"strings"

	"example.com/shelf/catalog"
)

// byTitle implements sort.Interface (the classic three methods).
type byTitle []catalog.Book

func (s byTitle) Len() int           { return len(s) }
func (s byTitle) Less(i, j int) bool { return s[i].Title < s[j].Title }
func (s byTitle) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

func titles(bs []catalog.Book) []string {
	var out []string
	for _, b := range bs {
		out = append(out, b.Title)
	}
	return out
}

func main() {
	books := []catalog.Book{{Title: "Neuromancer"}, {Title: "Dune"}, {Title: "Ubik"}}

	sort.Sort(byTitle(books))
	fmt.Println(titles(books))

	sort.Sort(sort.Reverse(byTitle(books)))
	fmt.Println(titles(books))

	// Since Go 1.21 a func and generics replace the interface in new code.
	slices.SortFunc(books, func(a, b catalog.Book) int {
		return strings.Compare(a.Title, b.Title)
	})
	fmt.Println(titles(books))
}

[Dune Neuromancer Ubik]
[Ubik Neuromancer Dune]
[Dune Neuromancer Ubik]

package main

import (
	"fmt"
)

type point struct{ x, y int }

func main() {
	var a, b any = point{1, 2}, point{1, 2}
	fmt.Println(a == b) // same dynamic type, equal values

	var c any = 1
	var d any = int64(1)
	fmt.Println(c == d) // different dynamic types: never equal

	var e, f any = "x", "x"
	fmt.Println(e == f)

	// map keys of interface type work for comparable dynamic types
	m := map[any]string{1: "int", "1": "string", point{0, 0}: "origin"}
	fmt.Println(m[1], m["1"], m[point{0, 0}], len(m))

	// comparing non-comparable dynamic types panics at run time
	defer func() { fmt.Println("recovered:", recover()) }()
	var g, h any = []int{1}, []int{1}
	fmt.Println(g == h)
}

true
false
true
int string origin 3
recovered: runtime error: comparing uncomparable type []int

package main

import (
	"fmt"

	"example.com/shelf/catalog"
)

// The consumer declares only what it needs (one method), not the whole Store.
type bookGetter interface {
	Get(isbn catalog.ISBN) (catalog.Book, bool)
}

// Lend accepts an interface...
func Lend(g bookGetter, isbn catalog.ISBN, member string) (catalog.Loan, error) {
	if _, ok := g.Get(isbn); !ok {
		return catalog.Loan{}, fmt.Errorf("lend %s: %w", isbn, errNotFound)
	}
	return catalog.Loan{Book: isbn, Member: member, State: catalog.OnLoan}, nil
}

var errNotFound = fmt.Errorf("book not found")

// ...and a constructor returns the concrete struct, never the interface.
func NewStore() *catalog.MemStore { return catalog.NewMemStore() }

// A test double needs only one method.
type fakeGetter map[catalog.ISBN]catalog.Book

func (f fakeGetter) Get(i catalog.ISBN) (catalog.Book, bool) { b, ok := f[i]; return b, ok }

func main() {
	s := NewStore()
	s.Put(catalog.Book{ISBN: "9780306406157", Title: "Dune"})

	fmt.Println(Lend(s, "9780306406157", "ada"))
	fmt.Println(Lend(s, "0000000000000", "ada"))
	fmt.Println(Lend(fakeGetter{"1": {Title: "Fake"}}, "1", "bob"))
}

{9780306406157 ada on loan} <nil>
{  available} lend 0000000000000: book not found
{1 bob on loan} <nil>

package main

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

// flusher is an optional interface: a Writer may or may not support it.
type flusher interface{ Flush() error }

type logWriter struct{ w io.Writer }

func (l logWriter) Write(p []byte) (int, error) { return l.w.Write(p) }
func (l logWriter) Flush() error {
	fmt.Fprintln(l.w, "[flushed]")
	return nil
}

// write uses a plain Writer but upgrades when the value supports Flush.
func write(w io.Writer, s string) {
	fmt.Fprintln(w, s)
	if f, ok := w.(flusher); ok {
		f.Flush()
	}
}

func main() {
	write(os.Stdout, "plain")
	write(logWriter{os.Stdout}, "buffered")

	// the standard library uses the same pattern: io.Copy upgrades to WriterTo
	var sb strings.Builder
	n, _ := io.Copy(&sb, strings.NewReader("copy me"))
	_, isWT := any(strings.NewReader("")).(io.WriterTo)
	fmt.Println(n, sb.String(), isWT)
}

plain
buffered
[flushed]
7 copy me true

package main

import (
	"fmt"
	"strconv"

	"example.com/shelf/catalog"
)

// Number is a general interface (type set), usable only as a constraint.
type Number interface {
	~int | ~int64 | ~float64
}

func Sum[T Number](xs ...T) T {
	var s T
	for _, x := range xs {
		s += x
	}
	return s
}

// A basic interface used as a constraint: T must have String.
func Join[T fmt.Stringer](xs []T) string {
	out := ""
	for i, x := range xs {
		if i > 0 {
			out += ", "
		}
		out += x.String()
	}
	return out
}

type Count int

func (c Count) String() string { return "#" + strconv.Itoa(int(c)) }

func main() {
	fmt.Println(Sum(1, 2, 3), Sum(1.5, 2.5), Sum(Count(4), Count(5)))
	fmt.Println(Join([]catalog.LoanState{catalog.Available, catalog.Overdue}))
	fmt.Println(Join([]Count{1, 2}))
}

6 4 #9
available, overdue
#1, #2

package main

import "fmt"

type Number interface {
	~int | ~float64
}

func main() {
	var n Number = 3 // a type-set interface is only a constraint
	fmt.Println(n)
}

./main.go:10:8: cannot use type Number outside a type constraint: interface contains type constraints

package main

import (
	"fmt"
	"strings"
)

// Set stores keys; the generic method Map takes its own type parameter (Go 1.27).
type Set struct{ items []string }

func (s *Set) Add(x string) { s.items = append(s.items, x) }

func (s *Set) Convert[T any](f func(string) T) []T {
	out := make([]T, 0, len(s.items))
	for _, x := range s.items {
		out = append(out, f(x))
	}
	return out
}

func main() {
	s := &Set{}
	s.Add("dune")
	s.Add("ubik")
	fmt.Println(s.Convert(strings.ToUpper))
	fmt.Println(s.Convert(func(x string) int { return len(x) }))
}

[DUNE UBIK]
[4 4]

package main

import "fmt"

type Mapper interface {
	Apply(x int) int
}

type doubler struct{}

func (doubler) Apply[T any](x T) T { return x }

func main() {
	var m Mapper = doubler{}
	fmt.Println(m.Apply(2))
}

./main.go:14:17: cannot use doubler{} (value of struct type doubler) as Mapper value in variable declaration: doubler does not implement Mapper (wrong type for method Apply)
		have Apply[T any](T) T
		want Apply(int) int

package main

import (
	"errors"
	"fmt"
	"reflect"

	"example.com/shelf/catalog"
)

// errors.AsType[E error] requires E to implement error, so embed it.
type temporary interface {
	error
	Temporary() bool
}

type netErr struct{}

func (netErr) Error() string   { return "connection reset" }
func (netErr) Temporary() bool { return true }

func main() {
	// reflect: ask about interfaces at run time
	stringer := reflect.TypeFor[fmt.Stringer]()
	fmt.Println(stringer.Kind(), stringer.NumMethod(), stringer.Method(0).Name)
	fmt.Println(reflect.TypeFor[catalog.LoanState]().Implements(stringer))
	fmt.Println(reflect.TypeFor[catalog.Book]().Implements(stringer))
	fmt.Println(reflect.TypeFor[*catalog.MemStore]().Implements(reflect.TypeFor[catalog.Store]()))

	// errors.AsType (Go 1.26) with an interface type parameter
	err := fmt.Errorf("fetch: %w", netErr{})
	if t, ok := errors.AsType[temporary](err); ok {
		fmt.Println("temporary:", t.Temporary())
	}
	var tgt temporary // the older errors.As form takes a pointer to the target
	fmt.Println(errors.As(err, &tgt), tgt != nil)
}

interface 1 String
true
false
true
temporary: true
true true

package main

import "fmt"

type number int

// The method name ReadByte is reserved by io.ByteReader: vet checks the signature.
func (n number) ReadByte() int { return int(n) }

func main() {
	fmt.Println(number(1).ReadByte())
}

./main.go:8:17: method ReadByte() int should have signature ReadByte() (byte, error)

package main

import (
	"errors"
	"fmt"
	"os"
)

func main() {
	_, err := os.Open("/nonexistent")
	var pe os.PathError
	fmt.Println(errors.As(err, pe)) // the target must be a pointer
}

./main.go:12:14: second argument to errors.As must be a non-nil pointer to either a type that implements error, or to any interface type

package main

import (
	"fmt"
	"io"
)

func main() {
	var r io.Reader
	// io.Reader.Read has a different signature from the asserted interface,
	// so no type can ever satisfy both.
	if x, ok := r.(interface{ Read() }); ok {
		fmt.Println(x)
	}
}

./main.go:12:17: impossible type assertion: no type can implement both io.Reader and interface{Read()} (conflicting types for Read method)