From 37128199947d8b38d28b49fcd6afdc7eec659e78 Mon Sep 17 00:00:00 2001
From: dudaodong <dudaodong@gmail.com>
Date: Mon, 2 Jan 2023 14:06:12 +0800
Subject: [PATCH] test: add exmaple for maputil package

---
 maputil/map.go              |  24 +++--
 maputil/map_example_test.go | 181 ++++++++++++++++++++++++++++++++++++
 2 files changed, 197 insertions(+), 8 deletions(-)
 create mode 100644 maputil/map_example_test.go

diff --git a/maputil/map.go b/maputil/map.go
index bf63196..f4d157c 100644
--- a/maputil/map.go
+++ b/maputil/map.go
@@ -6,7 +6,8 @@ package maputil
 
 import "reflect"
 
-// Keys returns a slice of the map's keys
+// Keys returns a slice of the map's keys.
+// Play: https://go.dev/play/p/xNB5bTb97Wd
 func Keys[K comparable, V any](m map[K]V) []K {
 	keys := make([]K, len(m))
 
@@ -19,7 +20,8 @@ func Keys[K comparable, V any](m map[K]V) []K {
 	return keys
 }
 
-// Values returns a slice of the map's values
+// Values returns a slice of the map's values.
+// Play: https://go.dev/play/p/CBKdUc5FTW6
 func Values[K comparable, V any](m map[K]V) []V {
 	values := make([]V, len(m))
 
@@ -32,7 +34,8 @@ func Values[K comparable, V any](m map[K]V) []V {
 	return values
 }
 
-// Merge maps, next key will overwrite previous key
+// Merge maps, next key will overwrite previous key.
+// Play: https://go.dev/play/p/H95LENF1uB-
 func Merge[K comparable, V any](maps ...map[K]V) map[K]V {
 	result := make(map[K]V, 0)
 
@@ -45,14 +48,16 @@ func Merge[K comparable, V any](maps ...map[K]V) map[K]V {
 	return result
 }
 
-// ForEach executes iteratee funcation for every key and value pair in map
+// ForEach executes iteratee funcation for every key and value pair in map.
+// Play: https://go.dev/play/p/OaThj6iNVXK
 func ForEach[K comparable, V any](m map[K]V, iteratee func(key K, value V)) {
 	for k, v := range m {
 		iteratee(k, v)
 	}
 }
 
-// Filter iterates over map, return a new map contains all key and value pairs pass the predicate function
+// Filter iterates over map, return a new map contains all key and value pairs pass the predicate function.
+// Play: https://go.dev/play/p/fSvF3wxuNG7
 func Filter[K comparable, V any](m map[K]V, predicate func(key K, value V) bool) map[K]V {
 	result := make(map[K]V)
 
@@ -64,7 +69,8 @@ func Filter[K comparable, V any](m map[K]V, predicate func(key K, value V) bool)
 	return result
 }
 
-// Intersect iterates over maps, return a new map of key and value pairs in all given maps
+// Intersect iterates over maps, return a new map of key and value pairs in all given maps.
+// Play: https://go.dev/play/p/Zld0oj3sjcC
 func Intersect[K comparable, V any](maps ...map[K]V) map[K]V {
 	if len(maps) == 0 {
 		return map[K]V{}
@@ -97,7 +103,8 @@ func Intersect[K comparable, V any](maps ...map[K]V) map[K]V {
 	return result
 }
 
-// Minus creates an map of whose key in mapA but not in mapB
+// Minus creates an map of whose key in mapA but not in mapB.
+// Play: https://go.dev/play/p/3u5U9K7YZ9m
 func Minus[K comparable, V any](mapA, mapB map[K]V) map[K]V {
 	result := make(map[K]V)
 
@@ -109,7 +116,8 @@ func Minus[K comparable, V any](mapA, mapB map[K]V) map[K]V {
 	return result
 }
 
-// IsDisjoint two map are disjoint if they have no keys in common
+// IsDisjoint two map are disjoint if they have no keys in common.
+// Play: https://go.dev/play/p/N9qgYg_Ho6f
 func IsDisjoint[K comparable, V any](mapA, mapB map[K]V) bool {
 	for k := range mapA {
 		if _, ok := mapB[k]; ok {
diff --git a/maputil/map_example_test.go b/maputil/map_example_test.go
new file mode 100644
index 0000000..c54e5f1
--- /dev/null
+++ b/maputil/map_example_test.go
@@ -0,0 +1,181 @@
+package maputil
+
+import (
+	"fmt"
+	"sort"
+)
+
+func ExampleKeys() {
+	m := map[int]string{
+		1: "a",
+		2: "a",
+		3: "b",
+		4: "c",
+		5: "d",
+	}
+
+	keys := Keys(m)
+	sort.Ints(keys)
+
+	fmt.Println(keys)
+
+	// Output:
+	// [1 2 3 4 5]
+}
+
+func ExampleValues() {
+	m := map[int]string{
+		1: "a",
+		2: "a",
+		3: "b",
+		4: "c",
+		5: "d",
+	}
+
+	values := Values(m)
+	sort.Strings(values)
+
+	fmt.Println(values)
+
+	// Output:
+	// [a a b c d]
+}
+
+func ExampleMerge() {
+	m1 := map[int]string{
+		1: "a",
+		2: "b",
+	}
+	m2 := map[int]string{
+		1: "c",
+		3: "d",
+	}
+
+	result := Merge(m1, m2)
+
+	fmt.Println(result)
+
+	// Output:
+	// map[1:c 2:b 3:d]
+}
+
+func ExampleForEach() {
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+	}
+
+	var sum int
+	ForEach(m, func(_ string, value int) {
+		sum += value
+	})
+
+	fmt.Println(sum)
+
+	// Output:
+	// 10
+}
+
+func ExampleFilter() {
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+		"e": 5,
+	}
+
+	isEven := func(_ string, value int) bool {
+		return value%2 == 0
+	}
+
+	result := Filter(m, isEven)
+
+	fmt.Println(result)
+
+	// Output:
+	// map[b:2 d:4]
+}
+
+func ExampleIntersect() {
+	m1 := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+	}
+
+	m2 := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 6,
+		"d": 7,
+	}
+
+	m3 := map[string]int{
+		"a": 1,
+		"b": 9,
+		"e": 9,
+	}
+
+	result1 := Intersect(m1)
+	result2 := Intersect(m1, m2)
+	result3 := Intersect(m1, m2, m3)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// map[a:1 b:2 c:3]
+	// map[a:1 b:2]
+	// map[a:1]
+}
+
+func ExampleMinus() {
+	m1 := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+	}
+
+	m2 := map[string]int{
+		"a": 11,
+		"b": 22,
+		"d": 33,
+	}
+
+	result := Minus(m1, m2)
+
+	fmt.Println(result)
+
+	// Output:
+	// map[c:3]
+}
+
+func ExampleIsDisjoint() {
+	m1 := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+	}
+
+	m2 := map[string]int{
+		"d": 22,
+	}
+
+	m3 := map[string]int{
+		"a": 22,
+	}
+
+	result1 := IsDisjoint(m1, m2)
+	result2 := IsDisjoint(m1, m3)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+
+	// Output:
+	// true
+	// false
+}