mirror of
https://github.com/samber/lo.git
synced 2025-12-24 12:48:02 +08:00
704 lines
16 KiB
Go
704 lines
16 KiB
Go
//go:build go1.23
|
|
|
|
package it
|
|
|
|
import (
|
|
"fmt"
|
|
"iter"
|
|
"math"
|
|
"slices"
|
|
"strconv"
|
|
)
|
|
|
|
func ExampleLength() {
|
|
list := slices.Values([]int64{1, 2, 3, 4})
|
|
|
|
result := Length(list)
|
|
|
|
fmt.Printf("%v", result)
|
|
// Output: 4
|
|
}
|
|
|
|
func ExampleDrain() {
|
|
list := slices.Values([]int64{1, 2, 3, 4})
|
|
|
|
Drain(list)
|
|
}
|
|
|
|
func ExampleFilter() {
|
|
list := slices.Values([]int64{1, 2, 3, 4})
|
|
|
|
result := Filter(list, func(nbr int64) bool {
|
|
return nbr%2 == 0
|
|
})
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [2 4]
|
|
}
|
|
|
|
func ExampleMap() {
|
|
list := slices.Values([]int64{1, 2, 3, 4})
|
|
|
|
result := Map(list, func(nbr int64) string {
|
|
return strconv.FormatInt(nbr*2, 10)
|
|
})
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [2 4 6 8]
|
|
}
|
|
|
|
func ExampleUniqMap() {
|
|
type User struct {
|
|
Name string
|
|
Age int
|
|
}
|
|
users := slices.Values([]User{{Name: "Alex", Age: 10}, {Name: "Alex", Age: 12}, {Name: "Bob", Age: 11}, {Name: "Alice", Age: 20}})
|
|
|
|
result := UniqMap(users, func(u User) string {
|
|
return u.Name
|
|
})
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [Alex Bob Alice]
|
|
}
|
|
|
|
func ExampleFilterMap() {
|
|
list := slices.Values([]int64{1, 2, 3, 4})
|
|
|
|
result := FilterMap(list, func(nbr int64) (string, bool) {
|
|
return strconv.FormatInt(nbr*2, 10), nbr%2 == 0
|
|
})
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [4 8]
|
|
}
|
|
|
|
func ExampleFlatMap() {
|
|
list := slices.Values([]int64{1, 2, 3, 4})
|
|
|
|
result := FlatMap(list, func(nbr int64) iter.Seq[string] {
|
|
return slices.Values([]string{
|
|
strconv.FormatInt(nbr, 10), // base 10
|
|
strconv.FormatInt(nbr, 2), // base 2
|
|
})
|
|
})
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [1 1 2 10 3 11 4 100]
|
|
}
|
|
|
|
func ExampleReduce() {
|
|
list := slices.Values([]int64{1, 2, 3, 4})
|
|
|
|
result := Reduce(list, func(agg, item int64) int64 {
|
|
return agg + item
|
|
}, 0)
|
|
|
|
fmt.Printf("%v", result)
|
|
// Output: 10
|
|
}
|
|
|
|
func ExampleReduceLast() {
|
|
list := slices.Values([][]int{{0, 1}, {2, 3}, {4, 5}})
|
|
|
|
result := ReduceLast(list, func(agg, item []int) []int {
|
|
return append(agg, item...)
|
|
}, []int{})
|
|
|
|
fmt.Printf("%v", result)
|
|
// Output: [4 5 2 3 0 1]
|
|
}
|
|
|
|
func ExampleForEach() {
|
|
list := slices.Values([]int64{1, 2, 3, 4})
|
|
|
|
ForEach(list, func(x int64) {
|
|
fmt.Println(x)
|
|
})
|
|
|
|
// Output:
|
|
// 1
|
|
// 2
|
|
// 3
|
|
// 4
|
|
}
|
|
|
|
func ExampleForEachWhile() {
|
|
list := slices.Values([]int64{1, 2, -math.MaxInt, 4})
|
|
|
|
ForEachWhile(list, func(x int64) bool {
|
|
if x < 0 {
|
|
return false
|
|
}
|
|
fmt.Println(x)
|
|
return true
|
|
})
|
|
|
|
// Output:
|
|
// 1
|
|
// 2
|
|
}
|
|
|
|
func ExampleTimes() {
|
|
result := Times(3, func(i int) string {
|
|
return strconv.FormatInt(int64(i), 10)
|
|
})
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [0 1 2]
|
|
}
|
|
|
|
func ExampleUniq() {
|
|
list := slices.Values([]int{1, 2, 2, 1})
|
|
|
|
result := Uniq(list)
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [1 2]
|
|
}
|
|
|
|
func ExampleUniqBy() {
|
|
list := slices.Values([]int{0, 1, 2, 3, 4, 5})
|
|
|
|
result := UniqBy(list, func(i int) int {
|
|
return i % 3
|
|
})
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [0 1 2]
|
|
}
|
|
|
|
func ExampleGroupBy() {
|
|
list := slices.Values([]int{0, 1, 2, 3, 4, 5})
|
|
|
|
result := GroupBy(list, func(i int) int {
|
|
return i % 3
|
|
})
|
|
|
|
fmt.Printf("%v\n", result[0])
|
|
fmt.Printf("%v\n", result[1])
|
|
fmt.Printf("%v\n", result[2])
|
|
// Output:
|
|
// [0 3]
|
|
// [1 4]
|
|
// [2 5]
|
|
}
|
|
|
|
func ExampleGroupByMap() {
|
|
list := slices.Values([]int{0, 1, 2, 3, 4, 5})
|
|
|
|
result := GroupByMap(list, func(i int) (int, int) {
|
|
return i % 3, i * 2
|
|
})
|
|
|
|
fmt.Printf("%v\n", result[0])
|
|
fmt.Printf("%v\n", result[1])
|
|
fmt.Printf("%v\n", result[2])
|
|
// Output:
|
|
// [0 6]
|
|
// [2 8]
|
|
// [4 10]
|
|
}
|
|
|
|
func ExampleChunk() {
|
|
list := slices.Values([]int{0, 1, 2, 3, 4})
|
|
|
|
result := Chunk(list, 2)
|
|
|
|
for r := range result {
|
|
fmt.Printf("%v\n", r)
|
|
}
|
|
// Output:
|
|
// [0 1]
|
|
// [2 3]
|
|
// [4]
|
|
}
|
|
|
|
func ExamplePartitionBy() {
|
|
list := slices.Values([]int{-2, -1, 0, 1, 2, 3, 4})
|
|
|
|
result := PartitionBy(list, func(x int) string {
|
|
if x < 0 {
|
|
return "negative"
|
|
} else if x%2 == 0 {
|
|
return "even"
|
|
}
|
|
return "odd"
|
|
})
|
|
|
|
for _, v := range result {
|
|
fmt.Printf("%v\n", v)
|
|
}
|
|
// Output:
|
|
// [-2 -1]
|
|
// [0 2 4]
|
|
// [1 3]
|
|
}
|
|
|
|
func ExampleFlatten() {
|
|
list := []iter.Seq[int]{slices.Values([]int{0, 1, 2}), slices.Values([]int{3, 4, 5})}
|
|
|
|
result := Flatten(list)
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [0 1 2 3 4 5]
|
|
}
|
|
|
|
func ExampleConcat() {
|
|
list1 := slices.Values([]int{0, 1, 2})
|
|
list2 := slices.Values([]int{3, 4, 5})
|
|
list3 := slices.Values([]int{6, 7, 8})
|
|
|
|
result := Concat(list1, list2, list3)
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [0 1 2 3 4 5 6 7 8]
|
|
}
|
|
|
|
func ExampleInterleave() {
|
|
list1 := []iter.Seq[int]{slices.Values([]int{1, 4, 7}), slices.Values([]int{2, 5, 8}), slices.Values([]int{3, 6, 9})}
|
|
list2 := []iter.Seq[int]{slices.Values([]int{1}), slices.Values([]int{2, 5, 8}), slices.Values([]int{3, 6}), slices.Values([]int{4, 7, 9, 10})}
|
|
|
|
result1 := slices.Collect(Interleave(list1...))
|
|
result2 := slices.Collect(Interleave(list2...))
|
|
|
|
fmt.Printf("%v\n", result1)
|
|
fmt.Printf("%v\n", result2)
|
|
// Output:
|
|
// [1 2 3 4 5 6 7 8 9]
|
|
// [1 2 3 4 5 6 7 8 9 10]
|
|
}
|
|
|
|
func ExampleShuffle() {
|
|
list := slices.Values([]int{0, 1, 2, 3, 4, 5})
|
|
|
|
result := slices.Collect(Shuffle(list))
|
|
|
|
fmt.Printf("%v", result)
|
|
}
|
|
|
|
func ExampleReverse() {
|
|
list := slices.Values([]int{0, 1, 2, 3, 4, 5})
|
|
|
|
result := slices.Collect(Reverse(list))
|
|
|
|
fmt.Printf("%v", result)
|
|
// Output: [5 4 3 2 1 0]
|
|
}
|
|
|
|
func ExampleFill() {
|
|
list := slices.Values([]foo{{"a"}, {"a"}})
|
|
|
|
result := Fill(list, foo{"b"})
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [{b} {b}]
|
|
}
|
|
|
|
func ExampleRepeat() {
|
|
result := Repeat(2, foo{"a"})
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [{a} {a}]
|
|
}
|
|
|
|
func ExampleRepeatBy() {
|
|
result := RepeatBy(5, func(i int) string {
|
|
return strconv.FormatInt(int64(math.Pow(float64(i), 2)), 10)
|
|
})
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [0 1 4 9 16]
|
|
}
|
|
|
|
func ExampleKeyBy() {
|
|
list := slices.Values([]string{"a", "aa", "aaa"})
|
|
|
|
result := KeyBy(list, func(str string) int {
|
|
return len(str)
|
|
})
|
|
|
|
fmt.Printf("%v", result)
|
|
// Output: map[1:a 2:aa 3:aaa]
|
|
}
|
|
|
|
func ExampleSeqToMap() {
|
|
list := slices.Values([]string{"a", "aa", "aaa"})
|
|
|
|
result := SeqToMap(list, func(str string) (string, int) {
|
|
return str, len(str)
|
|
})
|
|
|
|
fmt.Printf("%v", result)
|
|
// Output: map[a:1 aa:2 aaa:3]
|
|
}
|
|
|
|
func ExampleFilterSeqToMap() {
|
|
list := slices.Values([]string{"a", "aa", "aaa"})
|
|
|
|
result := FilterSeqToMap(list, func(str string) (string, int, bool) {
|
|
return str, len(str), len(str) > 1
|
|
})
|
|
|
|
fmt.Printf("%v", result)
|
|
// Output: map[aa:2 aaa:3]
|
|
}
|
|
|
|
func ExampleKeyify() {
|
|
list := slices.Values([]string{"a", "a", "b", "b", "d"})
|
|
|
|
set := Keyify(list)
|
|
_, ok1 := set["a"]
|
|
_, ok2 := set["c"]
|
|
fmt.Printf("%v\n", ok1)
|
|
fmt.Printf("%v\n", ok2)
|
|
fmt.Printf("%v\n", set)
|
|
|
|
// Output:
|
|
// true
|
|
// false
|
|
// map[a:{} b:{} d:{}]
|
|
}
|
|
|
|
func ExampleDrop() {
|
|
list := slices.Values([]int{0, 1, 2, 3, 4, 5})
|
|
|
|
result := Drop(list, 2)
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [2 3 4 5]
|
|
}
|
|
|
|
func ExampleDropWhile() {
|
|
list := slices.Values([]int{0, 1, 2, 3, 4, 5})
|
|
|
|
result := DropWhile(list, func(val int) bool {
|
|
return val < 2
|
|
})
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [2 3 4 5]
|
|
}
|
|
|
|
func ExampleDropByIndex() {
|
|
list := slices.Values([]int{0, 1, 2, 3, 4, 5})
|
|
|
|
result := DropByIndex(list, 2)
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [0 1 3 4 5]
|
|
}
|
|
|
|
func ExampleReject() {
|
|
list := slices.Values([]int{0, 1, 2, 3, 4, 5})
|
|
|
|
result := Reject(list, func(x int) bool {
|
|
return x%2 == 0
|
|
})
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [1 3 5]
|
|
}
|
|
|
|
func ExampleCount() {
|
|
list := slices.Values([]int{0, 1, 2, 3, 4, 5, 0, 1, 2, 3})
|
|
|
|
result := Count(list, 2)
|
|
|
|
fmt.Printf("%v", result)
|
|
// Output: 2
|
|
}
|
|
|
|
func ExampleCountBy() {
|
|
list := slices.Values([]int{0, 1, 2, 3, 4, 5, 0, 1, 2, 3})
|
|
|
|
result := CountBy(list, func(i int) bool {
|
|
return i < 4
|
|
})
|
|
|
|
fmt.Printf("%v", result)
|
|
// Output: 8
|
|
}
|
|
|
|
func ExampleCountValues() {
|
|
result1 := CountValues(slices.Values([]int{}))
|
|
result2 := CountValues(slices.Values([]int{1, 2}))
|
|
result3 := CountValues(slices.Values([]int{1, 2, 2}))
|
|
result4 := CountValues(slices.Values([]string{"foo", "bar", ""}))
|
|
result5 := CountValues(slices.Values([]string{"foo", "bar", "bar"}))
|
|
|
|
fmt.Printf("%v\n", result1)
|
|
fmt.Printf("%v\n", result2)
|
|
fmt.Printf("%v\n", result3)
|
|
fmt.Printf("%v\n", result4)
|
|
fmt.Printf("%v\n", result5)
|
|
// Output:
|
|
// map[]
|
|
// map[1:1 2:1]
|
|
// map[1:1 2:2]
|
|
// map[:1 bar:1 foo:1]
|
|
// map[bar:2 foo:1]
|
|
}
|
|
|
|
func ExampleCountValuesBy() {
|
|
isEven := func(v int) bool {
|
|
return v%2 == 0
|
|
}
|
|
|
|
result1 := CountValuesBy(slices.Values([]int{}), isEven)
|
|
result2 := CountValuesBy(slices.Values([]int{1, 2}), isEven)
|
|
result3 := CountValuesBy(slices.Values([]int{1, 2, 2}), isEven)
|
|
|
|
length := func(v string) int {
|
|
return len(v)
|
|
}
|
|
|
|
result4 := CountValuesBy(slices.Values([]string{"foo", "bar", ""}), length)
|
|
result5 := CountValuesBy(slices.Values([]string{"foo", "bar", "bar"}), length)
|
|
|
|
fmt.Printf("%v\n", result1)
|
|
fmt.Printf("%v\n", result2)
|
|
fmt.Printf("%v\n", result3)
|
|
fmt.Printf("%v\n", result4)
|
|
fmt.Printf("%v\n", result5)
|
|
// Output:
|
|
// map[]
|
|
// map[false:1 true:1]
|
|
// map[false:1 true:2]
|
|
// map[0:1 3:2]
|
|
// map[3:3]
|
|
}
|
|
|
|
func ExampleSubset() {
|
|
list := slices.Values([]int{0, 1, 2, 3, 4, 5})
|
|
|
|
result := Subset(list, 2, 3)
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
// Output: [2 3 4]
|
|
}
|
|
|
|
func ExampleSlice() {
|
|
list := values(0, 1, 2, 3, 4, 5)
|
|
|
|
result := Slice(list, 1, 4)
|
|
fmt.Printf("%v\n", slices.Collect(result))
|
|
|
|
result = Slice(list, 4, 1)
|
|
fmt.Printf("%v\n", slices.Collect(result))
|
|
|
|
result = Slice(list, 4, 5)
|
|
fmt.Printf("%v\n", slices.Collect(result))
|
|
|
|
// Output:
|
|
// [1 2 3]
|
|
// []
|
|
// [4]
|
|
}
|
|
|
|
func ExampleReplace() {
|
|
list := slices.Values([]int{0, 1, 0, 1, 2, 3, 0})
|
|
|
|
result := Replace(list, 0, 42, 1)
|
|
fmt.Printf("%v\n", slices.Collect(result))
|
|
|
|
result = Replace(list, -1, 42, 1)
|
|
fmt.Printf("%v\n", slices.Collect(result))
|
|
|
|
result = Replace(list, 0, 42, 2)
|
|
fmt.Printf("%v\n", slices.Collect(result))
|
|
|
|
result = Replace(list, 0, 42, -1)
|
|
fmt.Printf("%v\n", slices.Collect(result))
|
|
|
|
// Output:
|
|
// [42 1 0 1 2 3 0]
|
|
// [0 1 0 1 2 3 0]
|
|
// [42 1 42 1 2 3 0]
|
|
// [42 1 42 1 2 3 42]
|
|
}
|
|
|
|
func ExampleCompact() {
|
|
list := slices.Values([]string{"", "foo", "", "bar", ""})
|
|
|
|
result := Compact(list)
|
|
|
|
fmt.Printf("%v", slices.Collect(result))
|
|
|
|
// Output: [foo bar]
|
|
}
|
|
|
|
func ExampleIsSorted() {
|
|
list := slices.Values([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
|
|
|
|
result := IsSorted(list)
|
|
|
|
fmt.Printf("%v", result)
|
|
|
|
// Output: true
|
|
}
|
|
|
|
func ExampleIsSortedBy() {
|
|
list := slices.Values([]string{"a", "bb", "ccc"})
|
|
|
|
result := IsSortedBy(list, func(s string) int {
|
|
return len(s)
|
|
})
|
|
|
|
fmt.Printf("%v", result)
|
|
|
|
// Output: true
|
|
}
|
|
|
|
func ExampleCutPrefix() {
|
|
collection := slices.Values([]string{"a", "b", "c", "d", "e", "f", "g"})
|
|
|
|
// Test with valid prefix
|
|
after, found := CutPrefix(collection, []string{"a", "b", "c"})
|
|
fmt.Printf("After: %v, Found: %t\n", slices.Collect(after), found)
|
|
|
|
// Test with prefix not found
|
|
after2, found2 := CutPrefix(collection, []string{"b"})
|
|
fmt.Printf("After: %v, Found: %t\n", slices.Collect(after2), found2)
|
|
|
|
// Test with empty prefix
|
|
after3, found3 := CutPrefix(collection, []string{})
|
|
fmt.Printf("After: %v, Found: %t\n", slices.Collect(after3), found3)
|
|
|
|
// Output:
|
|
// After: [d e f g], Found: true
|
|
// After: [a b c d e f g], Found: false
|
|
// After: [a b c d e f g], Found: true
|
|
}
|
|
|
|
func ExampleCutSuffix() {
|
|
collection := slices.Values([]string{"a", "b", "c", "d", "e", "f", "g"})
|
|
|
|
// Test with valid suffix
|
|
before, found := CutSuffix(collection, []string{"f", "g"})
|
|
fmt.Printf("Before: %v, Found: %t\n", slices.Collect(before), found)
|
|
|
|
// Test with suffix not found
|
|
before2, found2 := CutSuffix(collection, []string{"b"})
|
|
fmt.Printf("Before: %v, Found: %t\n", slices.Collect(before2), found2)
|
|
|
|
// Test with empty suffix
|
|
before3, found3 := CutSuffix(collection, []string{})
|
|
fmt.Printf("Before: %v, Found: %t\n", slices.Collect(before3), found3)
|
|
|
|
// Output:
|
|
// Before: [a b c d e], Found: true
|
|
// Before: [a b c d e f g], Found: false
|
|
// Before: [a b c d e f g], Found: true
|
|
}
|
|
|
|
func ExampleTrim() {
|
|
collection := slices.Values([]int{0, 1, 2, 0, 3, 0})
|
|
|
|
// Test with valid cutset
|
|
result := Trim(collection, 0)
|
|
fmt.Printf("Trim with cutset {0}: %v\n", slices.Collect(result))
|
|
|
|
// Test with string collection
|
|
words := slices.Values([]string{" hello ", "world", " "})
|
|
result2 := Trim(words, " ")
|
|
fmt.Printf("Trim with string cutset: %v\n", slices.Collect(result2))
|
|
|
|
// Test with no cutset elements
|
|
result3 := Trim(collection, 5)
|
|
fmt.Printf("Trim with cutset {5} (not present): %v\n", slices.Collect(result3))
|
|
|
|
// Output:
|
|
// Trim with cutset {0}: [1 2 0 3]
|
|
// Trim with string cutset: [ hello world ]
|
|
// Trim with cutset {5} (not present): [0 1 2 0 3 0]
|
|
}
|
|
|
|
func ExampleTrimFirst() {
|
|
collection := slices.Values([]int{0, 1, 2, 0, 3, 0})
|
|
|
|
// Test with valid cutset
|
|
result := TrimFirst(collection, 0)
|
|
fmt.Printf("TrimFirst with cutset {0}: %v\n", slices.Collect(result))
|
|
|
|
// Test with string collection
|
|
words := slices.Values([]string{" hello ", "world", " "})
|
|
result2 := TrimFirst(words, " ")
|
|
fmt.Printf("TrimFirst with string cutset: %v\n", slices.Collect(result2))
|
|
|
|
// Test with no cutset elements
|
|
result3 := TrimFirst(collection, 5)
|
|
fmt.Printf("TrimFirst with cutset {5} (not present): %v\n", slices.Collect(result3))
|
|
|
|
// Output:
|
|
// TrimFirst with cutset {0}: [1 2 0 3 0]
|
|
// TrimFirst with string cutset: [ hello world ]
|
|
// TrimFirst with cutset {5} (not present): [0 1 2 0 3 0]
|
|
}
|
|
|
|
func ExampleTrimPrefix() {
|
|
collection := slices.Values([]int{1, 2, 1, 2, 3})
|
|
|
|
// Test with valid prefix
|
|
result := TrimPrefix(collection, []int{1, 2})
|
|
fmt.Printf("TrimPrefix with prefix {1,2}: %v\n", slices.Collect(result))
|
|
|
|
// Test with string collection
|
|
words := slices.Values([]string{"hello", "hello", "world"})
|
|
result2 := TrimPrefix(words, []string{"hello"})
|
|
fmt.Printf("TrimPrefix with string prefix: %v\n", slices.Collect(result2))
|
|
|
|
// Test with prefix not present
|
|
result3 := TrimPrefix(collection, []int{5, 6})
|
|
fmt.Printf("TrimPrefix with prefix {5,6} (not present): %v\n", slices.Collect(result3))
|
|
|
|
// Output:
|
|
// TrimPrefix with prefix {1,2}: [3]
|
|
// TrimPrefix with string prefix: [world]
|
|
// TrimPrefix with prefix {5,6} (not present): [1 2 1 2 3]
|
|
}
|
|
|
|
func ExampleTrimLast() {
|
|
collection := slices.Values([]int{0, 1, 2, 0, 3, 0})
|
|
|
|
// Test with valid cutset
|
|
result := TrimLast(collection, 0)
|
|
fmt.Printf("TrimLast with cutset {0}: %v\n", slices.Collect(result))
|
|
|
|
// Test with string collection
|
|
words := slices.Values([]string{" hello ", "world", " "})
|
|
result2 := TrimLast(words, " ")
|
|
fmt.Printf("TrimLast with string cutset: %v\n", slices.Collect(result2))
|
|
|
|
// Test with no cutset elements
|
|
result3 := TrimLast(collection, 5)
|
|
fmt.Printf("TrimLast with cutset {5} (not present): %v\n", slices.Collect(result3))
|
|
|
|
// Output:
|
|
// TrimLast with cutset {0}: [0 1 2 0 3]
|
|
// TrimLast with string cutset: [ hello world ]
|
|
// TrimLast with cutset {5} (not present): [0 1 2 0 3 0]
|
|
}
|
|
|
|
func ExampleTrimSuffix() {
|
|
collection := slices.Values([]int{1, 2, 1, 2, 3})
|
|
|
|
// Test with valid suffix
|
|
result := TrimSuffix(collection, []int{1, 2})
|
|
fmt.Printf("TrimSuffix with suffix {1,2}: %v\n", slices.Collect(result))
|
|
|
|
// Test with string collection
|
|
words := slices.Values([]string{"hello", "world", "test"})
|
|
result2 := TrimSuffix(words, []string{"test"})
|
|
fmt.Printf("TrimSuffix with string suffix: %v\n", slices.Collect(result2))
|
|
|
|
// Test with suffix not present
|
|
result3 := TrimSuffix(collection, []int{5, 6})
|
|
fmt.Printf("TrimSuffix with suffix {5,6} (not present): %v\n", slices.Collect(result3))
|
|
|
|
// Output:
|
|
// TrimSuffix with suffix {1,2}: [1 2 1 2 3]
|
|
// TrimSuffix with string suffix: [hello world]
|
|
// TrimSuffix with suffix {5,6} (not present): [1 2 1 2 3]
|
|
}
|