Maps

package main

import "fmt"

func main() {
	stock := map[string]int{ // composite literal
		"Dune":    3,
		"Emma":    1,
		"Ulysses": 0,
	}
	fmt.Println(len(stock), stock["Dune"], stock["Missing"]) // a missing key yields the zero value

	n, ok := stock["Ulysses"] // comma-ok tells "stored zero" apart from "absent"
	fmt.Println(n, ok)
	_, ok = stock["Missing"]
	fmt.Println(ok)

	stock["Emma"]++ // read-modify-write works on a map element
	stock["Persuasion"] = 2
	delete(stock, "Ulysses")
	delete(stock, "Never added") // deleting an absent key is a no-op
	fmt.Println(stock)           // fmt prints maps sorted by key

	hinted := make(map[string]int, 1000) // size hint: preallocates, len is still 0
	fmt.Println(len(hinted))

	var nilMap map[string]int // zero value is nil
	fmt.Println(nilMap == nil, len(nilMap), nilMap["x"])
	delete(nilMap, "x") // allowed
	for range nilMap {  // allowed, zero iterations
	}

	clear(stock) // Go 1.21: delete every entry
	fmt.Println(len(stock))

	defer func() { fmt.Println("recovered:", recover()) }()
	nilMap["x"] = 1 // writing to a nil map panics
}

3 3 0
0 true
false
map[Dune:3 Emma:2 Persuasion:2]
0
true 0 0
0
recovered: assignment to entry in nil map

package main

import (
	"fmt"
	"testing"
)

func main() {
	const n = 1000
	grow := testing.AllocsPerRun(20, func() {
		m := map[int]int{}
		for i := range n {
			m[i] = i
		}
	})
	hint := testing.AllocsPerRun(20, func() {
		m := make(map[int]int, n)
		for i := range n {
			m[i] = i
		}
	})
	fmt.Println("allocations per run, no hint:", grow, "with hint:", hint)
}

allocations per run, no hint: 20 with hint: 5

package main

import "fmt"

type ISBN string

type Edition struct {
	ISBN ISBN
	Year int
}

func main() {
	// struct keys: comparable if every field is comparable
	sold := map[Edition]int{{"978-0-441-17271-9", 1965}: 12}
	sold[Edition{"978-0-441-17271-9", 1965}]++
	fmt.Println(sold)

	// array keys
	grid := map[[2]int]string{{0, 0}: "origin"}
	fmt.Println(grid[[2]int{0, 0}])

	// a map of slices: append to the zero value (nil) of a missing key
	byAuthor := map[string][]string{}
	byAuthor["Austen"] = append(byAuthor["Austen"], "Emma")
	byAuthor["Austen"] = append(byAuthor["Austen"], "Persuasion")
	byAuthor["Herbert"] = append(byAuthor["Herbert"], "Dune")
	fmt.Println(byAuthor)

	// a set: map[T]struct{} (struct{} occupies no space) or map[T]bool
	seen := map[string]struct{}{}
	for _, w := range []string{"a", "b", "a", "c", "b"} {
		seen[w] = struct{}{}
	}
	_, has := seen["c"]
	fmt.Println(len(seen), has)

	// interface keys: the dynamic types must be hashable
	anyKeys := map[any]string{1: "int", "1": "string", 1.0: "float64"}
	fmt.Println(len(anyKeys), anyKeys[1], anyKeys[1.0])

	defer func() { fmt.Println("recovered:", recover()) }()
	anyKeys[[]int{1}] = "slice"
}

map[{978-0-441-17271-9 1965}:13]
origin
map[Austen:[Emma Persuasion] Herbert:[Dune]]
3 true
3 int float64
recovered: runtime error: hash of unhashable type []int

package main

import (
	"fmt"
	"maps"
	"slices"
)

func main() {
	m := map[string]int{"c": 3, "a": 1, "b": 2, "d": 4}

	// Order is unspecified and differs from run to run; make output deterministic by sorting keys.
	keys := slices.Sorted(maps.Keys(m))
	for _, k := range keys {
		fmt.Print(k, "=", m[k], " ")
	}
	fmt.Println()

	// Deleting during range is safe: entries not yet reached are not produced.
	for k := range m {
		delete(m, k)
	}
	fmt.Println(len(m))

	// The sum is the same regardless of order.
	n := map[int]int{1: 10, 2: 20, 3: 30}
	total := 0
	for _, v := range n {
		total += v
	}
	fmt.Println(total)

	// Updating existing keys while ranging is fine.
	for k := range n {
		n[k] *= 2
	}
	fmt.Println(n)
}

a=1 b=2 c=3 d=4
0
60
map[1:20 2:40 3:60]

package main

import (
	"fmt"
	"maps"
	"slices"
	"strings"
)

type Book struct {
	Title  string
	Author string
}

