Error Handling 🐹

package main

import (
    "errors"
    "fmt"
)

// In Go an error is just a VALUE you return, not a thrown exception.
// By convention error is the LAST return value, so a function that can
// fail returns (result, error). On success you return a real result and
// nil; on failure you return the zero value and a non-nil error.
func divide(a, b float64) (float64, error) {
    if b == 0 {
        // errors.New builds a simple error from a fixed message.
        return 0, errors.New("division by zero")
    }
    return a / b, nil // nil means "no error"
}

func main() {
    // The cornerstone idiom: call, then check err BEFORE using the result.
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("error:", err)
        return // stop early — don't use a result that may be invalid
    }
    fmt.Printf("10 / 2 = %.1f\n", result) // 10 / 2 = 5.0

    // The failure path. We don't need the result, so discard it with _.
    _, err = divide(10, 0)
    if err != nil {
        fmt.Println("error:", err) // error: division by zero
    }

    // fmt.Errorf is errors.New with formatting — bake in dynamic data.
    id := 42
    fmt.Println(fmt.Errorf("user %d not found", id)) // user 42 not found
}

10 / 2 = 5.0
error: division by zero
user 42 not found

package main

import (
    "errors"
    "fmt"
)

// 🎯 YOUR TURN — fill in each ___ , then run it on the Go Playground.

// parseAge should return (0, an error) when age is negative,
// and (the age, nil) when it is valid.
func parseAge(age int) (int, error) {
    if age < 0 {
        // 1) Return zero and a new error explaining the problem.
        return 0, ___ // 👉 errors.New("age cannot be negative")
    }
    // 2) On success, return the age and nil (no error).
    return age, ___ // 👉 nil
}

func main() {
    if a, err := parseAge(30); err != nil {
        fmt.Println("error:", err)
    } else {
        fmt.Println("age is", a) // age is 30
    }

    // 3) Check the error from a bad call and print it.
    _, err := parseAge(-5)
    if err ___ nil { // 👉 != (only act when there IS an error)
        fmt.Println("error:", err)
    }
}

// ✅ Expected output:
//    age is 30
//    error: age cannot be negative

age is 30
error: age cannot be negative

package main

import (
    "errors"
    "fmt"
)

// SENTINEL error: a single shared value for a known condition. Callers
// compare against it (with errors.Is) to react to that specific case.
var ErrNotFound = errors.New("not found")

// CUSTOM error type: ANY type with an  Error() string  method is an error.
// Use it when you want to carry extra data (here: which field failed).
type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("%s: %s", e.Field, e.Message)
}

func findUser(id int) error {
    // %w WRAPS ErrNotFound: it adds context AND keeps the original
    // detectable later via errors.Is. (%v would lose that link.)
    return fmt.Errorf("find user %d: %w", id, ErrNotFound)
}

func main() {
    err := findUser(42)
    fmt.Println(err) // find user 42: not found

    // errors.Is walks the whole wrap chain looking for a sentinel.
    if errors.Is(err, ErrNotFound) {
        fmt.Println("-> that user does not exist")
    }

    // errors.As pulls a specific error TYPE out of the chain so you
    // can read its fields. It needs a pointer to a variable of that type.
    var ve *ValidationError
    bad := &ValidationError{Field: "email", Message: "invalid format"}
    if errors.As(error(bad), &ve) {
        fmt.Println("-> failing field:", ve.Field) // -> failing field: email
    }
}

find user 42: not found
-> that user does not exist
-> failing field: email

package main

import (
    "errors"
    "fmt"
)

// 🎯 YOUR TURN — fill in the two ___ blanks.

var ErrConnRefused = errors.New("connection refused")

func queryDB() error {
    return ErrConnRefused // the low-level failure
}

func loadUser(id int) error {
    if err := queryDB(); err != nil {
        // 1) Wrap err with context, keeping the chain inspectable.
        //    Use the %w verb (NOT %v) so errors.Is still works.
        return fmt.Errorf("load user %d: %w", id, ___) // 👉 err
    }
    return nil
}

func main() {
    err := loadUser(7)
    fmt.Println("error:", err) // error: load user 7: connection refused

    // 2) Detect the ROOT cause through the wrap chain.
    if errors.___(err, ErrConnRefused) { // 👉 Is
        fmt.Println("root cause: database unreachable")
    }
}

// ✅ Expected output:
//    error: load user 7: connection refused
//    root cause: database unreachable

error: load user 7: connection refused
root cause: database unreachable

package main

import (
    "errors"
    "fmt"
)

// The lowest layer fails with a sentinel error.
var ErrConnRefused = errors.New("connection refused")

func queryDB() error {
    return fmt.Errorf("database: %w", ErrConnRefused)
}

// Each layer uses EARLY RETURN: handle the error and get out, which keeps
// the happy path flat and unindented. Wrap with %w to add this layer's context.
func fetchUser(id int) error {
    if err := queryDB(); err != nil {
        return fmt.Errorf("fetch user %d: %w", id, err)
    }
    return nil // the happy path stays at the bottom, unindented
}

func getProfile(id int) error {
    if err := fetchUser(id); err != nil {
        return fmt.Errorf("get profile: %w", err)
    }
    return nil
}

func main() {
    err := getProfile(42)
    // Each wrap prepended its context, building a breadcrumb trail.
    fmt.Println("error:", err)

    // The original cause is STILL detectable through the whole chain.
    if errors.Is(err, ErrConnRefused) {
        fmt.Println("root cause: the database was unreachable")
    }
}

error: get profile: fetch user 42: database: connection refused
root cause: the database was unreachable

package main

import "fmt"

// panic is for UNRECOVERABLE programmer bugs, not expected failures.
// A bad user input is an error you return; a logic bug (impossible state,
// a nil you should never get) is a panic. Reach for it rarely.

func mustPositive(n int) int {
    if n <= 0 {
        // This signals "the program is in a state that should be impossible".
        panic(fmt.Sprintf("mustPositive: got %d", n))
    }
    return n
}

// recover stops a panic from crashing the program, but only inside a
// deferred function. Libraries use it at a boundary to turn a panic
// back into an ordinary error rather than killing the whole process.
func safeCall(n int) (result int, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("recovered: %v", r) // panic -> normal error
        }
    }()
    return mustPositive(n), nil
}

func main() {
    if r, err := safeCall(5); err == nil {
        fmt.Println("ok:", r) // ok: 5
    }

    if _, err := safeCall(-1); err != nil {
        fmt.Println(err) // recovered: mustPositive: got -1
    }

    fmt.Println("program keeps running") // we did NOT crash
}

ok: 5
recovered: mustPositive: got -1
program keeps running