maps.go

     1  // run
     2  
     3  // Copyright 2021 The Go Authors. All rights reserved.
     4  // Use of this source code is governed by a BSD-style
     5  // license that can be found in the LICENSE file.
     6  
     7  package main
     8  
     9  import (
    10  	"fmt"
    11  	"math"
    12  	"sort"
    13  )
    14  
    15  // _Equal reports whether two slices are equal: the same length and all
    16  // elements equal. All floating point NaNs are considered equal.
    17  func _SliceEqual[Elem comparable](s1, s2 []Elem) bool {
    18  	if len(s1) != len(s2) {
    19  		return false
    20  	}
    21  	for i, v1 := range s1 {
    22  		v2 := s2[i]
    23  		if v1 != v2 {
    24  			isNaN := func(f Elem) bool { return f != f }
    25  			if !isNaN(v1) || !isNaN(v2) {
    26  				return false
    27  			}
    28  		}
    29  	}
    30  	return true
    31  }
    32  
    33  // _Keys returns the keys of the map m.
    34  // The keys will be an indeterminate order.
    35  func _Keys[K comparable, V any](m map[K]V) []K {
    36  	r := make([]K, 0, len(m))
    37  	for k := range m {
    38  		r = append(r, k)
    39  	}
    40  	return r
    41  }
    42  
    43  // _Values returns the values of the map m.
    44  // The values will be in an indeterminate order.
    45  func _Values[K comparable, V any](m map[K]V) []V {
    46  	r := make([]V, 0, len(m))
    47  	for _, v := range m {
    48  		r = append(r, v)
    49  	}
    50  	return r
    51  }
    52  
    53  // _Equal reports whether two maps contain the same key/value pairs.
    54  // _Values are compared using ==.
    55  func _Equal[K, V comparable](m1, m2 map[K]V) bool {
    56  	if len(m1) != len(m2) {
    57  		return false
    58  	}
    59  	for k, v1 := range m1 {
    60  		if v2, ok := m2[k]; !ok || v1 != v2 {
    61  			return false
    62  		}
    63  	}
    64  	return true
    65  }
    66  
    67  // _Copy returns a copy of m.
    68  func _Copy[K comparable, V any](m map[K]V) map[K]V {
    69  	r := make(map[K]V, len(m))
    70  	for k, v := range m {
    71  		r[k] = v
    72  	}
    73  	return r
    74  }
    75  
    76  // _Add adds all key/value pairs in m2 to m1. _Keys in m2 that are already
    77  // present in m1 will be overwritten with the value in m2.
    78  func _Add[K comparable, V any](m1, m2 map[K]V) {
    79  	for k, v := range m2 {
    80  		m1[k] = v
    81  	}
    82  }
    83  
    84  // _Sub removes all keys in m2 from m1. _Keys in m2 that are not present
    85  // in m1 are ignored. The values in m2 are ignored.
    86  func _Sub[K comparable, V any](m1, m2 map[K]V) {
    87  	for k := range m2 {
    88  		delete(m1, k)
    89  	}
    90  }
    91  
    92  // _Intersect removes all keys from m1 that are not present in m2.
    93  // _Keys in m2 that are not in m1 are ignored. The values in m2 are ignored.
    94  func _Intersect[K comparable, V any](m1, m2 map[K]V) {
    95  	for k := range m1 {
    96  		if _, ok := m2[k]; !ok {
    97  			delete(m1, k)
    98  		}
    99  	}
   100  }
   101  
   102  // _Filter deletes any key/value pairs from m for which f returns false.
   103  func _Filter[K comparable, V any](m map[K]V, f func(K, V) bool) {
   104  	for k, v := range m {
   105  		if !f(k, v) {
   106  			delete(m, k)
   107  		}
   108  	}
   109  }
   110  
   111  // _TransformValues applies f to each value in m. The keys remain unchanged.
   112  func _TransformValues[K comparable, V any](m map[K]V, f func(V) V) {
   113  	for k, v := range m {
   114  		m[k] = f(v)
   115  	}
   116  }
   117  
   118  var m1 = map[int]int{1: 2, 2: 4, 4: 8, 8: 16}
   119  var m2 = map[int]string{1: "2", 2: "4", 4: "8", 8: "16"}
   120  
   121  func TestKeys() {
   122  	want := []int{1, 2, 4, 8}
   123  
   124  	got1 := _Keys(m1)
   125  	sort.Ints(got1)
   126  	if !_SliceEqual(got1, want) {
   127  		panic(fmt.Sprintf("_Keys(%v) = %v, want %v", m1, got1, want))
   128  	}
   129  
   130  	got2 := _Keys(m2)
   131  	sort.Ints(got2)
   132  	if !_SliceEqual(got2, want) {
   133  		panic(fmt.Sprintf("_Keys(%v) = %v, want %v", m2, got2, want))
   134  	}
   135  }
   136  
   137  func TestValues() {
   138  	got1 := _Values(m1)
   139  	want1 := []int{2, 4, 8, 16}
   140  	sort.Ints(got1)
   141  	if !_SliceEqual(got1, want1) {
   142  		panic(fmt.Sprintf("_Values(%v) = %v, want %v", m1, got1, want1))
   143  	}
   144  
   145  	got2 := _Values(m2)
   146  	want2 := []string{"16", "2", "4", "8"}
   147  	sort.Strings(got2)
   148  	if !_SliceEqual(got2, want2) {
   149  		panic(fmt.Sprintf("_Values(%v) = %v, want %v", m2, got2, want2))
   150  	}
   151  }
   152  
   153  func TestEqual() {
   154  	if !_Equal(m1, m1) {
   155  		panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", m1, m1))
   156  	}
   157  	if _Equal(m1, nil) {
   158  		panic(fmt.Sprintf("_Equal(%v, nil) = true, want false", m1))
   159  	}
   160  	if _Equal(nil, m1) {
   161  		panic(fmt.Sprintf("_Equal(nil, %v) = true, want false", m1))
   162  	}
   163  	if !_Equal[int, int](nil, nil) {
   164  		panic("_Equal(nil, nil) = false, want true")
   165  	}
   166  	if ms := map[int]int{1: 2}; _Equal(m1, ms) {
   167  		panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", m1, ms))
   168  	}
   169  
   170  	// Comparing NaN for equality is expected to fail.
   171  	mf := map[int]float64{1: 0, 2: math.NaN()}
   172  	if _Equal(mf, mf) {
   173  		panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", mf, mf))
   174  	}
   175  }
   176  
   177  func TestCopy() {
   178  	m2 := _Copy(m1)
   179  	if !_Equal(m1, m2) {
   180  		panic(fmt.Sprintf("_Copy(%v) = %v, want %v", m1, m2, m1))
   181  	}
   182  	m2[16] = 32
   183  	if _Equal(m1, m2) {
   184  		panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", m1, m2))
   185  	}
   186  }
   187  
   188  func TestAdd() {
   189  	mc := _Copy(m1)
   190  	_Add(mc, mc)
   191  	if !_Equal(mc, m1) {
   192  		panic(fmt.Sprintf("_Add(%v, %v) = %v, want %v", m1, m1, mc, m1))
   193  	}
   194  	_Add(mc, map[int]int{16: 32})
   195  	want := map[int]int{1: 2, 2: 4, 4: 8, 8: 16, 16: 32}
   196  	if !_Equal(mc, want) {
   197  		panic(fmt.Sprintf("_Add result = %v, want %v", mc, want))
   198  	}
   199  }
   200  
   201  func TestSub() {
   202  	mc := _Copy(m1)
   203  	_Sub(mc, mc)
   204  	if len(mc) > 0 {
   205  		panic(fmt.Sprintf("_Sub(%v, %v) = %v, want empty map", m1, m1, mc))
   206  	}
   207  	mc = _Copy(m1)
   208  	_Sub(mc, map[int]int{1: 0})
   209  	want := map[int]int{2: 4, 4: 8, 8: 16}
   210  	if !_Equal(mc, want) {
   211  		panic(fmt.Sprintf("_Sub result = %v, want %v", mc, want))
   212  	}
   213  }
   214  
   215  func TestIntersect() {
   216  	mc := _Copy(m1)
   217  	_Intersect(mc, mc)
   218  	if !_Equal(mc, m1) {
   219  		panic(fmt.Sprintf("_Intersect(%v, %v) = %v, want %v", m1, m1, mc, m1))
   220  	}
   221  	_Intersect(mc, map[int]int{1: 0, 2: 0})
   222  	want := map[int]int{1: 2, 2: 4}
   223  	if !_Equal(mc, want) {
   224  		panic(fmt.Sprintf("_Intersect result = %v, want %v", mc, want))
   225  	}
   226  }
   227  
   228  func TestFilter() {
   229  	mc := _Copy(m1)
   230  	_Filter(mc, func(int, int) bool { return true })
   231  	if !_Equal(mc, m1) {
   232  		panic(fmt.Sprintf("_Filter(%v, true) = %v, want %v", m1, mc, m1))
   233  	}
   234  	_Filter(mc, func(k, v int) bool { return k < 3 })
   235  	want := map[int]int{1: 2, 2: 4}
   236  	if !_Equal(mc, want) {
   237  		panic(fmt.Sprintf("_Filter result = %v, want %v", mc, want))
   238  	}
   239  }
   240  
   241  func TestTransformValues() {
   242  	mc := _Copy(m1)
   243  	_TransformValues(mc, func(i int) int { return i / 2 })
   244  	want := map[int]int{1: 1, 2: 2, 4: 4, 8: 8}
   245  	if !_Equal(mc, want) {
   246  		panic(fmt.Sprintf("_TransformValues result = %v, want %v", mc, want))
   247  	}
   248  }
   249  
   250  func main() {
   251  	TestKeys()
   252  	TestValues()
   253  	TestEqual()
   254  	TestCopy()
   255  	TestAdd()
   256  	TestSub()
   257  	TestIntersect()
   258  	TestFilter()
   259  	TestTransformValues()
   260  }
   261
View as plain text