Merge pull request #380 from ardanlabs/cheikh/slices

Cheikh/slices

Author: ardan-bkennedy

topics/go/packages/slices/example1/example1.go

@@ -0,0 +1,45 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Sample program shows how to use the BinarySearch APIs from the
+// slices package.
+package main
+
+import (
+	"fmt"
+
+	"golang.org/x/exp/slices"
+)
+
+// BinarySearch searches for target in a sorted slice and returns the
+// position where target is found, or the position where target would
+// appear in the sort order.
+
+func main() {
+	list := []int{1, 2, 3, 4, 5, 6}
+	fmt.Println("Slice", list)
+
+	// -------------------------------------------------------------------------
+	// BinarySearch
+
+	index, found := slices.BinarySearch(list, 9)
+	fmt.Printf("Looking for 9, idx[%d], found[%v]\n", index, found)
+
+	index, found = slices.BinarySearch(list, 5)
+	fmt.Printf("Looking for 5, idx[%d], found[%v]\n", index, found)
+
+	// -------------------------------------------------------------------------
+	// BinarySearchFunc
+
+	index, found = slices.BinarySearchFunc(list, 7, compare)
+	fmt.Printf("Looking for 7, idx[%d], found[%v]\n", index, found)
+
+	index, found = slices.BinarySearchFunc(list, 2, compare)
+	fmt.Printf("Looking for 2, idx[%d], found[%v]\n", index, found)
+}
+
+// Compare needs to return 0 if the two values are the same, a positive
+// number of a > b, and a negative number of a < b.
+func compare(a int, b int) int {
+	return a - b
+}

topics/go/packages/slices/example10/example10.go

@@ -0,0 +1,38 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Sample program shows how to use the Index API from the slices package.
+package main
+
+import (
+	"fmt"
+
+	"golang.org/x/exp/slices"
+)
+
+// Index returns the index of the first occurrence or -1 if not present.
+
+func main() {
+	list := []int{1, 1, 2, 2, 1, 1, 3, 3, 4, 5}
+	fmt.Println("Slice", list)
+
+	// -------------------------------------------------------------------------
+	// Index
+
+	fmt.Printf("Looking for 5, idx[%d]\n", slices.Index(list, 5))
+	fmt.Printf("Looking for 0, idx[%d]\n", slices.Index(list, 0))
+	fmt.Printf("Looking for 2, idx[%d]\n", slices.Index(list, 2))
+
+	// -------------------------------------------------------------------------
+	// IndexFunc
+
+	fmt.Printf("Looking for 5, idx[%d]\n", slices.IndexFunc(list, compare(5)))
+	fmt.Printf("Looking for 0, idx[%d]\n", slices.IndexFunc(list, compare(0)))
+	fmt.Printf("Looking for 2, idx[%d]\n", slices.IndexFunc(list, compare(2)))
+}
+
+func compare(a int) func(int) bool {
+	return func(b int) bool {
+		return a == b
+	}
+}

topics/go/packages/slices/example11/example11.go

@@ -0,0 +1,31 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Sample program shows how to use the Insert API from the slices package.
+package main
+
+import (
+	"fmt"
+
+	"golang.org/x/exp/slices"
+)
+
+// Insert adds values into the slices at the specified index and
+// returns the modified slice.
+
+func main() {
+	list := []int{1, 2, 3, 4, 5, 6}
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+
+	// -------------------------------------------------------------------------
+	// Insert - add 7, 8, 9 to the end of the list
+
+	list = slices.Insert(list, 6, 7, 8, 9)
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+
+	// -------------------------------------------------------------------------
+	// Insert - add 0 to the beginning of the list
+
+	list = slices.Insert(list, 0, 0)
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+}

topics/go/packages/slices/example12/example12.go

@@ -0,0 +1,57 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Sample program shows how to use the Sort APIs from the slices package.
+package main
+
+import (
+	"fmt"
+
+	"golang.org/x/exp/slices"
+)
+
+// Sort sorts a slice of any ordered type in ascending order.
+// IsSorted reports whether x is sorted in ascending order.
+
+func main() {
+
+	// -------------------------------------------------------------------------
+	// Sort
+
+	list := []int{1, 4, 5, 2, 8, 3, 6, 9, 7}
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+
+	slices.Sort(list)
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+
+	is := slices.IsSorted(list)
+	fmt.Println("Is list sorted:", is)
+
+	// -------------------------------------------------------------------------
+	// SortFunc
+
+	list = []int{1, 4, 5, 2, 8, 3, 6, 9, 7}
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+
+	slices.SortFunc(list, compare)
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+
+	is = slices.IsSortedFunc(list, compare)
+	fmt.Println("Is list sorted:", is)
+
+	// -------------------------------------------------------------------------
+	// SortStableFunc
+
+	list = []int{1, 4, 5, 2, 8, 3, 6, 9, 7}
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+
+	slices.SortStableFunc(list, compare)
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+
+	is = slices.IsSortedFunc(list, compare)
+	fmt.Println("Is list sorted:", is)
+}
+
+func compare(a, b int) bool {
+	return a < b
+}

topics/go/packages/slices/example13/example13.go

