Interfaces

package main

import (
    "fmt"
    "math"
)

// Define an interface
type Shape interface {
    Area() float64
    Perimeter() float64
}

// Circle implicitly satisfies Shape
type Circle struct{ Radius float64 }

func (c Circle) Area() float64      { return math.Pi * c.Radius * c.Radius }
func (c Circle) Perimeter() float64 { return 2 * math.Pi * c.Radius }

// Rectangle implicitly satisfies Shape
type Rectangle struct{ Width, Height float64 }

func (r Rectangle) Area() float64      { return r.Width * r.Height }
func (r Rectangle) Perimeter() float64 { return 2 * (r.Width + r.Height) }

// Triangle also satisfies Shape
type Triangle struct{ A, B, C float64 } // side lengths

func (t Triangle) Perimeter() float64 { return t.A + t.B + t.C }
func (t Triangle) Area() float64 {
    s := t.Perimeter() / 2
    return math.Sqrt(s * (s - t.A) * (s - t.B) * (s - t.C)) // Heron's formula
}

// Function that accepts any Shape
func printShapeInfo(s Shape) {
    fmt.Printf("Type: %T\n  Area: %.4f\n  Perimeter: %.4f\n", s, s.Area(), s.Perimeter())
}

func totalArea(shapes []Shape) float64 {
    total := 0.0
    for _, s := range shapes {
        total += s.Area()
    }
    return total
}

func main() {
    shapes := []Shape{
        Circle{Radius: 5},
        Rectangle{Width: 4, Height: 6},
        Triangle{A: 3, B: 4, C: 5},
    }

    for _, s := range shapes {
        printShapeInfo(s)
    }

    fmt.Printf("Total area: %.4f\n", totalArea(shapes))

    // Compile-time interface check (no runtime cost)
    var _ Shape = Circle{}      // ensures Circle implements Shape
    var _ Shape = Rectangle{}   // ensures Rectangle implements Shape
}

package main

import "fmt"

type Animal interface {
    Sound() string
}

type Dog struct{ Name string }
func (d *Dog) Sound() string { return "Woof" }

func getAnimal(createDog bool) Animal {
    var d *Dog = nil  // d is a nil *Dog

    if createDog {
        d = &Dog{Name: "Rex"}
    }

    return d  // ← THIS IS THE CLASSIC GOTCHA!
    // Even when d is nil, we return an interface with:
    //   type word: *Dog (non-nil!)
    //   data word: nil
    // So the interface itself is NOT nil!
}

func main() {
    // ✅ Correct nil check
    a1 := getAnimal(false)
    fmt.Println("a1 == nil:", a1 == nil)  // false!!! (type word is *Dog)
    // Calling a1.Sound() would PANIC — data is nil

    // The fix: return nil directly from the function, not a nil typed value
    // return nil  // ← this sets both words to nil

    // Normal usage
    a2 := getAnimal(true)
    fmt.Println("a2 == nil:", a2 == nil)  // false (and correctly has a value)
    fmt.Println(a2.Sound())               // Woof

    // Proper nil interface
    var a3 Animal  // zero value: both words nil
    fmt.Println("a3 == nil:", a3 == nil)  // true
}

package main

import "fmt"

type Animal interface{ Sound() string }
type Dog struct{ Breed string }
type Cat struct{ Indoor bool }

func (d Dog) Sound() string { return "Woof" }
func (c Cat) Sound() string { return "Meow" }

func describe(a Animal) {
    // ── Type assertion (single type) ──
    // Form 1: panics if wrong type — use only when you're certain!
    d := a.(Dog)  // panics if a is not Dog
    fmt.Println("dog breed:", d.Breed)
}

func safeDescribe(a Animal) {
    // Form 2: comma-ok — safe, no panic
    if d, ok := a.(Dog); ok {
        fmt.Println("It's a dog!", d.Breed)
    } else if c, ok := a.(Cat); ok {
        fmt.Println("It's a cat! indoor:", c.Indoor)
    } else {
        fmt.Println("Unknown animal")
    }
}

// ── Type switch — handle multiple types elegantly ──
func processValue(v interface{}) {
    switch x := v.(type) {
    case nil:
        fmt.Println("nil value")
    case int:
        fmt.Printf("int: %d (squared: %d)\n", x, x*x)
    case float64:
        fmt.Printf("float64: %f\n", x)
    case string:
        fmt.Printf("string: %q (len=%d)\n", x, len(x))
    case bool:
        fmt.Printf("bool: %v\n", x)
    case []int:
        fmt.Printf("[]int with %d elements\n", len(x))
    case Dog:
        fmt.Printf("Dog: %s\n", x.Breed)
    case Animal:  // catch-all for other Animal types
        fmt.Printf("some animal: %s\n", x.Sound())
    default:
        fmt.Printf("unknown type: %T\n", x)
    }
}

func main() {
    var a Animal = Dog{Breed: "Labrador"}
    safeDescribe(a)

    a = Cat{Indoor: true}
    safeDescribe(a)

    processValue(42)
    processValue(3.14)
    processValue("hello")
    processValue(Dog{Breed: "Poodle"})
    processValue(nil)
    processValue([]int{1, 2, 3})
}

package main

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

// Small, focused interfaces
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
}

// Composed interfaces
type ReadWriter interface {
    Reader
    Writer
}

type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

// Real stdlib composition:
// io.Reader, io.Writer, io.Closer, io.ReadWriter, io.ReadWriteCloser

func processData(r io.Reader) (string, error) {
    buf := new(bytes.Buffer)
    _, err := io.Copy(buf, r)
    return buf.String(), err
}

func main() {
    // strings.NewReader implements io.Reader
    r := strings.NewReader("Hello, World!")
    data, _ := processData(r)
    fmt.Println(data)  // Hello, World!

    // bytes.Buffer implements io.Reader AND io.Writer
    var buf bytes.Buffer
    buf.WriteString("buffered data")
    result, _ := processData(&buf)
    fmt.Println(result)

    // Accept interface, return interface principle:
    // Write functions accepting the smallest interface they need
    // io.Reader if you only need to read
    // io.Writer if you only need to write
    // This makes functions testable and composable
}