package main
import (
"cmp"
"fmt"
"slices"
"strconv"
"strings"
)
func All() {
println("~~~ All start")
defer println("~~~ All end\n")
slice := []string{"a", "e", "c"}
for index, value := range slices.All(slice) {
println(index, ",", value)
}
}
func AppendSeq() {
println("~~~ AppendSeq start")
defer println("~~~ AppendSeq end\n")
slice := []string{"a", "e", "c"}
for index, value := range slices.AppendSeq(slice, slices.Values([]string{"b", "d"})) {
println(index, ",", value)
}
}
func Backward() {
println("~~~ Backward start")
defer println("~~~ Backward end\n")
slice := []string{"a", "e", "c"}
for index, value := range slices.Backward(slice) {
println(index, ",", value)
}
}
func BinarySearch() {
println("~~~ BinarySearch start")
defer println("~~~ BinarySearch end\n")
slice := []string{"a", "e", "c"}
slices.Sort(slice)
fmt.Println(slice)
println(slices.BinarySearch(slice, "a"))
println(slices.BinarySearch(slice, "e"))
println(slices.BinarySearch(slice, "c"))
println(slices.BinarySearch(slice, "b"))
println(slices.BinarySearch(slice, "d"))
}
func BinarySearchFunc() {
println("~~~ BinarySearchFunc start")
defer println("~~~ BinarySearchFunc end\n")
type T struct {
i int
s string
}
slice := []T{
{1, "a"},
{2, "b"},
}
cmp := func(t1, t2 T) int {
return strings.Compare(t1.s, t2.s)
}
println(slices.BinarySearchFunc(slice, T{i: 100, s: "a"}, cmp))
println(slices.BinarySearchFunc(slice, T{i: 100, s: "b"}, cmp))
println(slices.BinarySearchFunc(slice, T{i: 100, s: "c"}, cmp))
}
func Chunk() {
println("~~~ Chunk start")
defer println("~~~ Chunk end\n")
for seq := range slices.Chunk([]int{1, 2, 3, 4, 5}, 2) {
fmt.Println(seq)
}
}
func Clip() {
println("~~~ Clip start")
defer println("~~~ Clip end\n")
slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}[:5:9]
fmt.Println(slice, ",", cap(slice))
clip := slices.Clip(slice)
fmt.Println(clip, ",", cap(clip))
}
func Clone() {
println("~~~ Clone start")
defer println("~~~ Clone end\n")
value := 1
slice := []*int{&value}
clone := slices.Clone(slice)
fmt.Println(*slice[0], ",", *clone[0])
*slice[0] = 10
fmt.Println(*slice[0], ",", *clone[0])
}
func Collect() {
println("~~~ Collect start")
defer println("~~~ Collect end\n")
seq := slices.Values([]int{1, 2, 3, 4, 5})
fmt.Printf("%T\n", seq)
slice := slices.Collect(seq)
fmt.Printf("%T\n", slice)
fmt.Println(slice)
}
func Compact() {
println("~~~ Compact start")
defer println("~~~ Compact end\n")
slice := []int{1, 2, 1, 3, 5, 4, 5}
fmt.Println(slice)
fmt.Println(slices.Compact(slice))
println()
slices.Sort(slice)
fmt.Println(slice)
fmt.Println(slices.Compact(slice))
}
func CompactFunc() {
println("~~~ CompactFunc start")
defer println("~~~ CompactFunc end\n")
slice := []string{"a", "A", "b", "B", "c", "C"}
fmt.Println(slices.Compact(slice))
fmt.Println(slices.CompactFunc(slice, strings.EqualFold))
}
func Compare() {
println("~~~ Compare start")
defer println("~~~ Compare end\n")
slice := []int{1, 2, 3}
println(slices.Compare(slice, []int{1, 2, 3}))
println(slices.Compare(slice, []int{1, 2}))
println(slices.Compare(slice, []int{1, 2, 3, 4}))
}
func CompareFunc() {
println("~~~ CompareFunc start")
defer println("~~~ CompareFunc end\n")
slice1 := []int{1, 2, 3}
slice2 := []string{"1", "2", "3"}
cmp := func(i int, s string) int {
return cmp.Compare(strconv.Itoa(i), s)
}
println(slices.CompareFunc(slice1, slice2, cmp))
}
func Concat() {
println("~~~ Concat start")
defer println("~~~ Concat end\n")
fmt.Println(slices.Concat([]int{1, 2, 3}, []int{4, 5, 6}))
}
func Contains() {
println("~~~ Contains start")
defer println("~~~ Contains end\n")
slice := []int{1, 2, 3}
println(slices.Contains(slice, 2))
println(slices.Contains(slice, 5))
}
func ContainsFunc() {
println("~~~ ContainsFunc start")
defer println("~~~ ContainsFunc end\n")
println(slices.ContainsFunc([]int{1, 2, 3}, func(i int) bool { return i%2 == 0 }))
}
func Delete() {
println("~~~ Delete start")
defer println("~~~ Delete end\n")
fmt.Println(slices.Delete([]int{1, 2, 3, 4, 5, 6, 7, 8, 9}, 1, 8))
}
func DeleteFunc() {
println("~~~ DeleteFunc start")
defer println("~~~ DeleteFunc end\n")
fmt.Println(slices.DeleteFunc([]int{1, 2, 3, 4, 5}, func(i int) bool { return i%2 == 0 }))
}
func Equal() {
println("~~~ Equal start")
defer println("~~~ Equal end\n")
slice := []int{1, 2, 3}
println(slices.Equal(slice, []int{1, 2, 3}))
println(slices.Equal(slice, []int{1, 2}))
}
func EqualFunc() {
println("~~~ EqualFunc start")
defer println("~~~ EqualFunc end\n")
eq := func(i int, s string) bool {
return strconv.Itoa(i) == s
}
println(slices.EqualFunc([]int{1, 2, 3}, []string{"1", "2", "3"}, eq))
}
func Grow() {
println("~~~ Grow start")
defer println("~~~ Grow end\n")
slice := []int{1, 2, 3}
fmt.Println(cap(slice))
grow := slices.Grow(slice, 3)
fmt.Println(cap(grow))
}
func Index() {
println("~~~ Index start")
defer println("~~~ Index end\n")
slice := []string{"a", "b", "c"}
println(slices.Index(slice, "a"))
println(slices.Index(slice, "b"))
println(slices.Index(slice, "c"))
println(slices.Index(slice, "e"))
}
func IndexFunc() {
println("~~~ IndexFunc start")
defer println("~~~ IndexFunc end\n")
println(slices.IndexFunc([]int{1, 2, 3}, func(i int) bool { return i > 2 }))
}
func Insert() {
println("~~~ Insert start")
defer println("~~~ Insert end\n")
slice := []string{"a", "d"}
fmt.Println(slices.Insert(slice, 1, "b", "c"))
fmt.Println(slices.Insert(slice, len(slice), "e"))
}
func IsSorted() {
println("~~~ IsSorted start")
defer println("~~~ IsSorted end\n")
println(slices.IsSorted([]int{1, 2, 3}))
println(slices.IsSorted([]int{1, 3, 2}))
println(slices.IsSorted([]string{"a", "b", "c"}))
println(slices.IsSorted([]string{"a", "c", "b"}))
}
func IsSortedFunc() {
println("~~~ IsSortedFunc start")
defer println("~~~ IsSortedFunc end\n")
slice := []string{"a", "B", "c"}
println(slices.IsSorted(slice))
cmp := func(s1, s2 string) int {
return strings.Compare(strings.ToLower(s1), strings.ToLower(s2))
}
println(slices.IsSortedFunc(slice, cmp))
}
func Max() {
println("~~~ Max start")
defer println("~~~ Max end\n")
println(slices.Max([]int{1, 2, 10, 3}))
}
func MaxFunc() {
println("~~~ MaxFunc start")
defer println("~~~ MaxFunc end\n")
slice := []int{1, 2, 3}
cmp := func(i1, i2 int) int {
return cmp.Compare(i1*-1, i2*-1)
}
println(slices.MaxFunc(slice, cmp))
}
func Min() {
println("~~~ Min start")
defer println("~~~ Min end\n")
println(slices.Min([]int{1, 2, 10, 3}))
}
func MinFunc() {
println("~~~ MinFunc start")
defer println("~~~ MinFunc end\n")
slice := []int{1, 2, 3}
cmp := func(i1, i2 int) int {
return cmp.Compare(i1*-1, i2*-1)
}
println(slices.MinFunc(slice, cmp))
}
func Repeat() {
println("~~~ Repeat start")
defer println("~~~ Repeat end\n")
fmt.Println(slices.Repeat([]int{1, 2, 3}, 3))
}
func Replace() {
println("~~~ Replace start")
defer println("~~~ Replace end\n")
slice := []string{"a", "y", "z", "e"}
fmt.Println(slices.Replace(slice, 1, 3, "b"))
fmt.Println(slices.Replace(slice, 1, 3, "b", "c", "d"))
}
func Reverse() {
println("~~~ Reverse start")
defer println("~~~ Reverse end\n")
slice := []int{1, 2, 3}
slices.Reverse(slice)
fmt.Println(slice)
}
func Sort() {
println("~~~ Sort start")
defer println("~~~ Sort end\n")
slice := []int{1, 3, 2}
slices.Sort(slice)
fmt.Println(slice)
}
func SortFunc() {
println("~~~ SortFunc start")
defer println("~~~ SortFunc end\n")
slice := []int{1, 3, 2}
cmp := func(i1, i2 int) int {
return cmp.Compare(i2, i1)
}
slices.SortFunc(slice, cmp)
fmt.Println(slice)
}
func SortStableFunc() {
println("~~~ SortStableFunc start")
defer println("~~~ SortStableFunc end\n")
type T struct {
i int
s string
}
slice := []T{
{1, "a"},
{2, "b"},
{1, "c"},
}
cmp := func(t1, t2 T) int {
return cmp.Compare(t1.i, t2.i)
//return strings.Compare(t1.s, t2.s)
}
slices.SortStableFunc(slice, cmp)
fmt.Println(slice)
}
func Sorted() {
println("~~~ Sorted start")
defer println("~~~ Sorted end\n")
seq := slices.Values([]string{"c", "a", "b"})
fmt.Println(slices.Sorted(seq))
}
func SortedFunc() {
println("~~~ SortedFunc start")
defer println("~~~ SortedFunc end\n")
seq := slices.Values([]string{"c", "a", "b"})
cmp := func(s1, s2 string) int {
return strings.Compare(s2, s1)
}
fmt.Println(slices.SortedFunc(seq, cmp))
}
func SortedStableFunc() {
println("~~~ SortedStableFunc start")
defer println("~~~ SortedStableFunc end\n")
seq := slices.Values([]string{"c", "a", "b"})
cmp := func(s1, s2 string) int {
return strings.Compare(s2, s1)
}
fmt.Println(slices.SortedFunc(seq, cmp))
}
func Values() {
println("~~~ Values start")
defer println("~~~ Values end\n")
for value := range slices.Values([]string{"c", "a", "b"}) {
println(value)
}
}
func main() {
All()
AppendSeq()
Backward()
BinarySearch()
BinarySearchFunc()
Chunk()
Clip()
Clone()
Collect()
Compact()
CompactFunc()
Compare()
CompareFunc()
Concat()
Contains()
ContainsFunc()
Delete()
DeleteFunc()
Equal()
EqualFunc()
Grow()
Index()
IndexFunc()
Insert()
IsSorted()
IsSortedFunc()
Max()
MaxFunc()
Min()
MinFunc()
Repeat()
Replace()
Reverse()
Sort()
SortFunc()
SortStableFunc()
Sorted()
SortedFunc()
SortedStableFunc()
Values()
}
