Documentation
¶
Overview ¶
Package maps contains functions related to maps such as deep copying and equality testing.
Index ¶
- func CopyMap(m map[string]any) map[string]any
- func Difference[K comparable, V any](m map[K]V, n map[K]V)
- func DifferenceNew[K comparable, V any](m map[K]V, n map[K]V) map[K]V
- func Filter[K comparable, V any](m map[K]V, fun func(i int, key K, val V) bool)
- func FilterNew[K comparable, V any](m map[K]V, fun func(i int, key K, val V) bool) map[K]V
- func JsonMapEqualTest(t *testing.T, actual, expected any, forString string)
- func Keys[K comparable, V any](m map[K]V) []K
- func OrderedKeys[K constraints.Ordered, V any](m map[K]V) []K
- func RangeKeys[K comparable, V any](m map[K]V, fun MapRangeFunc[K, V])
- func RangeOrderedKeys[K constraints.Ordered, V any](m map[K]V, fun MapRangeFunc[K, V])
- func Union[K comparable, V any](dst map[K]V, src map[K]V)
- func UnionNew[K comparable, V any](m map[K]V, n map[K]V) map[K]V
- func Values[K comparable, V any](m map[K]V) []V
- type MapRangeFunc
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func CopyMap ¶
CopyMap clones a map deeply using recursion.
Example ¶
Deep copying a map using recursion via CopyMap.
CopyMap was designed for use with deserialised JSONs hence the map[string]any signature.
original := map[string]any{
"hello": "world",
"age": 20,
"bald": false,
"friends": []any{
"Bob",
"Jane",
"John",
"Mark",
map[string]any{
"name": "Gregor",
"age": 31,
"friends": []any{
"Bill",
"Bob",
"Sarah",
},
},
},
}
// Clone the above map.
clone := CopyMap(original)
fmt.Println("Original:", original)
fmt.Println("Clone:", clone)
Output: Original: map[age:20 bald:false friends:[Bob Jane John Mark map[age:31 friends:[Bill Bob Sarah] name:Gregor]] hello:world] Clone: map[age:20 bald:false friends:[Bob Jane John Mark map[age:31 friends:[Bill Bob Sarah] name:Gregor]] hello:world]
func Difference ¶ added in v2.3.5
func Difference[K comparable, V any](m map[K]V, n map[K]V)
Difference removes every key-value pair in m that also exists in n.
Example ¶
Find the difference of two maps, storing the difference in the first map.
m := map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
n := map[string]int{
"a": 4,
"b": 5,
"d": 6,
}
Difference(m, n)
fmt.Println(m)
Output: map[c:3]
func DifferenceNew ¶ added in v2.4.0
func DifferenceNew[K comparable, V any](m map[K]V, n map[K]V) map[K]V
DifferenceNew works similarly to Difference expect it returns a new map.
Example ¶
Find the difference of two maps, storing the difference in a new map.
m := map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
n := map[string]int{
"a": 4,
"b": 5,
"d": 6,
}
fmt.Println(DifferenceNew(m, n))
Output: map[c:3]
func Filter ¶ added in v2.3.5
func Filter[K comparable, V any](m map[K]V, fun func(i int, key K, val V) bool)
Filter takes a map and runs the given predicate function on each index-key-value triple. If the predicate returns false for an element, then that element will be removed from the given map.
Example ¶
Filter out all key-value pairs for a map of strings to integers whose values are <= 2.
m := map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
Filter(m, func(i int, key string, val int) bool {
return val > 2
})
fmt.Println(m)
Output: map[c:3]
func FilterNew ¶ added in v2.4.0
func FilterNew[K comparable, V any](m map[K]V, fun func(i int, key K, val V) bool) map[K]V
FilterNew works similarly to Filter except it returns a new map.
Example ¶
Filter out all key-value pairs for a map of strings to integers whose values are <= 2.
Notice how we print the returned map.
m := map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
fmt.Println(FilterNew(m, func(i int, key string, val int) bool {
return val > 2
}))
Output: map[c:3]
func JsonMapEqualTest ¶
JsonMapEqualTest used in tests to check equality between two anys.
This takes into account orderings of slices.
func Keys ¶ added in v2.3.0
func Keys[K comparable, V any](m map[K]V) []K
Keys returns the keys within a given map.
Example ¶
Retrieve the keys from a map.
m := map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
for _, key := range Keys(m) {
fmt.Println(key)
}
Output: a b c
func OrderedKeys ¶ added in v2.3.0
func OrderedKeys[K constraints.Ordered, V any](m map[K]V) []K
OrderedKeys returns the ordered keys for a given map.
Example ¶
Retrieve the keys from the map in order.
m := map[string]int{
"c": 3,
"b": 2,
"a": 1,
}
fmt.Println(OrderedKeys(m))
Output: [a b c]
func RangeKeys ¶ added in v2.3.0
func RangeKeys[K comparable, V any](m map[K]V, fun MapRangeFunc[K, V])
RangeKeys calls the given MapRangeFunc on each index-key-value triple. Triples are unordered.
Example ¶
Range over a map and display the index, key, and value of the current key-value pair.
m := map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
RangeKeys(m, func(i int, key string, val int) bool {
fmt.Printf("%s-%d\n", key, val)
return true
})
Output: a-1 b-2 c-3
func RangeOrderedKeys ¶ added in v2.3.0
func RangeOrderedKeys[K constraints.Ordered, V any](m map[K]V, fun MapRangeFunc[K, V])
RangeOrderedKeys calls the given MapRangeFunc on each index-key-value triple. Triples are ordered by their keys.
Example ¶
Range over a map, in key order, and display the index, key, and value of the current key-value pair.
m := map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
RangeOrderedKeys(m, func(i int, key string, val int) bool {
fmt.Printf("%d-%s-%d\n", i, key, val)
return true
})
Output: 0-a-1 1-b-2 2-c-3
func Union ¶ added in v2.3.5
func Union[K comparable, V any](dst map[K]V, src map[K]V)
Union takes merges the source map into the destination map, overriding any matching keys.
Example ¶
Union two maps together, storing the result in the first map.
m := map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
n := map[string]int{
"c": 4,
"d": 5,
"e": 6,
}
Union(m, n)
fmt.Println(m)
Output: map[a:1 b:2 c:4 d:5 e:6]
func UnionNew ¶ added in v2.4.0
func UnionNew[K comparable, V any](m map[K]V, n map[K]V) map[K]V
UnionNew works similarly to Union expect it returns a new map.
Example ¶
Union two maps together, storing the result in a new map.
m := map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
n := map[string]int{
"c": 4,
"d": 5,
"e": 6,
}
fmt.Println(UnionNew(m, n))
Output: map[a:1 b:2 c:4 d:5 e:6]
func Values ¶ added in v2.3.0
func Values[K comparable, V any](m map[K]V) []V
Values returns the values within a given map.
Example ¶
Retrieve the values from a map.
m := map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
for _, value := range Values(m) {
fmt.Println(value)
}
Output: 1 2 3
Types ¶
type MapRangeFunc ¶ added in v2.3.0
type MapRangeFunc[K comparable, V any] func(i int, key K, val V) bool
MapRangeFunc is the signature passed to RangeKeys, and RangeOrderedKeys. It is passed the key-value pair, and should return whether you want to keep iterating over the map.
Source Files