package maps

Import Path
	maps (on go.dev)

Dependency Relation
	imports 2 packages, and imported by 10 packages


Involved Source Files

	    iter.go
	
		Package maps defines various functions useful with maps of any type.
		
		This package does not have any special handling for non-reflexive keys
		(keys k where k != k), such as floating-point NaNs.


Code Examples

	
		package main
		
		import (
			"fmt"
			"maps"
		)
		
		func main() {
			m1 := map[string]int{
				"one": 1,
				"two": 2,
			}
			m2 := map[string]int{
				"one": 10,
			}
			maps.Insert(m2, maps.All(m1))
			fmt.Println("m2 is:", m2)
		}

	
		package main
		
		import (
			"fmt"
			"maps"
		)
		
		func main() {
			m1 := map[string]int{
				"key": 1,
			}
			m2 := maps.Clone(m1)
			m2["key"] = 100
			fmt.Println(m1["key"])
			fmt.Println(m2["key"])
		
			m3 := map[string][]int{
				"key": {1, 2, 3},
			}
			m4 := maps.Clone(m3)
			fmt.Println(m4["key"][0])
			m4["key"][0] = 100
			fmt.Println(m3["key"][0])
			fmt.Println(m4["key"][0])
		
		}

	
		package main
		
		import (
			"fmt"
			"maps"
			"slices"
		)
		
		func main() {
			s1 := []string{"zero", "one", "two", "three"}
			m1 := maps.Collect(slices.All(s1))
			fmt.Println("m1 is:", m1)
		}

	
		package main
		
		import (
			"fmt"
			"maps"
		)
		
		func main() {
			m1 := map[string]int{
				"one": 1,
				"two": 2,
			}
			m2 := map[string]int{
				"one": 10,
			}
		
			maps.Copy(m2, m1)
			fmt.Println("m2 is:", m2)
		
			m2["one"] = 100
			fmt.Println("m1 is:", m1)
			fmt.Println("m2 is:", m2)
		
			m3 := map[string][]int{
				"one": {1, 2, 3},
				"two": {4, 5, 6},
			}
			m4 := map[string][]int{
				"one": {7, 8, 9},
			}
		
			maps.Copy(m4, m3)
			fmt.Println("m4 is:", m4)
		
			m4["one"][0] = 100
			fmt.Println("m3 is:", m3)
			fmt.Println("m4 is:", m4)
		
		}

	
		package main
		
		import (
			"fmt"
			"maps"
		)
		
		func main() {
			m := map[string]int{
				"one":   1,
				"two":   2,
				"three": 3,
				"four":  4,
			}
			maps.DeleteFunc(m, func(k string, v int) bool {
				return v%2 != 0 // delete odd values
			})
			fmt.Println(m)
		}

	
		package main
		
		import (
			"fmt"
			"maps"
		)
		
		func main() {
			m1 := map[int]string{
				1:    "one",
				10:   "Ten",
				1000: "THOUSAND",
			}
			m2 := map[int]string{
				1:    "one",
				10:   "Ten",
				1000: "THOUSAND",
			}
			m3 := map[int]string{
				1:    "one",
				10:   "ten",
				1000: "thousand",
			}
		
			fmt.Println(maps.Equal(m1, m2))
			fmt.Println(maps.Equal(m1, m3))
		}

	
		package main
		
		import (
			"fmt"
			"maps"
			"strings"
		)
		
		func main() {
			m1 := map[int]string{
				1:    "one",
				10:   "Ten",
				1000: "THOUSAND",
			}
			m2 := map[int][]byte{
				1:    []byte("One"),
				10:   []byte("Ten"),
				1000: []byte("Thousand"),
			}
			eq := maps.EqualFunc(m1, m2, func(v1 string, v2 []byte) bool {
				return strings.ToLower(v1) == strings.ToLower(string(v2))
			})
			fmt.Println(eq)
		}

	
		package main
		
		import (
			"fmt"
			"maps"
			"slices"
		)
		
		func main() {
			m1 := map[int]string{
				1000: "THOUSAND",
			}
			s1 := []string{"zero", "one", "two", "three"}
			maps.Insert(m1, slices.All(s1))
			fmt.Println("m1 is:", m1)
		}

	
		package main
		
		import (
			"fmt"
			"maps"
			"slices"
		)
		
		func main() {
			m1 := map[int]string{
				1:    "one",
				10:   "Ten",
				1000: "THOUSAND",
			}
			keys := slices.Sorted(maps.Keys(m1))
			fmt.Println(keys)
		}

	
		package main
		
		import (
			"fmt"
			"maps"
			"slices"
		)
		
		func main() {
			m1 := map[int]string{
				1:    "one",
				10:   "Ten",
				1000: "THOUSAND",
			}
			values := slices.Sorted(maps.Values(m1))
			fmt.Println(values)
		}




Package-Level Functions (total 11, in which 10 are exported)


	

		Type Parameters:
			Map: ~map[K]V
			K: comparable
			V: any

		All returns an iterator over key-value pairs from m.
		The iteration order is not specified and is not guaranteed
		to be the same from one call to the next.


	

		Type Parameters:
			M: ~map[K]V
			K: comparable
			V: any

		Clone returns a copy of m.  This is a shallow clone:
		the new keys and values are set using ordinary assignment.


	

		Type Parameters:
			K: comparable
			V: any

		Collect collects key-value pairs from seq into a new map
		and returns it.


	

		Type Parameters:
			M1: ~map[K]V
			M2: ~map[K]V
			K: comparable
			V: any

		Copy copies all key/value pairs in src adding them to dst.
		When a key in src is already present in dst,
		the value in dst will be overwritten by the value associated
		with the key in src.


	

		Type Parameters:
			M: ~map[K]V
			K: comparable
			V: any

		DeleteFunc deletes any key/value pairs from m for which del returns true.


	

		Type Parameters:
			M1: ~map[K]V
			M2: ~map[K]V
			K: comparable
			V: comparable

		Equal reports whether two maps contain the same key/value pairs.
		Values are compared using ==.


	

		Type Parameters:
			M1: ~map[K]V1
			M2: ~map[K]V2
			K: comparable
			V1: any
			V2: any

		EqualFunc is like Equal, but compares values using eq.
		Keys are still compared with ==.


	

		Type Parameters:
			Map: ~map[K]V
			K: comparable
			V: any

		Insert adds the key-value pairs from seq to m.
		If a key in seq already exists in m, its value will be overwritten.


	

		Type Parameters:
			Map: ~map[K]V
			K: comparable
			V: any

		Keys returns an iterator over keys in m.
		The iteration order is not specified and is not guaranteed
		to be the same from one call to the next.


	

		Type Parameters:
			Map: ~map[K]V
			K: comparable
			V: any

		Values returns an iterator over values in m.
		The iteration order is not specified and is not guaranteed
		to be the same from one call to the next.