package maps

Import Path
	maps (on go.dev)

Dependency Relation
	imports 2 packages, and imported by one package

Involved Source Files

	    iter.go
	  d maps.go
		Package maps defines various functions useful with maps of any type.
Code Examples

	Clone
		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])
		
		}

	Copy
		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)
		
		}

	DeleteFunc
		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)
		}

	Equal
		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))
		}

	EqualFunc
		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-Level Functions (total 10)

	 func All[Map, K, V](m Map) iter.Seq2[K, V]

		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.

	 func Clone[M, K, V](m M) M

		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.

	 func Collect[K, V](seq iter.Seq2[K, V]) map[K]V

		Type Parameters:
			K: comparable
			V: any

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

	 func Copy[M1, M2, K, V](dst M1, src M2)

		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.

	 func DeleteFunc[M, K, V](m M, del func(K, V) bool)

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

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

	 func Equal[M1, M2, K, V](m1 M1, m2 M2) bool

		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 ==.

	 func EqualFunc[M1, M2, K, V1, V2](m1 M1, m2 M2, eq func(V1, V2) bool) bool

		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 ==.

	 func Insert[Map, K, V](m Map, seq iter.Seq2[K, V])

		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.

	 func Keys[Map, K, V](m Map) iter.Seq[K]

		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.

	 func Values[Map, K, V](m Map) iter.Seq[V]

		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.

The pages are generated with Golds v0.7.0-preview. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.