Structs and Embedding

package main

import "fmt"

// ISBN is a validated ISBN-13 (see the catalog package).
type ISBN string

type Author struct {
	Name string
	Born int
}

type Book struct {
	ISBN    ISBN
	Title   string
	Authors []Author
	Pages   int
}

func main() {
	// Keyed literal: fields may be omitted and reordered; omitted fields are zero.
	dune := Book{
		Title:   "Dune",
		ISBN:    "9780441172719",
		Authors: []Author{{Name: "Frank Herbert", Born: 1920}},
	}
	fmt.Printf("%v\n%+v\n", dune, dune)
	fmt.Printf("%#v\n", Author{"Ursula K. Le Guin", 1929})

	// Zero value: every field has its own zero value.
	var empty Book
	fmt.Printf("%+v %t\n", empty, empty.Authors == nil)

	// Pointers: new, &T{} and automatic dereference in selectors.
	p := &dune
	p.Pages = 412
	q := new(Book)
	q.Title = "Emma"
	r := &Book{Title: "Ulysses"}
	fmt.Println(dune.Pages, (*p).Pages, q.Title, r.Title)

	// Assignment copies the struct (but not what a slice field points to).
	cp := dune
	cp.Title = "Dune (copy)"
	cp.Authors[0].Name = "F. Herbert"
	fmt.Println(dune.Title, dune.Authors[0].Name)
}

{9780441172719 Dune [{Frank Herbert 1920}] 0}
{ISBN:9780441172719 Title:Dune Authors:[{Name:Frank Herbert Born:1920}] Pages:0}
main.Author{Name:"Ursula K. Le Guin", Born:1929}
{ISBN: Title: Authors:[] Pages:0} true
412 412 Emma Ulysses
Dune F. Herbert

package main

import (
	"fmt"
	"slices"
)

type Author struct{ Name string }

type Book struct {
	Title   string
	Authors []Author
	Tags    map[string]bool
}

// Clone returns a copy that shares no mutable state with b.
func (b Book) Clone() Book {
	b.Authors = slices.Clone(b.Authors)
	if b.Tags != nil {
		tags := make(map[string]bool, len(b.Tags))
		for k, v := range b.Tags {
			tags[k] = v
		}
		b.Tags = tags
	}
	return b
}

func main() {
	a := Book{Title: "Dune", Authors: []Author{{"Frank Herbert"}}, Tags: map[string]bool{"sf": true}}

	shallow := a
	shallow.Authors[0].Name = "changed"
	shallow.Tags["classic"] = true
	fmt.Println(a.Authors[0].Name, len(a.Tags))

	a.Authors[0].Name = "Frank Herbert"
	deep := a.Clone()
	deep.Authors[0].Name = "changed"
	deep.Tags["new"] = true
	fmt.Println(a.Authors[0].Name, len(a.Tags), len(deep.Tags))
}

changed 2
Frank Herbert 2 3

package main

type Node struct {
	Value int
	Next  Node
}

func main() {}

./main.go:3:6: invalid recursive type: Node refers to itself

package main

import "fmt"

type Book struct {
	Title string
	Pages int
}

func main() {
	b := Book{"Dune"}
	c := Book{Title: "Dune", "412"}
	d := Book{Titel: "Dune"}
	fmt.Println(b, c, d)
}

./main.go:11:18: too few values in struct literal of type Book
./main.go:12:27: mixture of field:value and value elements in struct literal
./main.go:13:12: unknown field Titel in struct literal of type Book

package main

import (
	"fmt"
	"os"
)

func main() {
	err := fmt.Errorf("denied")
	// Positional literal: every field, in declaration order. Breaks when a field is added.
	e := os.PathError{"open", "/shelf/books.json", err}
	fmt.Println(e.Error())
}

main.go:11:7: os.PathError struct literal uses unkeyed fields

package main

import "fmt"

type Author struct {
	Name string
	Born int
}

