maps.go

Documentation: golang.org/x/exp/maps

     1  // Copyright 2021 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Package maps defines various functions useful with maps of any type.
     6  package maps
     7  
     8  // Keys returns the keys of the map m.
     9  // The keys will be in an indeterminate order.
    10  func Keys[M ~map[K]V, K comparable, V any](m M) []K {
    11  	r := make([]K, 0, len(m))
    12  	for k := range m {
    13  		r = append(r, k)
    14  	}
    15  	return r
    16  }
    17  
    18  // Values returns the values of the map m.
    19  // The values will be in an indeterminate order.
    20  func Values[M ~map[K]V, K comparable, V any](m M) []V {
    21  	r := make([]V, 0, len(m))
    22  	for _, v := range m {
    23  		r = append(r, v)
    24  	}
    25  	return r
    26  }
    27  
    28  // Equal reports whether two maps contain the same key/value pairs.
    29  // Values are compared using ==.
    30  func Equal[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool {
    31  	if len(m1) != len(m2) {
    32  		return false
    33  	}
    34  	for k, v1 := range m1 {
    35  		if v2, ok := m2[k]; !ok || v1 != v2 {
    36  			return false
    37  		}
    38  	}
    39  	return true
    40  }
    41  
    42  // EqualFunc is like Equal, but compares values using eq.
    43  // Keys are still compared with ==.
    44  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 {
    45  	if len(m1) != len(m2) {
    46  		return false
    47  	}
    48  	for k, v1 := range m1 {
    49  		if v2, ok := m2[k]; !ok || !eq(v1, v2) {
    50  			return false
    51  		}
    52  	}
    53  	return true
    54  }
    55  
    56  // Clear removes all entries from m, leaving it empty.
    57  func Clear[M ~map[K]V, K comparable, V any](m M) {
    58  	for k := range m {
    59  		delete(m, k)
    60  	}
    61  }
    62  
    63  // Clone returns a copy of m.  This is a shallow clone:
    64  // the new keys and values are set using ordinary assignment.
    65  func Clone[M ~map[K]V, K comparable, V any](m M) M {
    66  	// Preserve nil in case it matters.
    67  	if m == nil {
    68  		return nil
    69  	}
    70  	r := make(M, len(m))
    71  	for k, v := range m {
    72  		r[k] = v
    73  	}
    74  	return r
    75  }
    76  
    77  // Copy copies all key/value pairs in src adding them to dst.
    78  // When a key in src is already present in dst,
    79  // the value in dst will be overwritten by the value associated
    80  // with the key in src.
    81  func Copy[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2) {
    82  	for k, v := range src {
    83  		dst[k] = v
    84  	}
    85  }
    86  
    87  // DeleteFunc deletes any key/value pairs from m for which del returns true.
    88  func DeleteFunc[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool) {
    89  	for k, v := range m {
    90  		if del(k, v) {
    91  			delete(m, k)
    92  		}
    93  	}
    94  }
    95
View as plain text