Structs and Interfaces 🐹

package main

import "fmt"

// A struct is a named type that groups related fields together.
// Think of it as a blueprint for one "thing" in your program.
type Person struct {
    Name string
    Age  int
}

func main() {
    // 1) Field names (clearest, order-independent, safest):
    alice := Person{Name: "Alice", Age: 30}

    // 2) Positional (must match the field order exactly):
    bob := Person{"Bob", 25}

    // 3) Zero value — every field gets its type's default:
    var empty Person // Name: "" (empty string), Age: 0

    // Read and write fields with a dot.
    alice.Age = 31 // it was her birthday

    fmt.Println("alice:", alice.Name, alice.Age) // alice: Alice 31
    fmt.Println("bob:  ", bob.Name, bob.Age)      // bob:   Bob 25
    fmt.Printf("empty: %+v\n", empty)             // %+v prints field names
}

alice: Alice 31
bob:   Bob 25
empty: {Name: Age:0}

package main

import "fmt"

func main() {
    // 🎯 YOUR TURN — fill in each ___ then run it.

    // 1) Define a Book struct with a Title (string) and Pages (int).
    type Book struct {
        ___    // 👉 Title string
        ___    // 👉 Pages int
    }

    // 2) Make a book using FIELD NAMES.
    b := Book{___}  // 👉 Title: "Go 101", Pages: 200

    // 3) Print the title and page count (this line already works).
    fmt.Printf("%s has %d pages\n", b.Title, b.Pages)

    // ✅ Expected output:
    //    Go 101 has 200 pages
}

Go 101 has 200 pages

package main

import "fmt"

type Counter struct {
    Count int
}

// VALUE receiver (c Counter): works on a COPY.
// Changes here do NOT affect the original.
func (c Counter) Show() {
    fmt.Println("count is", c.Count)
}

// POINTER receiver (c *Counter): works on the ORIGINAL.
// Changes here DO stick.
func (c *Counter) Increment() {
    c.Count++ // Go auto-dereferences, so it's c.Count, not (*c).Count
}

func main() {
    c := Counter{Count: 0}

    c.Increment() // pointer receiver -> modifies c
    c.Increment() // count is now 2
    c.Show()       // value receiver -> reads (a copy of) c

    // Rule of thumb: use a POINTER receiver when the method must
    // change the struct, OR the struct is large (avoid copying).
}

count is 2

package main

import "fmt"

type User struct {
    Name string
}

// Taking a *User lets the function modify the caller's struct.
func rename(u *User, name string) {
    u.Name = name // Go auto-dereferences struct pointers
}

func main() {
    x := 42
    p := &x          // & takes the ADDRESS of x; p is a *int
    fmt.Println(*p)  // * DEREFERENCES: read the value at p -> 42
    *p = 100         // write through the pointer -> changes x
    fmt.Println(x)   // 100 — x changed!

    user := User{Name: "Alice"}
    rename(&user, "Bob")           // pass the address so the change sticks
    fmt.Println("user:", user.Name) // user: Bob

    // Go has no pointer arithmetic (no p++ / p + 4) — memory stays safe.
}

42
100
user: Bob

package main

import "fmt"

type Wallet struct {
    Balance int
}

// 🎯 YOUR TURN — make Deposit actually change the wallet.

// 1) Give Deposit a POINTER receiver so the change sticks.
func (w ___) Deposit(amount int) {  // 👉 *Wallet
    w.Balance += amount
}

func main() {
    wallet := Wallet{Balance: 100}

    // 2) Add 50 to the wallet.
    wallet.Deposit(___)  // 👉 50

    fmt.Println("balance:", wallet.Balance)

    // ✅ Expected output:
    //    balance: 150
    // (With a VALUE receiver you'd wrongly get 100 — try it to see why!)
}

balance: 150

package main

import "fmt"

type Address struct {
    City string
}

// A method on the embedded type comes along for free.
func (a Address) Where() string { return "lives in " + a.City }

type User struct {
    Name string
}

// Employee EMBEDS User and Address (no field name = embedded).
// Go has no inheritance — this is composition.
type Employee struct {
    User    // promotes User's fields/methods
    Address // promotes Address's fields/methods
    Salary  int
}

func main() {
    e := Employee{
        User:    User{Name: "Alice"},
        Address: Address{City: "London"},
        Salary:  50000,
    }

    // Promoted: reach Name and City directly, no e.User.Name needed.
    fmt.Println(e.Name)     // Alice  (promoted from User)
    fmt.Println(e.City)     // London (promoted from Address)
    fmt.Println(e.Where())  // lives in London (promoted method)
    fmt.Println(e.Salary)   // 50000
}

Alice
London
lives in London
50000

package main

import "fmt"

// An interface is a list of method signatures — a contract.
// A type satisfies it just by HAVING those methods. There is no
// "implements" keyword; satisfaction is automatic (structural typing).
type Speaker interface {
    Speak() string
}

type Dog struct{ Name string }
type Robot struct{ ID int }

// Dog has a Speak() string method -> Dog satisfies Speaker.
func (d Dog) Speak() string { return d.Name + " says Woof" }

// Robot also has Speak() string -> Robot satisfies Speaker too.
func (r Robot) Speak() string { return fmt.Sprintf("Unit %d: Beep", r.ID) }

// announce accepts ANY Speaker — it doesn't care about the concrete type.
func announce(s Speaker) {
    fmt.Println(s.Speak())
}

func main() {
    announce(Dog{Name: "Rex"})
    announce(Robot{ID: 7})
}

Rex says Woof
Unit 7: Beep