Go Data Structures

type User struct {
    Name  string
    Age   int
    Email string
    Admin bool
}

// Named literal — preferred, order-independent
u := User{Name: "Alice", Age: 30, Email: "alice@example.com"}

// Positional literal — fragile, avoid for >2 fields
u2 := User{"Bob", 25, "bob@example.com", false}

// Field access
fmt.Println(u.Name)  // "Alice"
u.Age = 31

// Anonymous struct — useful for one-off shapes (JSON, test cases)
point := struct{ X, Y int }{X: 1, Y: 2}

// Struct is a value type — assignment copies all fields
u3 := u
u3.Name = "Carol"
fmt.Println(u.Name)  // still "Alice"

type Rect struct{ Width, Height float64 }

// Value receiver — gets a copy, cannot mutate the original
func (r Rect) Area() float64 {
    return r.Width * r.Height
}

// Pointer receiver — operates on the original, can mutate it
func (r *Rect) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

rect := Rect{Width: 4, Height: 3}
fmt.Println(rect.Area()) // 12
rect.Scale(2)
fmt.Println(rect.Area()) // 48

// Go auto-takes the address: rect.Scale(2) is (&rect).Scale(2)

type Animal struct {
    Name string
}

func (a Animal) Speak() string { return a.Name + " speaks" }

type Dog struct {
    Animal        // embedded — no field name
    Breed string
}

d := Dog{
    Animal: Animal{Name: "Rex"},
    Breed:  "Labrador",
}

// Promoted — access Animal fields/methods directly on Dog
fmt.Println(d.Name)      // "Rex"    (d.Animal.Name)
fmt.Println(d.Speak())  // "Rex speaks"
fmt.Println(d.Breed)     // "Labrador"

type Cat struct {
    Animal
}

// Define a method with the same name — shadows the embedded one
func (c Cat) Speak() string { return c.Name + " meows" }

cat := Cat{Animal: Animal{Name: "Whiskers"}}
fmt.Println(cat.Speak())        // "Whiskers meows" — Cat's method
fmt.Println(cat.Animal.Speak()) // "Whiskers speaks" — explicit call

// Embedding also works with interfaces — a common pattern
type ReadWriter interface {
    io.Reader  // embeds Reader interface
    io.Writer  // embeds Writer interface
}

// Explicit size
var a [3]int              // [0 0 0]
a[0] = 10

// Literal
b := [3]int{1, 2, 3}

// Let compiler count with ...
c := [...]string{"foo", "bar", "baz"}  // [3]string

// Sparse initialisation — unset elements stay zero
d := [5]int{1: 10, 4: 50}             // [0 10 0 0 50]

fmt.Println(len(c)) // 3

// Arrays are comparable if their element type is comparable
[2]int{1, 2} == [2]int{1, 2}  // true

// make([]T, len, cap) — cap is optional, defaults to len
s := make([]int, 3)       // [0 0 0]  len=3 cap=3
s  = make([]int, 3, 10)   // [0 0 0]  len=3 cap=10

// Literal
nums := []int{10, 20, 30, 40, 50}

// append — returns a (possibly new) slice
nums = append(nums, 60)
nums = append(nums, 70, 80)     // multiple at once
more := []int{90, 100}
nums = append(nums, more...)  // spread another slice

// Slicing — shares the underlying array
a := nums[1:4]   // elements 1,2,3 — [20 30 40]
b := nums[:3]    // from start    — [10 20 30]
c := nums[3:]    // to end        — [40 50 ...]

// Writing through a sub-slice affects the original
a[0] = 99
fmt.Println(nums[1]) // 99

// make or literal
ages := make(map[string]int)
ages = map[string]int{
    "alice": 30,
    "bob":   25,
}

// Write
ages["carol"] = 28

// Read — missing key returns zero value, not an error
fmt.Println(ages["alice"])   // 30
fmt.Println(ages["nobody"])  // 0 — zero value for int

// Comma-ok — distinguish "key missing" from "value is zero"
v, ok := ages["alice"]   // v=30, ok=true
v, ok  = ages["nobody"]  // v=0,  ok=false

// Delete
delete(ages, "bob")
fmt.Println(len(ages)) // 2

// Iterate — order is random on every run
for k, v := range ages {
    fmt.Printf("%s: %d\n", k, v)
}

type Stringer interface {
    String() string
}

type Color struct{ R, G, B uint8 }

// Color satisfies Stringer — no declaration needed
func (c Color) String() string {
    return fmt.Sprintf("#%02x%02x%02x", c.R, c.G, c.B)
}

func print(s Stringer) { fmt.Println(s.String()) }

print(Color{255, 128, 0}) // "#ff8000"

// Interface value holds (type, value) pair
var s Stringer = Color{0, 255, 0}
fmt.Printf("%T\n", s) // "main.Color"

var i any = "hello"

// Direct assertion — panics if wrong type
s := i.(string)
fmt.Println(s) // "hello"

// Comma-ok — safe, no panic
s, ok := i.(string)  // s="hello", ok=true
n, ok := i.(int)     // n=0,       ok=false

// Always prefer comma-ok unless you're certain of the type
if s, ok := i.(string); ok {
    fmt.Println("string value:", s)
}

// Asserting to an interface — checks method set
type Closer interface{ Close() error }
if c, ok := i.(Closer); ok {
    c.Close()
}

// [T any] — T can be any type
func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

Map([]int{1, 2, 3}, func(n int) string {
    return strconv.Itoa(n)
})
// ["1" "2" "3"]

// comparable — allows == and != operators
func Contains[T comparable](s []T, v T) bool {
    for _, item := range s {
        if item == v { return true }
    }
    return false
}

Contains([]string{"a", "b"}, "b") // true
Contains([]int{1, 2, 3}, 4)        // false

// Interface as constraint — restrict which types are allowed
type Number interface {
    ~int | ~int64 | ~float64
}

// ~ means "any type whose underlying type is T"
func Sum[T Number](nums []T) T {
    var total T
    for _, n := range nums { total += n }
    return total
}

Sum([]int{1, 2, 3})       // 6
Sum([]float64{1.1, 2.2}) // 3.3

// Generic type — Stack[T]
type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(v T)     { s.items = append(s.items, v) }
func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    n := len(s.items) - 1
    v := s.items[n]
    s.items = s.items[:n]
    return v, true
}

var st Stack[int]
st.Push(1); st.Push(2)
v, _ := st.Pop()  // 2