func main() {
	// Anonymous struct: a type literal used once.
	cfg := struct {
		Addr    string
		Verbose bool
	}{Addr: ":8080", Verbose: true}
	fmt.Printf("%+v\n", cfg)

	// A table of test-like cases.
	cases := []struct {
		isbn  string
		valid bool
	}{
		{"9780441172719", true},
		{"9780441172710", false},
	}
	for _, c := range cases {
		fmt.Println(c.isbn, c.valid)
	}

	// Anonymous structs with identical fields are assignable to a named type.
	var a Author = struct {
		Name string
		Born int
	}{"Jane Austen", 1775}
	fmt.Println(a)

	// The empty struct occupies no memory.
	var e struct{}
	seen := map[string]struct{}{"Dune": {}}
	_, ok := seen["Dune"]
	done := make(chan struct{})
	go func() { close(done) }()
	<-done
	fmt.Println(e, ok, len(seen))
}

{Addr::8080 Verbose:true}
9780441172719 true
9780441172710 false
{Jane Austen 1775}
{} true 1

package main

import "fmt"

type Book struct {
	Title   string
	Authors []string
}

func main() {
	a := Book{Title: "Dune"}
	b := Book{Title: "Dune"}
	fmt.Println(a == b)
}

./main.go:13:14: invalid operation: a == b (struct containing []string cannot be compared)

package main

import "fmt"

type Point struct{ X, Y int }

type Edition struct {
	Year int
	Name string
}

type Shelf struct {
	Edition
	Row int
}

type Pair struct {
	A int `json:"a"`
	B int `json:"b"`
}

type Alt struct {
	A, B int
}

func main() {
	p, q := Point{1, 2}, Point{1, 2}
	fmt.Println(p == q, p != Point{2, 1})

	// Comparable structs are usable as map keys.
	where := map[Point]string{{0, 0}: "origin", {3, 4}: "shelf A"}
	fmt.Println(where[Point{3, 4}])

	// Conversion ignores tags when the underlying field sequences match.
	pair := Pair{1, 2}
	alt := Alt(pair)
	fmt.Println(alt)

	// Comparison of nested comparable fields.
	fmt.Println(Shelf{Edition{1965, "first"}, 1} == Shelf{Edition{1965, "first"}, 1})

	var x any = Point{1, 2}
	fmt.Println(x == any(Point{1, 2}))
}

true true
shelf A
{1 2}
true
true

package main

import (
	"fmt"
	"time"
)

// Audit records when a record was created and by whom.
type Audit struct {
	Created time.Time
	By      string
}

func (a Audit) Describe() string {
	return fmt.Sprintf("created %s by %s", a.Created.Format(time.DateOnly), a.By)
}

func (a *Audit) Touch(by string) { a.By = by }

type Book struct {
	Audit // embedded field: the field name is the type name, Audit
	Title string
}

func main() {
	b := Book{
		Audit: Audit{Created: time.Date(2026, 3, 14, 0, 0, 0, 0, time.UTC), By: "ana"},
		Title: "Dune",
	}
	// Promoted field and methods: b.By is shorthand for b.Audit.By.
	fmt.Println(b.By, b.Audit.By)
	fmt.Println(b.Describe())
	b.Touch("ben") // addressable b, so (&b.Audit).Touch
	fmt.Println(b.Describe())
	fmt.Printf("%+v\n", b.Audit.By)
}

ana ana
created 2026-03-14 by ana
created 2026-03-14 by ben
ben

package main

import "fmt"

// noCopy is the blank-field idiom: it takes no space and carries no data.
type Shelf struct {
	_     [0]func() // makes Shelf incomparable
	Label string
	_     int // padding or reserved field; cannot be read or set by name
}

type Counter struct{ n int }

func (c *Counter) Inc()      { c.n++ }
func (c Counter) Value() int { return c.n }

type Page struct {
	Counter // embedded value: *Page has Inc and Value, Page only Value
}

type Incer interface{ Inc() }
type Valuer interface{ Value() int }

func main() {
	var s Shelf
	s.Label = "A1"
	fmt.Printf("%+v\n", s)

	p := Page{}
	p.Inc() // fine: p is addressable, so the compiler takes &p
	var _ Valuer = p
	var _ Incer = &p
	// var _ Incer = p  // compile error: Page does not implement Incer (method Inc has pointer receiver)
	fmt.Println(p.Value())
}