@@ -0,0 +1,31 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Sample program shows how to use the Replace API from the slices package.
+package main
+
+import (
+	"fmt"
+
+	"golang.org/x/exp/slices"
+)
+
+// Replace replaces the elements specified for a given range and returns
+// the modified slice.
+
+func main() {
+	list := []int{1, 2, 3, 4, 5, 6}
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+
+	// -------------------------------------------------------------------------
+	// Replace - Change 3 to 7
+
+	list = slices.Replace(list, 2, 3, 7)
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+
+	// -------------------------------------------------------------------------
+	// Replace - Change 4, 5, 6 to 8, 9
+
+	list = slices.Replace(list, 3, 6, 8, 9)
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+}

topics/go/packages/slices/example2/example2.go

@@ -0,0 +1,30 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Sample program shows how to use the Clip API from the slices package.
+package main
+
+import (
+	"fmt"
+
+	"golang.org/x/exp/slices"
+)
+
+// Clip removes the unused capacity from the slice.
+
+func main() {
+	list := make([]string, 0, 10)
+	fmt.Printf("Len(%d), Cap(%d)\n", len(list), cap(list))
+
+	// -------------------------------------------------------------------------
+	// Append a string to the slice
+
+	list = append(list, "A")
+	fmt.Printf("Len(%d), Cap(%d)\n", len(list), cap(list))
+
+	// -------------------------------------------------------------------------
+	// Clip
+
+	list = slices.Clip(list)
+	fmt.Printf("Len(%d), Cap(%d)\n", len(list), cap(list))
+}

topics/go/packages/slices/example3/example3.go

@@ -0,0 +1,25 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Sample program shows how to use the Clone API from the slices package.
+package main
+
+import (
+	"fmt"
+
+	"golang.org/x/exp/slices"
+)
+
+// Clone creates a new slice value and underlying array with a shallow
+// copy of the elements.
+
+func main() {
+	list := []int{1, 2, 3, 4, 5, 6}
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+
+	// -------------------------------------------------------------------------
+	// Clone
+
+	list = slices.Clone(list)
+	fmt.Printf("Copy: Addr(%x), %v\n", &list[0], list)
+}

topics/go/packages/slices/example4/example4.go

@@ -0,0 +1,40 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Sample program shows how to use the Compact APIs from the slices package.
+package main
+
+import (
+	"fmt"
+
+	"golang.org/x/exp/slices"
+)
+
+// Compact replaces consecutive runs of equal elements with a single copy.
+// Compact modifies the contents of the slice and does not create a new slice.
+
+func main() {
+
+	// -------------------------------------------------------------------------
+	// Compact
+
+	list := []int{1, 1, 2, 2, 1, 1, 3, 3, 4, 5}
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+
+	list = slices.Compact(list)
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+
+	// -------------------------------------------------------------------------
+	// CompactFunc
+
+	list = []int{1, 1, 2, 2, 1, 1, 3, 3, 4, 5}
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+
+	list = slices.CompactFunc(list, compare)
+	fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
+}
+
+// compare needs to return true if the two values are the same.
+func compare(a int, b int) bool {
+	return a == b
+}

topics/go/packages/slices/example5/example5.go

@@ -0,0 +1,73 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Sample program shows how to use the Compare API from the slices package.
+package main
+
+import (
+	"fmt"
+
+	"golang.org/x/exp/slices"
+)
+
+// result translates the result of the compare API.
+var result = map[int]string{
+	-1: "First slice is shorter",
+	0:  "Both slices are equal",
+	1:  "Second slice is shorter",
+}
+
+// Compare compares the elements between two slices. The elements are compared
+// sequentially, starting at index 0, until one element is not equal to the
+// other. The result of comparing the first non-matching elements is returned.
+
+func main() {
+	list1 := []int{1, 2, 3, 4, 5}
+	list2 := []int{1, 2, 6, 4, 5, 6}
+	list3 := []int{1, 2, 3, 4}
+	list4 := []int{1, 2, 3, 4}
+
+	fmt.Println("Slice1", list1)
+	fmt.Println("Slice2", list2)
+	fmt.Println("Slice3", list3)
+	fmt.Println("Slice4", list4)
+
+	// -------------------------------------------------------------------------
+	// Compare list1 and list2
+
+	fmt.Printf("list1 vs list2: Compare(%s), Func(%s)\n",
+		result[slices.Compare(list1, list2)],
+		result[slices.CompareFunc(list1, list2, compare)],
+	)
+
+	// -------------------------------------------------------------------------
+	// Compare list1 and list3
+
+	fmt.Printf("list1 vs list3: Compare(%s), Func(%s)\n",
+		result[slices.Compare(list1, list3)],
+		result[slices.CompareFunc(list1, list3, compare)],
+	)
+
+	// -------------------------------------------------------------------------
+	// Compare list3 and list4
+
+	fmt.Printf("list3 vs list4: Compare(%s), Func(%s)\n",
+		result[slices.Compare(list3, list4)],
+		result[slices.CompareFunc(list3, list4, compare)],
+	)
+}
+
+// compare evaluates values in increasing index order, and the comparisons stop
+// after the first time the function returns non-zero. Return 0 is the two
+// values match, return -1 if a < b, and 1 if a > b.
+func compare(a int, b int) int {
+	if a < b {
+		return -1
+	}
+
+	if a > b {
+		return 1
+	}
+
+	return 0
+}