func main() {
	books := []Book{
		{"Emma", "Austen"}, {"Dune", "Herbert"}, {"Persuasion", "Austen"},
		{"Children of Dune", "Herbert"}, {"Ulysses", "Joyce"},
	}

	byAuthor := make(map[string][]Book)
	for _, b := range books {
		byAuthor[b.Author] = append(byAuthor[b.Author], b)
	}
	for _, author := range slices.Sorted(maps.Keys(byAuthor)) {
		titles := make([]string, 0, len(byAuthor[author]))
		for _, b := range byAuthor[author] {
			titles = append(titles, b.Title)
		}
		fmt.Printf("%-8s %s\n", author, strings.Join(titles, ", "))
	}

	// Count words with the zero value
	counts := map[string]int{}
	for _, w := range strings.Fields("a rose is a rose is a rose") {
		counts[w]++
	}
	fmt.Println(counts)

	// Set operations
	a := map[string]struct{}{"x": {}, "y": {}}
	b := map[string]struct{}{"y": {}, "z": {}}
	union := maps.Clone(a)
	maps.Copy(union, b)
	inter := map[string]struct{}{}
	for k := range a {
		if _, ok := b[k]; ok {
			inter[k] = struct{}{}
		}
	}
	fmt.Println(slices.Sorted(maps.Keys(union)), slices.Sorted(maps.Keys(inter)))
}

Austen   Emma, Persuasion
Herbert  Dune, Children of Dune
Joyce    Ulysses
map[a:3 is:2 rose:3]
[x y z] [y]

package main

import (
	"fmt"
	"maps"
	"slices"
	"strings"
)

func main() {
	a := map[string]int{"x": 1, "y": 2}

	b := maps.Clone(a) // shallow copy; Clone(nil) stays nil
	b["z"] = 3
	fmt.Println(a, b)

	maps.Copy(a, b) // copies all pairs of b into a, overwriting
	fmt.Println(a, maps.Equal(a, b))

	fmt.Println(maps.EqualFunc(a, map[string]string{"x": "1", "y": "2", "z": "3"},
		func(v int, s string) bool { return fmt.Sprint(v) == s }))

	maps.DeleteFunc(a, func(k string, v int) bool { return v%2 == 1 })
	fmt.Println(a)

	// iterators (Go 1.23): Keys, Values, All, Insert, Collect
	m := map[string]int{"b": 2, "a": 1, "c": 3}
	fmt.Println(slices.Sorted(maps.Keys(m)))
	fmt.Println(slices.Sorted(maps.Values(m)))
	for _, k := range slices.Sorted(maps.Keys(m)) {
		fmt.Print(k, ":", m[k], " ")
	}
	fmt.Println()

	copyOf := maps.Collect(maps.All(m))
	maps.Insert(copyOf, maps.All(map[string]int{"d": 4}))
	fmt.Println(len(copyOf), maps.Equal(m, copyOf))

	// build a map from a sequence of pairs
	upper := maps.Collect(slices.All(strings.Fields("zero one two")))
	fmt.Println(upper)
}

map[x:1 y:2] map[x:1 y:2 z:3]
map[x:1 y:2 z:3] true
true
map[y:2]
[a b c]
[1 2 3]
a:1 b:2 c:3
4 false
map[0:zero 1:one 2:two]

package main

import "fmt"

func main() {
	m := map[int]int{}
	done := make(chan bool)
	for g := 0; g < 4; g++ {
		go func() {
			for i := 0; i < 100000; i++ {
				m[i] = i
			}
			done <- true
		}()
	}
	for g := 0; g < 4; g++ {
		<-done
	}
	fmt.Println(len(m))
}

fatal error: concurrent map writes
...

package main

import (
	"fmt"
	"sort"
	"sync"
)

// Stock is a map guarded by a mutex: the usual way to share a map.
type Stock struct {
	mu    sync.RWMutex
	count map[string]int
}

func (s *Stock) Add(title string) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.count[title]++
}

func (s *Stock) Count(title string) int {
	s.mu.RLock()
	defer s.mu.RUnlock()
	return s.count[title]
}

func main() {
	st := &Stock{count: map[string]int{}}
	var wg sync.WaitGroup
	for range 50 {
		wg.Go(func() {
			for range 100 {
				st.Add("Dune")
			}
		})
	}
	wg.Wait()
	fmt.Println(st.Count("Dune"))

	var sm sync.Map // for write-once, read-many keys or disjoint key sets
	sm.Store("Emma", 1)
	v, loaded := sm.LoadOrStore("Emma", 2)
	fmt.Println(v, loaded)
	sm.Store("Dune", 3)
	var keys []string
	sm.Range(func(k, _ any) bool {
		keys = append(keys, k.(string))
		return true
	})
	sort.Strings(keys)
	fmt.Println(keys)
}

5000
1 true
[Dune Emma]