{_:[] Label:A1 _:0}
1

./main.go:14:16: cannot use Page{} (value of struct type Page) as Incer value in variable declaration: Page does not implement Incer (method Inc has pointer receiver)

package main

import (
	"fmt"
	"reflect"
)

type Book struct {
	ISBN   string `json:"isbn" db:"isbn,primary"`
	Title  string `json:"title,omitempty" validate:"required"`
	Secret string `json:"-"`
	Pages  int    `json:"pages,omitzero"`
	hidden int
}

func main() {
	t := reflect.TypeFor[Book]()
	for i := range t.NumField() {
		f := t.Field(i)
		fmt.Printf("%-6s exported=%-5t tag=%q\n", f.Name, f.IsExported(), f.Tag)
	}

	f, _ := t.FieldByName("ISBN")
	fmt.Println(f.Tag.Get("json"), f.Tag.Get("db"), f.Tag.Get("xml") == "")

	v, ok := f.Tag.Lookup("xml")
	fmt.Printf("%q %t\n", v, ok)

	f, _ = t.FieldByName("Secret")
	v, ok = f.Tag.Lookup("json")
	fmt.Printf("%q %t\n", v, ok)
}

ISBN   exported=true  tag="json:\"isbn\" db:\"isbn,primary\""
Title  exported=true  tag="json:\"title,omitempty\" validate:\"required\""
Secret exported=true  tag="json:\"-\""
Pages  exported=true  tag="json:\"pages,omitzero\""
hidden exported=false tag=""
isbn isbn,primary true
"" false
"-" true

package main

import "fmt"

type Book struct {
	Title string `json: "title"`
}

func main() { fmt.Println(Book{}) }

main.go:6:2: struct field tag `json: "title"` not compatible with reflect.StructTag.Get: bad syntax for struct tag value

package main

import (
	"fmt"
	"structs"
	"unsafe"
)

type Loose struct {
	Active bool
	ID     int64
	Flag   bool
	Pages  int32
	Rare   bool
}

type Tight struct {
	ID     int64
	Pages  int32
	Active bool
	Flag   bool
	Rare   bool
}

// Header has the memory layout the host (C) ABI would give the same fields.
type Header struct {
	_     structs.HostLayout
	Magic uint32
	Size  uint16
	Kind  uint8
}

type Empty struct{}

type WithEmpty struct {
	A int32
	E Empty
}

func main() {
	fmt.Println("Loose:", unsafe.Sizeof(Loose{}), unsafe.Alignof(Loose{}))
	fmt.Println("Tight:", unsafe.Sizeof(Tight{}), unsafe.Alignof(Tight{}))
	var l Loose
	fmt.Println(unsafe.Offsetof(l.Active), unsafe.Offsetof(l.ID), unsafe.Offsetof(l.Flag),
		unsafe.Offsetof(l.Pages), unsafe.Offsetof(l.Rare))
	var t Tight
	fmt.Println(unsafe.Offsetof(t.ID), unsafe.Offsetof(t.Pages), unsafe.Offsetof(t.Active),
		unsafe.Offsetof(t.Flag), unsafe.Offsetof(t.Rare))
	fmt.Println("Header:", unsafe.Sizeof(Header{}), "Empty:", unsafe.Sizeof(Empty{}), "WithEmpty:", unsafe.Sizeof(WithEmpty{}))
}

Loose: 32 8
Tight: 16 8
0 8 16 20 24
0 8 12 13 14
Header: 8 Empty: 0 WithEmpty: 8

package main

import (
	"fmt"
	"sync"
)

type Store struct {
	mu    sync.Mutex
	books map[string]int
}

func count(s Store) int { return len(s.books) }

func main() {
	s := Store{books: map[string]int{"Dune": 1}}
	fmt.Println(count(s))
}

main.go:13:14: count passes lock by value: example.com/errs/f4.Store contains sync.Mutex
main.go:17:20: call of count copies lock value: example.com/errs/f4.Store contains sync.Mutex

package main

import "fmt"

type Book struct{ Title string }

func main() {
	var b *Book
	fmt.Println(b.Title)
}

panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x2 addr=0x0 pc=...]