Documentation
¶
Overview ¶
Package maps provides a set of generic functions for common operations on maps.
This package is a generated adapter that mirrors the public API of the standard Go experimental package `golang.org/x/exp/maps`. It offers a convenient way to access common utilities for cloning, extracting keys/values, and comparing maps.
For detailed information on the behavior of specific functions, please refer to the official Go documentation for the `golang.org/x/exp/maps` package.
Package maps implements the functions, types, and interfaces for the module.
Package maps contains generated code by adptool.
Index ¶
- func Clear[M ~map[K]V, K comparable, V any](m M)
- func Clone[M ~map[K]V, K comparable, V any](m M) M
- func Concat[M ~map[K]V, K comparable, V any](m M, ms ...M)
- func ConcatWith[M ~map[K]V, K comparable, V any](merge func(K, V, V) V, m M, ms ...M)
- func Copy[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2)
- func DeleteFunc[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool)
- func Equal[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool
- 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
- func Exclude[M ~map[K]V, K comparable, V any](m M, keys ...K)
- func Filter[M ~map[K]V, K comparable, V any](m M, f func(K, V) bool)
- func FromKVs[K comparable, V any](kvs ...KeyValue[K, V]) map[K]V
- func FromSlice[T any, K comparable, V any](ts []T, f func(T) (K, V)) map[K]V
- func FromSliceWithIndex[T any, K comparable, V any](ts []T, f func(int, T) (K, V)) map[K]V
- func Keys[M ~map[K]V, K comparable, V any](m M) []K
- func Merge[M ~map[K]V, K comparable, V any](dest M, src M, overlay bool)
- func MergeWith[M ~map[K]V, K comparable, V any](dest M, src M, cmp func(key K, src V, val V) V)
- func ToSlice[M ~map[K]V, K comparable, V any, T any](m M, f func(K, V) T) []T
- func ToSliceWith[M ~map[K]V, K comparable, V any, T any](m M, f func(K, V) (T, bool)) []T
- func ToStruct[M ~map[K]V, K comparable, V any, S any](m M, f func(*S, K, V) *S) *S
- func Transform[M ~map[K]V, K comparable, V any, TK comparable, TV any](m M, f func(K, V) (TK, TV, bool)) map[TK]TV
- func Values[M ~map[K]V, K comparable, V any](m M) []V
- type KeyValue
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Clear ¶
func Clear[M ~map[K]V, K comparable, V any](m M)
func Clone ¶
func Clone[M ~map[K]V, K comparable, V any](m M) M
func Concat ¶ added in v0.7.0
func Concat[M ~map[K]V, K comparable, V any](m M, ms ...M)
Concat merges multiple maps into a single map. If a key exists in multiple maps, the value from the last map will be used.
func ConcatWith ¶ added in v0.7.0
func ConcatWith[M ~map[K]V, K comparable, V any](merge func(K, V, V) V, m M, ms ...M)
ConcatWith merges multiple maps into a single map using a custom merge function. If a key exists in multiple maps, the merge function will be called to determine the final value.
func Copy ¶
func Copy[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2)
func DeleteFunc ¶
func DeleteFunc[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool)
func Equal ¶
func Equal[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool
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
func Exclude ¶ added in v0.7.0
func Exclude[M ~map[K]V, K comparable, V any](m M, keys ...K)
Exclude removes all key/value pairs from m for which f returns false.
func Filter ¶
func Filter[M ~map[K]V, K comparable, V any](m M, f func(K, V) bool)
Filter keeps only the key-value pairs in the map for which the provided function returns true.
func FromKVs ¶ added in v0.7.0
func FromKVs[K comparable, V any](kvs ...KeyValue[K, V]) map[K]V
FromKVs converts a slice of key-value pairs to a map.
func FromSlice ¶ added in v0.7.0
func FromSlice[T any, K comparable, V any](ts []T, f func(T) (K, V)) map[K]V
FromSlice converts a slice of types to a map.
func FromSliceWithIndex ¶ added in v0.8.0
func FromSliceWithIndex[T any, K comparable, V any](ts []T, f func(int, T) (K, V)) map[K]V
FromSliceWithIndex converts a slice of types to a map, using the provided function to extract the key and value.
func Keys ¶
func Keys[M ~map[K]V, K comparable, V any](m M) []K
func Merge ¶
func Merge[M ~map[K]V, K comparable, V any](dest M, src M, overlay bool)
Merge merges the values of src into dest. If overlay is true, existing values in dest will be overwritten.
func MergeWith ¶ added in v0.7.0
func MergeWith[M ~map[K]V, K comparable, V any](dest M, src M, cmp func(key K, src V, val V) V)
MergeWith merges the values of src into dest using the provided merge function. If a key exists in both maps, the merge function will be called to determine the final value.
func ToSlice ¶ added in v0.7.0
func ToSlice[M ~map[K]V, K comparable, V any, T any](m M, f func(K, V) T) []T
ToSlice converts a map to a slice of types.
func ToSliceWith ¶ added in v0.8.0
func ToSliceWith[M ~map[K]V, K comparable, V any, T any](m M, f func(K, V) (T, bool)) []T
ToSliceWith converts a map to a slice of types, filtering out values that return false.
func ToStruct ¶ added in v0.7.0
func ToStruct[M ~map[K]V, K comparable, V any, S any](m M, f func(*S, K, V) *S) *S
ToStruct converts a map to a struct.
func Transform ¶ added in v0.1.5
func Transform[M ~map[K]V, K comparable, V any, TK comparable, TV any](m M, f func(K, V) (TK, TV, bool)) map[TK]TV
Transform remaps the keys and values of a map using a custom transformation function. The transformation function is called for each key-value pair in the original map. If the transformation function returns false as its third return value, the key-value pair is skipped. Otherwise, the transformed key-value pair is added to the new map.
func Values ¶
func Values[M ~map[K]V, K comparable, V any](m M) []V
Types ¶
type KeyValue ¶
type KeyValue[K comparable, V any] struct { Key K Val V }
KeyValue is a key-value pair.
func KV ¶ added in v0.10.0
func KV[K comparable, V any](key K, value V) KeyValue[K, V]
KV creates a new KeyValue pair with type inference. This is a convenience function that allows type inference when creating a KeyValue. Example:
kv := KV("a", 1) // returns KeyValue[string, int]{Key: "a", Val: 1}
func KVs ¶ added in v0.10.0
func KVs[K comparable, V any](kvs ...KeyValue[K, V]) []KeyValue[K, V]
KVs creates a slice of KeyValue pairs from the given key-value pairs. This is a convenience function that allows creating slices of KeyValue with type inference. Example:
kvs := KVs( KV(1, "one"), KV(2, "two"), ) // returns []KeyValue[int, string]
func ToKVs ¶ added in v0.7.0
func ToKVs[M ~map[K]V, K comparable, V any](m M) []KeyValue[K, V]
ToKVs converts a map to a slice of key-value pairs.
Source Files