package maps

Import Path
	maps (on go.dev)

Dependency Relation
	imports 0 packages, and imported by 0 packages

Involved Source Files

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

	    maps.s
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 5)

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

The pages are generated with Golds v0.6.9-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 @Go100and1 (reachable from the left QR code) to get the latest news of Golds.