# maps

package standard library
master (071b8d5) Latest Latest

Go to latest
Published: Jul 12, 2024 License: BSD-3-Clause

## Documentation ¶

### Overview ¶

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

### Constants ¶

This section is empty.

### Variables ¶

This section is empty.

### Functions ¶

#### func All ¶

func All[Map ~map[K]V, K comparable, V any](m Map) iter.Seq2[K, V]

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 ¶

func Clone[M ~map[K]V, K comparable, V any](m M) M

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

Example
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])

}
Output:

1
100
1
100
100

#### func Collect ¶

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

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

#### func Copy ¶

func Copy[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2)

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.

Example
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)

}
Output:

m2 is: map[one:1 two:2]
m1 is: map[one:1 two:2]
m2 is: map[one:100 two:2]
m4 is: map[one:[1 2 3] two:[4 5 6]]
m3 is: map[one:[100 2 3] two:[4 5 6]]
m4 is: map[one:[100 2 3] two:[4 5 6]]

#### func DeleteFunc ¶

func DeleteFunc[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool)

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

Example
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)
}
Output:

map[four:4 two:2]

#### func Equal ¶

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

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

Example
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))
}
Output:

true
false

#### func EqualFunc ¶

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

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

Example
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)
}
Output:

true

#### func Insert ¶

func Insert[Map ~map[K]V, K comparable, V any](m Map, seq iter.Seq2[K, V])

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 ¶

func Keys[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[K]

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 ¶

func Values[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[V]

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.

### Types ¶

This section is empty.