Type Assertions — Professional Level¶

import "errors"

type ValidationError struct{ Field, Msg string }
func (e *ValidationError) Error() string { return e.Msg }

func process(req Request) error {
    if err := validate(req); err != nil {
        var ve *ValidationError
        if errors.As(err, &ve) {
            // structured error response
            return BadRequest(ve.Field, ve.Msg)
        }
        return InternalError(err)
    }
    return nil
}

func writeLog(w io.Writer, msg string) {
    fmt.Fprintln(w, msg)
    if f, ok := w.(interface{ Flush() error }); ok {
        f.Flush()
    }
}

func GetInt(m map[string]any, key string, def int) int {
    v, ok := m[key]
    if !ok { return def }
    n, ok := v.(int)
    if !ok { return def }
    return n
}

type Plugin interface { Run() error }
type Configurable interface { Configure(map[string]any) error }

func StartPlugin(p Plugin, cfg map[string]any) error {
    if c, ok := p.(Configurable); ok {
        if err := c.Configure(cfg); err != nil { return err }
    }
    return p.Run()
}

// Bad
func processEntity(e any) {
    switch v := e.(type) {
    case *User:    processUser(v)
    case *Order:   processOrder(v)
    case *Product: processProduct(v)
    }
}

// Good
type Processor interface { Process() error }
func processEntity(p Processor) error { return p.Process() }

// Bad
v := i.(T)   // panic risk

// Good
v, ok := i.(T)
if !ok { return ErrUnexpectedType }

// Bad
if e, ok := err.(*MyError); ok { ... }

// Good
var e *MyError
if errors.As(err, &e) { ... }

// Bad — caller has to do the assertion
func GetData() any { ... }

// Good — typed return
func GetUser() (*User, error) { ... }

// Decode parses payload as JSON.
//
// On success, the result is one of:
//   - map[string]any
//   - []any
//   - float64, string, bool, nil
//
// Use type assertion or json.Unmarshal with a typed struct.
func Decode(payload []byte) (any, error) { ... }

func TestNotFound(t *testing.T) {
    err := find("missing")
    var nf *NotFoundError
    if !errors.As(err, &nf) {
        t.Fatalf("expected NotFoundError, got %T", err)
    }
    if nf.ID != "missing" {
        t.Errorf("expected ID=missing, got %s", nf.ID)
    }
}

func TestSeekable(t *testing.T) {
    r := &MyReader{}
    if _, ok := any(r).(io.Seeker); ok {
        t.Error("expected NOT seekable")
    }
}