result := Assign(
	map[string]int{"a": 1, "b": 2},
	map[string]int{"b": 3, "c": 4},
)

fmt.Printf("%v %v %v %v", len(result), result["a"], result["b"], result["c"])

Output:

3 1 3 4

count1, err1 := Attempt(2, func(i int) error {
	if i == 0 {
		return errors.New("error")
	}

	return nil
})

count2, err2 := Attempt(2, func(i int) error {
	if i < 10 {
		return errors.New("error")
	}

	return nil
})

fmt.Printf("%v %v\n", count1, err1)
fmt.Printf("%v %v\n", count2, err2)

Output:

2 <nil>
2 error

count1, time1, err1 := AttemptWithDelay(2, time.Millisecond, func(i int, _ time.Duration) error {
	if i == 0 {
		return errors.New("error")
	}

	return nil
})

count2, time2, err2 := AttemptWithDelay(2, time.Millisecond, func(i int, _ time.Duration) error {
	if i < 10 {
		return errors.New("error")
	}

	return nil
})

fmt.Printf("%v %v %v\n", count1, time1.Truncate(time.Millisecond), err1)
fmt.Printf("%v %v %v\n", count2, time2.Truncate(time.Millisecond), err2)

Output:

2 1ms <nil>
2 1ms error

list := []int{0, 1, 2, 3, 4}

result := Chunk(list, 2)

for _, item := range result {
	fmt.Printf("%v\n", item)
}

Output:

[0 1]
[2 3]
[4]

result := ChunkEntries(
	map[string]int{
		"a": 1,
		"b": 2,
		"c": 3,
		"d": 4,
		"e": 5,
	},
	3,
)

for i := range result {
	fmt.Printf("%d\n", len(result[i]))
}

Output:

3
2

result1 := ChunkString("123456", 2)
result2 := ChunkString("1234567", 2)
result3 := ChunkString("", 2)
result4 := ChunkString("1", 2)

fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)
fmt.Printf("%v\n", result4)

Output:

[12 34 56]
[12 34 56 7]
[]
[1]

result1 := Clamp(0, -10, 10)
result2 := Clamp(-42, -10, 10)
result3 := Clamp(42, -10, 10)

fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)

Output:

0
-10
10

input := []int{1, 2, 3, 4, 5}

output := Clone(input)
input[0] = 42

fmt.Printf("%v", output)

Output:

[1 2 3 4 5]

list := []string{"", "foo", "", "bar", ""}

result := Compact(list)

fmt.Printf("%v", result)

Output:

[foo bar]

list := []int{0, 1, 2, 3, 4, 5}

result := Concat(list, list)

fmt.Printf("%v", result)

Output:

[0 1 2 3 4 5 0 1 2 3 4 5]

list := []int{0, 1, 2, 3, 4, 5, 0, 1, 2, 3}

result := Count(list, 2)

fmt.Printf("%v", result)

Output:

2

list := []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

list := []int{0, 1, 2, 3, 4, 5, 0, 1, 2, 3}

_, err := CountByErr(list, func(i int) (bool, error) {
	if i == 3 {
		return false, errors.New("number 3 is not allowed")
	}
	return i < 4, nil
})

fmt.Printf("%v", err)

Output:

number 3 is not allowed

result1 := CountValues([]int{})
result2 := CountValues([]int{1, 2})
result3 := CountValues([]int{1, 2, 2})
result4 := CountValues([]string{"foo", "bar", ""})
result5 := CountValues([]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]

isEven := func(v int) bool {
	return v%2 == 0
}

result1 := CountValuesBy([]int{}, isEven)
result2 := CountValuesBy([]int{1, 2}, isEven)
result3 := CountValuesBy([]int{1, 2, 2}, isEven)

length := func(v string) int {
	return len(v)
}

result4 := CountValuesBy([]string{"foo", "bar", ""}, length)
result5 := CountValuesBy([]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]

result := CrossJoinBy2([]string{"a", "b"}, []int{1, 2, 3, 4}, func(a string, b int) string {
	return fmt.Sprintf("%v-%v", a, b)
})
for _, r := range result {
	fmt.Printf("%v\n", r)
}

Output:

a-1
a-2
a-3
a-4
b-1
b-2
b-3
b-4

result := CrossJoinBy3([]string{"a", "b"}, []int{1, 2, 3, 4}, []bool{true, false}, func(a string, b int, c bool) string {
	return fmt.Sprintf("%v-%v-%v", a, b, c)
})
for _, r := range result {
	fmt.Printf("%v\n", r)
}

Output:

a-1-true
a-1-false
a-2-true
a-2-false
a-3-true
a-3-false
a-4-true
a-4-false
b-1-true
b-1-false
b-2-true
b-2-false
b-3-true
b-3-false
b-4-true
b-4-false

result := CrossJoinBy4([]string{"a", "b"}, []int{1, 2, 3, 4}, []bool{true, false}, []foo{{bar: "bar"}}, func(a string, b int, c bool, d foo) string {
	return fmt.Sprintf("%v-%v-%v-%v", a, b, c, d)
})
for _, r := range result {
	fmt.Printf("%v\n", r)
}

Output:

a-1-true-{bar}
a-1-false-{bar}
a-2-true-{bar}
a-2-false-{bar}
a-3-true-{bar}
a-3-false-{bar}
a-4-true-{bar}
a-4-false-{bar}
b-1-true-{bar}
b-1-false-{bar}
b-2-true-{bar}
b-2-false-{bar}
b-3-true-{bar}
b-3-false-{bar}
b-4-true-{bar}
b-4-false-{bar}

result := CrossJoinBy5([]string{"a", "b"}, []int{1, 2, 3, 4}, []bool{true, false}, []foo{{bar: "bar"}}, []float64{4.2}, func(a string, b int, c bool, d foo, e float64) string {
	return fmt.Sprintf("%v-%v-%v-%v-%v", a, b, c, d, e)
})
for _, r := range result {
	fmt.Printf("%v\n", r)
}

Output:

a-1-true-{bar}-4.2
a-1-false-{bar}-4.2
a-2-true-{bar}-4.2
a-2-false-{bar}-4.2
a-3-true-{bar}-4.2
a-3-false-{bar}-4.2
a-4-true-{bar}-4.2
a-4-false-{bar}-4.2
b-1-true-{bar}-4.2
b-1-false-{bar}-4.2
b-2-true-{bar}-4.2
b-2-false-{bar}-4.2
b-3-true-{bar}-4.2
b-3-false-{bar}-4.2
b-4-true-{bar}-4.2
b-4-false-{bar}-4.2

result := CrossJoinBy6([]string{"a", "b"}, []int{1, 2, 3, 4}, []bool{true, false}, []foo{{bar: "bar"}}, []float64{4.2}, []string{"plop"}, func(a string, b int, c bool, d foo, e float64, f string) string {
	return fmt.Sprintf("%v-%v-%v-%v-%v-%v", a, b, c, d, e, f)
})
for _, r := range result {
	fmt.Printf("%v\n", r)
}

Output:

a-1-true-{bar}-4.2-plop
a-1-false-{bar}-4.2-plop
a-2-true-{bar}-4.2-plop
a-2-false-{bar}-4.2-plop
a-3-true-{bar}-4.2-plop
a-3-false-{bar}-4.2-plop
a-4-true-{bar}-4.2-plop
a-4-false-{bar}-4.2-plop
b-1-true-{bar}-4.2-plop
b-1-false-{bar}-4.2-plop
b-2-true-{bar}-4.2-plop
b-2-false-{bar}-4.2-plop
b-3-true-{bar}-4.2-plop
b-3-false-{bar}-4.2-plop
b-4-true-{bar}-4.2-plop
b-4-false-{bar}-4.2-plop

result := CrossJoinBy7([]string{"a", "b"}, []int{1, 2, 3, 4}, []bool{true, false}, []foo{{bar: "bar"}}, []float64{4.2}, []string{"plop"}, []bool{false}, func(a string, b int, c bool, d foo, e float64, f string, g bool) string {
	return fmt.Sprintf("%v-%v-%v-%v-%v-%v-%v", a, b, c, d, e, f, g)
})
for _, r := range result {
	fmt.Printf("%v\n", r)
}

Output:

a-1-true-{bar}-4.2-plop-false
a-1-false-{bar}-4.2-plop-false
a-2-true-{bar}-4.2-plop-false
a-2-false-{bar}-4.2-plop-false
a-3-true-{bar}-4.2-plop-false
a-3-false-{bar}-4.2-plop-false
a-4-true-{bar}-4.2-plop-false
a-4-false-{bar}-4.2-plop-false
b-1-true-{bar}-4.2-plop-false
b-1-false-{bar}-4.2-plop-false
b-2-true-{bar}-4.2-plop-false
b-2-false-{bar}-4.2-plop-false
b-3-true-{bar}-4.2-plop-false
b-3-false-{bar}-4.2-plop-false
b-4-true-{bar}-4.2-plop-false
b-4-false-{bar}-4.2-plop-false

result := CrossJoinBy8([]string{"a", "b"}, []int{1, 2, 3, 4}, []bool{true, false}, []foo{{bar: "bar"}}, []float64{4.2}, []string{"plop"}, []bool{false}, []int{42}, func(a string, b int, c bool, d foo, e float64, f string, g bool, h int) string {
	return fmt.Sprintf("%v-%v-%v-%v-%v-%v-%v-%v", a, b, c, d, e, f, g, h)
})
for _, r := range result {
	fmt.Printf("%v\n", r)
}

Output:

a-1-true-{bar}-4.2-plop-false-42
a-1-false-{bar}-4.2-plop-false-42
a-2-true-{bar}-4.2-plop-false-42
a-2-false-{bar}-4.2-plop-false-42
a-3-true-{bar}-4.2-plop-false-42
a-3-false-{bar}-4.2-plop-false-42
a-4-true-{bar}-4.2-plop-false-42
a-4-false-{bar}-4.2-plop-false-42
b-1-true-{bar}-4.2-plop-false-42
b-1-false-{bar}-4.2-plop-false-42
b-2-true-{bar}-4.2-plop-false-42
b-2-false-{bar}-4.2-plop-false-42
b-3-true-{bar}-4.2-plop-false-42
b-3-false-{bar}-4.2-plop-false-42
b-4-true-{bar}-4.2-plop-false-42
b-4-false-{bar}-4.2-plop-false-42

result := CrossJoinBy9([]string{"a", "b"}, []int{1, 2, 3, 4}, []bool{true, false}, []foo{{bar: "bar"}}, []float64{4.2}, []string{"plop"}, []bool{false}, []int{42}, []string{"hello world"}, func(a string, b int, c bool, d foo, e float64, f string, g bool, h int, i string) string {
	return fmt.Sprintf("%v-%v-%v-%v-%v-%v-%v-%v-%v", a, b, c, d, e, f, g, h, i)
})
for _, r := range result {
	fmt.Printf("%v\n", r)
}

Output:

a-1-true-{bar}-4.2-plop-false-42-hello world
a-1-false-{bar}-4.2-plop-false-42-hello world
a-2-true-{bar}-4.2-plop-false-42-hello world
a-2-false-{bar}-4.2-plop-false-42-hello world
a-3-true-{bar}-4.2-plop-false-42-hello world
a-3-false-{bar}-4.2-plop-false-42-hello world
a-4-true-{bar}-4.2-plop-false-42-hello world
a-4-false-{bar}-4.2-plop-false-42-hello world
b-1-true-{bar}-4.2-plop-false-42-hello world
b-1-false-{bar}-4.2-plop-false-42-hello world
b-2-true-{bar}-4.2-plop-false-42-hello world
b-2-false-{bar}-4.2-plop-false-42-hello world
b-3-true-{bar}-4.2-plop-false-42-hello world
b-3-false-{bar}-4.2-plop-false-42-hello world
b-4-true-{bar}-4.2-plop-false-42-hello world
b-4-false-{bar}-4.2-plop-false-42-hello world

result, err := CrossJoinByErr2([]string{"a", "b"}, []int{1, 2}, func(a string, b int) (string, error) {
	if a == "b" {
		return "", errors.New("b not allowed")
	}
	return fmt.Sprintf("%v-%v", a, b), nil
})
if err != nil {
	fmt.Printf("error: %v\n", err)
	return
}
for _, r := range result {
	fmt.Printf("%v\n", r)
}

Output:

error: b not allowed

collection := []string{"a", "b", "c", "d", "e", "f", "g"}

// Test with valid separator
before, after, found := Cut(collection, []string{"b", "c", "d"})
fmt.Printf("Before: %v, After: %v, Found: %t\n", before, after, found)

// Test with separator not found
before2, after2, found2 := Cut(collection, []string{"z"})
fmt.Printf("Before: %v, After: %v, Found: %t\n", before2, after2, found2)

// Test with separator at beginning
before3, after3, found3 := Cut(collection, []string{"a", "b"})
fmt.Printf("Before: %v, After: %v, Found: %t\n", before3, after3, found3)

Output:

Before: [a], After: [e f g], Found: true
Before: [a b c d e f g], After: [], Found: false
Before: [], After: [c d e f g], Found: true

collection := []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", after, found)

// Test with prefix not found
after2, found2 := CutPrefix(collection, []string{"b"})
fmt.Printf("After: %v, Found: %t\n", after2, found2)

// Test with empty prefix
after3, found3 := CutPrefix(collection, []string{})
fmt.Printf("After: %v, Found: %t\n", 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

collection := []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", before, found)

// Test with suffix not found
before2, found2 := CutSuffix(collection, []string{"b"})
fmt.Printf("Before: %v, Found: %t\n", before2, found2)

// Test with empty suffix
before3, found3 := CutSuffix(collection, []string{})
fmt.Printf("Before: %v, Found: %t\n", 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

list := []int{0, 1, 2, 3, 4, 5}

result := Drop(list, 2)

fmt.Printf("%v", result)

Output:

[2 3 4 5]

list := []int{0, 1, 2, 3, 4, 5}

result := DropByIndex(list, 2)

fmt.Printf("%v", result)

Output:

[0 1 3 4 5]

list := []int{0, 1, 2, 3, 4, 5}

result := DropRight(list, 2)

fmt.Printf("%v", result)

Output:

[0 1 2 3]

list := []int{0, 1, 2, 3, 4, 5}

result := DropRightWhile(list, func(val int) bool {
	return val > 2
})

fmt.Printf("%v", result)

Output:

[0 1 2]

list := []int{0, 1, 2, 3, 4, 5}

result := DropWhile(list, func(val int) bool {
	return val < 2
})

fmt.Printf("%v", result)

Output:

[2 3 4 5]

now := time.Now()
past := now.Add(-time.Hour)
future := now.Add(time.Hour)

result := Earliest(future, now, past)

fmt.Printf("%t", result.Equal(past))

Output:

true

type Event struct {
	Name string
	Time time.Time
}

now := time.Now()
events := []Event{
	{Name: "Event A", Time: now.Add(time.Hour)},
	{Name: "Event B", Time: now},
	{Name: "Event C", Time: now.Add(-time.Hour)},
}

result := EarliestBy(events, func(event Event) time.Time {
	return event.Time
})

fmt.Printf("%s", result.Name)

Output:

Event C

type Event struct {
	Name string
	Time time.Time
}

now := time.Now()
events := []Event{
	{Name: "Event A", Time: now.Add(time.Hour)},
	{Name: "Event B", Time: now},
	{Name: "Event C", Time: now.Add(-time.Hour)},
}

_, err := EarliestByErr(events, func(event Event) (time.Time, error) {
	if event.Name == "Event B" {
		return time.Time{}, errors.New("event b is not allowed")
	}
	return event.Time, nil
})

fmt.Printf("%v", err)

Output:

event b is not allowed

doSomething := func() error {
	return &myError{}
}

err := doSomething()

if rateLimitErr, ok := ErrorsAs[*myError](err); ok {
	fmt.Printf("is type myError, err: %s", rateLimitErr.Error())
} else {
	fmt.Printf("is not type myError")
}

Output:

is type myError, err: my error

list := []foo{{"a"}, {"a"}}

result := Fill(list, foo{"b"})

fmt.Printf("%v", result)

Output:

[{b} {b}]

list := []int64{1, 2, 3, 4}

result := Filter(list, func(nbr int64, index int) bool {
	return nbr%2 == 0
})

fmt.Printf("%v", result)

Output:

[2 4]

list := []int64{1, 2, 3, 4}

result, err := FilterErr(list, func(nbr int64, index int) (bool, error) {
	if nbr == 3 {
		return false, errors.New("number 3 is not allowed")
	}
	return nbr%2 == 0, nil
})
fmt.Printf("%v, %v\n", result, err)

result, err = FilterErr([]int64{1, 2, 4, 6}, func(nbr int64, index int) (bool, error) {
	return nbr%2 == 0, nil
})
fmt.Printf("%v, %v\n", result, err)

Output:

[], number 3 is not allowed
[2 4 6], <nil>

kv := map[int]string{1: "foo", 2: "bar", 3: "baz"}

result := FilterKeys(kv, func(k int, v string) bool {
	return v == "foo"
})

fmt.Printf("%v", result)

Output:

[1]

kv := map[int]string{1: "foo", 2: "bar", 3: "baz"}

result, err := FilterKeysErr(kv, func(k int, v string) (bool, error) {
	if k == 3 {
		return false, errors.New("key 3 not allowed")
	}
	return v == "foo", nil
})
fmt.Printf("%v, %v\n", result, err)

result, err = FilterKeysErr(kv, func(k int, v string) (bool, error) {
	return v == "bar", nil
})
fmt.Printf("%v, %v\n", result, err)

Output:

[], key 3 not allowed
[2], <nil>

list := []int64{1, 2, 3, 4}

result := FilterMap(list, func(nbr int64, index int) (string, bool) {
	return strconv.FormatInt(nbr*2, 10), nbr%2 == 0
})

fmt.Printf("%v", result)

Output:

[4 8]

kv := map[int]int64{1: 1, 2: 2, 3: 3, 4: 4}

result := FilterMapToSlice(kv, func(k int, v int64) (string, bool) {
	return fmt.Sprintf("%d_%d", k, v), k%2 == 0
})

sort.Strings(result)
fmt.Printf("%v", result)

Output:

[2_2 4_4]

kv := map[int]int64{1: 1, 2: 2, 3: 3, 4: 4}

_, err := FilterMapToSliceErr(kv, func(k int, v int64) (string, bool, error) {
	if k == 3 {
		return "", false, errors.New("key 3 is not allowed")
	}
	return fmt.Sprintf("%d_%d", k, v), k%2 == 0, nil
})

fmt.Printf("%v", err)

Output:

key 3 is not allowed

list := []string{"a", "aa", "aaa"}

result := FilterSliceToMap(list, func(str string) (string, int, bool) {
	return str, len(str), len(str) > 1
})

fmt.Printf("%v", result)

Output:

map[aa:2 aaa:3]

kv := map[int]string{1: "foo", 2: "bar", 3: "baz"}

result := FilterValues(kv, func(k int, v string) bool {
	return v == "foo"
})

fmt.Printf("%v", result)

Output:

[foo]

kv := map[int]string{1: "foo", 2: "bar", 3: "baz"}

result, err := FilterValuesErr(kv, func(k int, v string) (bool, error) {
	if k == 3 {
		return false, errors.New("key 3 not allowed")
	}
	return v == "foo", nil
})
fmt.Printf("%v, %v\n", result, err)

result, err = FilterValuesErr(kv, func(k int, v string) (bool, error) {
	return v == "bar", nil
})
fmt.Printf("%v, %v\n", result, err)

Output:

[], key 3 not allowed
[bar], <nil>

type User struct {
	Name string
	Age  int
}

users := []User{
	{Name: "Alice", Age: 25},
	{Name: "Bob", Age: 30},
	{Name: "Charlie", Age: 35},
}

result, found := Find(users, func(user User) bool {
	return user.Age > 30
})

fmt.Printf("%s %t", result.Name, found)

Output:

Charlie true

list := []int{1, 2, 3, 4, 5}

result, found := Find(list, func(n int) bool {
	return n > 10
})

fmt.Printf("%d %t", result, found)

Output:

0 false

list := []int{1, 2, 2, 3, 3, 3, 4, 5}

result := FindDuplicates(list)

fmt.Printf("%v", result)

Output:

[2 3]

type User struct {
	Name string
	Age  int
}

users := []User{
	{Name: "Alice", Age: 25},
	{Name: "Bob", Age: 30},
	{Name: "Charlie", Age: 25},
	{Name: "David", Age: 30},
	{Name: "Eve", Age: 35},
}

result := FindDuplicatesBy(users, func(user User) int {
	return user.Age
})

fmt.Printf("%d", len(result))

Output:

2

type User struct {
	Name string
	Age  int
}

users := []User{
	{Name: "Alice", Age: 25},
	{Name: "Bob", Age: 30},
	{Name: "Charlie", Age: 25},
	{Name: "David", Age: 30},
	{Name: "Eve", Age: 35},
}

result, err := FindDuplicatesByErr(users, func(user User) (int, error) {
	if user.Name == "Charlie" {
		return 0, errors.New("charlie is not allowed")
	}
	return user.Age, nil
})

fmt.Printf("%d %v", len(result), err)

Output:

0 charlie is not allowed

result, err := FindErr([]string{"a", "b", "c", "d"}, func(i string) (bool, error) {
	return i == "b", nil
})
fmt.Printf("%v %v\n", result, err)

result, err = FindErr([]string{"foobar"}, func(i string) (bool, error) {
	return i == "b", nil
})
fmt.Printf("%v %v\n", result, err)

result, err = FindErr([]string{"a", "b", "c"}, func(i string) (bool, error) {
	if i == "b" {
		return false, errors.New("b is not allowed")
	}
	return i == "b", nil
})
fmt.Printf("%v %v", result, err)

Output:

b <nil>
 <nil>
 b is not allowed

list := []int{1, 2, 3, 4, 5}

result, index, found := FindIndexOf(list, func(n int) bool {
	return n > 2
})

fmt.Printf("%d %d %t", result, index, found)

Output:

3 2 true

list := []int{1, 2, 3, 4, 5}

result, index, found := FindIndexOf(list, func(n int) bool {
	return n > 10
})

fmt.Printf("%d %d %t", result, index, found)

Output:

0 -1 false

users := map[string]int{
	"Alice":   25,
	"Bob":     30,
	"Charlie": 35,
}

key, found := FindKey(users, 30)

fmt.Printf("%s %t", key, found)

Output:

Bob true

users := map[string]int{
	"Alice":   25,
	"Bob":     30,
	"Charlie": 35,
}

key, found := FindKey(users, 40)

fmt.Printf("%s %t", key, found)

Output:

false

users := map[string]int{
	"Alice":   25,
	"Bob":     30,
	"Charlie": 35,
}

key, found := FindKeyBy(users, func(name string, age int) bool {
	return age > 30
})

fmt.Printf("%s %t", key, found)

Output:

Charlie true

users := map[string]int{
	"Alice":   25,
	"Bob":     30,
	"Charlie": 35,
}

key, found := FindKeyBy(users, func(name string, age int) bool {
	return age > 40
})

fmt.Printf("%s %t", key, found)

Output:

false

list := []int{1, 2, 3, 4, 3, 5}

result, index, found := FindLastIndexOf(list, func(n int) bool {
	return n == 3
})

fmt.Printf("%d %d %t", result, index, found)

Output:

3 4 true

list := []int{1, 2, 3, 4, 5}

result, index, found := FindLastIndexOf(list, func(n int) bool {
	return n > 10
})

fmt.Printf("%d %d %t", result, index, found)

Output:

0 -1 false

list := []int{1, 2, 3, 4, 5}

result := FindOrElse(list, -1, func(n int) bool {
	return n > 10
})

fmt.Printf("%d", result)

Output:

-1

list := []int{1, 2, 3, 4, 5}

result := FindOrElse(list, -1, func(n int) bool {
	return n > 3
})

fmt.Printf("%d", result)

Output:

4

list := []int{1, 2, 2, 3, 3, 3, 4, 5}

result := FindUniques(list)

fmt.Printf("%v", result)

Output:

[1 4 5]

type User struct {
	Name string
	Age  int
}

users := []User{
	{Name: "Alice", Age: 25},
	{Name: "Bob", Age: 30},
	{Name: "Charlie", Age: 25},
	{Name: "David", Age: 30},
	{Name: "Eve", Age: 35},
}

result := FindUniquesBy(users, func(user User) int {
	return user.Age
})

fmt.Printf("%d", len(result))

Output:

1

list := []int{1, 2, 3, 4, 5}

result, found := First(list)

fmt.Printf("%d %t", result, found)

Output:

1 true

list := []int{}

result, found := First(list)

fmt.Printf("%d %t", result, found)

Output:

0 false

list := []int{1, 2, 3, 4, 5}

result := FirstOr(list, -1)

fmt.Printf("%d", result)

Output:

1

list := []int{}

result := FirstOr(list, -1)

fmt.Printf("%d", result)

Output:

-1

list := []int{1, 2, 3, 4, 5}

result := FirstOrEmpty(list)

fmt.Printf("%d", result)

Output:

1

list := []int{}

result := FirstOrEmpty(list)

fmt.Printf("%d", result)

Output:

0

list := []int64{1, 2, 3, 4}

result := FlatMap(list, func(nbr int64, index int) []string {
	return []string{
		strconv.FormatInt(nbr, 10), // base 10
		strconv.FormatInt(nbr, 2),  // base 2
	}
})

fmt.Printf("%v", result)

Output:

[1 1 2 10 3 11 4 100]

list := []int64{1, 2, 3, 4}

_, err := FlatMapErr(list, func(nbr int64, index int) ([]string, error) {
	if nbr == 3 {
		return nil, errors.New("number 3 is not allowed")
	}
	return []string{
		strconv.FormatInt(nbr, 10), // base 10
		strconv.FormatInt(nbr, 2),  // base 2
	}, nil
})

fmt.Printf("%v", err)

Output:

number 3 is not allowed

list := [][]int{{0, 1, 2}, {3, 4, 5}}

result := Flatten(list)

fmt.Printf("%v", result)

Output:

[0 1 2 3 4 5]

list := []int64{1, 2, 3, 4}

ForEach(list, func(x int64, _ int) {
	fmt.Println(x)
})

Output:

1
2
3
4

list := []int64{1, 2, -math.MaxInt, 4}

ForEachWhile(list, func(x int64, _ int) bool {
	if x < 0 {
		return false
	}
	fmt.Println(x)
	return true
})

Output:

1
2

result := FromEntries([]Entry[string, int]{
	{
		Key:   "foo",
		Value: 1,
	},
	{
		Key:   "bar",
		Value: 2,
	},
	{
		Key:   "baz",
		Value: 3,
	},
})

fmt.Printf("%v %v %v %v", len(result), result["foo"], result["bar"], result["baz"])

Output:

3 1 2 3

func Generator[T any](bufferSize int, generator func(yield func(T))) <-chan T

Generator implements the generator design pattern. Play: https://go.dev/play/p/lIbSY3QmiEg

Deprecated: use "iter" package instead (Go >= 1.23).

list := []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]

list := []int{0, 1, 2, 3, 4, 5}

_, err := GroupByErr(list, func(i int) (int, error) {
	if i == 3 {
		return 0, errors.New("number 3 is not allowed")
	}
	return i % 3, nil
})

fmt.Printf("%v", err)

Output:

number 3 is not allowed

list := []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]

list := []int{0, 1, 2, 3, 4, 5}

_, err := GroupByMapErr(list, func(i int) (int, int, error) {
	if i == 3 {
		return 0, 0, errors.New("number 3 is not allowed")
	}
	return i % 3, i * 2, nil
})

fmt.Printf("%v", err)

Output:

number 3 is not allowed

result1 := If(true, 1).
	ElseIf(false, 2).
	Else(3)

result2 := If(false, 1).
	ElseIf(true, 2).
	Else(3)

result3 := If(false, 1).
	ElseIf(false, 2).
	Else(3)

result4 := IfF(true, func() int { return 1 }).
	ElseIfF(false, func() int { return 2 }).
	ElseF(func() int { return 3 })

result5 := IfF(false, func() int { return 1 }).
	ElseIfF(true, func() int { return 2 }).
	ElseF(func() int { return 3 })

result6 := IfF(false, func() int { return 1 }).
	ElseIfF(false, func() int { return 2 }).
	ElseF(func() int { return 3 })

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)
fmt.Printf("%v\n", result6)

Output:

1
2
3
1
2
3

result1 := If(true, 1).
	ElseIf(false, 2).
	Else(3)

result2 := If(false, 1).
	ElseIf(true, 2).
	Else(3)

result3 := If(false, 1).
	ElseIf(false, 2).
	Else(3)

result4 := IfF(true, func() int { return 1 }).
	ElseIfF(false, func() int { return 2 }).
	ElseF(func() int { return 3 })

result5 := IfF(false, func() int { return 1 }).
	ElseIfF(true, func() int { return 2 }).
	ElseF(func() int { return 3 })

result6 := IfF(false, func() int { return 1 }).
	ElseIfF(false, func() int { return 2 }).
	ElseF(func() int { return 3 })

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)
fmt.Printf("%v\n", result6)

Output:

1
2
3
1
2
3

list := []string{"foo", "bar", "baz"}

result := IndexOf(list, "bar")

fmt.Printf("%d", result)

Output:

1

list := []string{"foo", "bar", "baz"}

result := IndexOf(list, "qux")

fmt.Printf("%d", result)

Output:

-1

list1 := [][]int{{1, 4, 7}, {2, 5, 8}, {3, 6, 9}}
list2 := [][]int{{1}, {2, 5, 8}, {3, 6}, {4, 7, 9, 10}}

result1 := Interleave(list1...)
result2 := 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]

result := Intersect([]int{0, 3, 5, 7}, []int{3, 5}, []int{0, 1, 2, 0, 3, 0})
fmt.Printf("%v", result)

Output:

[3]

result := IntersectBy(strconv.Itoa, []int{0, 6, 0, 3}, []int{0, 1, 2, 3, 4, 5}, []int{0, 6})
fmt.Printf("%v", result)

Output:

[0]

kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}

result := Invert(kv)

fmt.Printf("%v %v %v %v", len(result), result[1], result[2], result[3])

Output:

3 foo bar baz

list := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

result := IsSorted(list)

fmt.Printf("%v", result)

Output:

true

list := []string{"a", "bb", "ccc"}

result := IsSortedBy(list, func(s string) int {
	return len(s)
})

fmt.Printf("%v", result)

Output:

true

IsSortedByKey checks if a slice is sorted by iteratee.

Deprecated: Use lo.IsSortedBy instead.

list := []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]

list := []string{"a", "aa", "aaa"}

_, err := KeyByErr(list, func(str string) (int, error) {
	if str == "aa" {
		return 0, errors.New("aa is not allowed")
	}
	return len(str), nil
})

fmt.Printf("%v", err)

Output:

aa is not allowed

list := []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:{}]

kv := map[string]int{"foo": 1, "bar": 2}
kv2 := map[string]int{"baz": 3}

result := Keys(kv, kv2)
sort.Strings(result)
fmt.Printf("%v", result)

Output:

[bar baz foo]

list := []int{1, 2, 3, 4, 5}

result, found := Last(list)

fmt.Printf("%d %t", result, found)

Output:

5 true

list := []int{}

result, found := Last(list)

fmt.Printf("%d %t", result, found)

Output:

0 false

list := []string{"foo", "bar", "baz", "bar"}

result := LastIndexOf(list, "bar")

fmt.Printf("%d", result)

Output:

3

list := []string{"foo", "bar", "baz"}

result := LastIndexOf(list, "qux")

fmt.Printf("%d", result)

Output:

-1

list := []int{1, 2, 3, 4, 5}

result := LastOr(list, -1)

fmt.Printf("%d", result)

Output:

5

list := []int{}

result := LastOr(list, -1)

fmt.Printf("%d", result)

Output:

-1

list := []int{1, 2, 3, 4, 5}

result := LastOrEmpty(list)

fmt.Printf("%d", result)

Output:

5

list := []int{}

result := LastOrEmpty(list)

fmt.Printf("%d", result)

Output:

0

now := time.Now()
past := now.Add(-time.Hour)
future := now.Add(time.Hour)

result := Latest(future, now, past)

fmt.Printf("%t", result.Equal(future))

Output:

true

type Event struct {
	Name string
	Time time.Time
}

now := time.Now()
events := []Event{
	{Name: "Event A", Time: now.Add(time.Hour)},
	{Name: "Event B", Time: now},
	{Name: "Event C", Time: now.Add(-time.Hour)},
}

result := LatestBy(events, func(event Event) time.Time {
	return event.Time
})

fmt.Printf("%s", result.Name)

Output:

Event A

type Event struct {
	Name string
	Time time.Time
	Err  error // Simulates error condition
}

now := time.Now()
events := []Event{
	{Name: "Event A", Time: now.Add(time.Hour), Err: nil},
	{Name: "Event B", Time: now, Err: errors.New("event b error")},
	{Name: "Event C", Time: now.Add(-time.Hour), Err: nil},
}

_, err := LatestByErr(events, func(event Event) (time.Time, error) {
	if event.Err != nil {
		return time.Time{}, event.Err
	}
	return event.Time, nil
})

fmt.Printf("%v", err)

Output:

event b error

list := []int64{1, 2, 3, 4}

result := Map(list, func(nbr int64, index int) string {
	return strconv.FormatInt(nbr*2, 10)
})

fmt.Printf("%v", result)

Output:

[2 4 6 8]

kv := map[string]int{"foo": 1, "bar": 2}

result := MapEntries(kv, func(k string, v int) (int, string) {
	return v, k
})

fmt.Printf("%v", result)

Output:

map[1:foo 2:bar]

kv := map[string]int{"foo": 1, "bar": 2}

_, err := MapEntriesErr(kv, func(k string, v int) (int, string, error) {
	if k == "foo" {
		return 0, "", errors.New("entry foo is not allowed")
	}
	return v, k, nil
})

fmt.Printf("%v", err)

Output:

entry foo is not allowed

list := []int64{1, 2, 3, 4}

_, err := MapErr(list, func(nbr int64, index int) (string, error) {
	if nbr == 3 {
		return "", errors.New("number 3 is not allowed")
	}
	return strconv.FormatInt(nbr*2, 10), nil
})

fmt.Printf("%v", err)

Output:

number 3 is not allowed

kv := map[int]int{1: 1, 2: 2, 3: 3, 4: 4}

result := MapKeys(kv, func(_, k int) string {
	return strconv.FormatInt(int64(k), 10)
})

fmt.Printf("%v %v %v %v %v", len(result), result["1"], result["2"], result["3"], result["4"])

Output:

4 1 2 3 4

kv := map[int]int{1: 1, 2: 2, 3: 3, 4: 4}

_, err := MapKeysErr(kv, func(_, k int) (string, error) {
	if k == 3 {
		return "", errors.New("key 3 is not allowed")
	}
	return strconv.FormatInt(int64(k), 10), nil
})

fmt.Printf("%v", err)

Output:

key 3 is not allowed

kv := map[int]int64{1: 1, 2: 2, 3: 3, 4: 4}

result := MapToSlice(kv, func(k int, v int64) string {
	return fmt.Sprintf("%d_%d", k, v)
})

sort.Strings(result)
fmt.Printf("%v", result)

Output:

[1_1 2_2 3_3 4_4]

kv := map[int]int64{1: 1, 2: 2, 3: 3, 4: 4}

_, err := MapToSliceErr(kv, func(k int, v int64) (string, error) {
	if k == 3 {
		return "", errors.New("key 3 is not allowed")
	}
	return fmt.Sprintf("%d_%d", k, v), nil
})

fmt.Printf("%v", err)

Output:

key 3 is not allowed

kv := map[int]int{1: 1, 2: 2, 3: 3, 4: 4}

result := MapValues(kv, func(v, _ int) string {
	return strconv.FormatInt(int64(v), 10)
})

fmt.Printf("%v %q %q %q %q", len(result), result[1], result[2], result[3], result[4])

Output:

4 "1" "2" "3" "4"

kv := map[int]int{1: 1, 2: 2, 3: 3, 4: 4}

_, err := MapValuesErr(kv, func(v, _ int) (string, error) {
	if v == 3 {
		return "", errors.New("value 3 is not allowed")
	}
	return strconv.FormatInt(int64(v), 10), nil
})

fmt.Printf("%v", err)

Output:

value 3 is not allowed

list := []int{3, 1, 4, 1, 5, 9, 2, 6}

result := Max(list)

fmt.Printf("%d", result)

Output:

9

list := []int{}

result := Max(list)

fmt.Printf("%d", result)

Output:

0

type User struct {
	Name string
	Age  int
}

users := []User{
	{Name: "Alice", Age: 25},
	{Name: "Bob", Age: 30},
	{Name: "Charlie", Age: 35},
}

result := MaxBy(users, func(a, b User) bool {
	return a.Age > b.Age
})

fmt.Printf("%s", result.Name)

Output:

Charlie

type User struct {
	Name string
	Age  int
}

users := []User{
	{Name: "Alice", Age: 25},
	{Name: "Bob", Age: 30},
	{Name: "Charlie", Age: 35},
}

_, err := MaxByErr(users, func(a, b User) (bool, error) {
	if b.Name == "Bob" {
		return false, errors.New("bob is not allowed")
	}
	return a.Age > b.Age, nil
})

fmt.Printf("%v", err)

Output:

bob is not allowed

list := []int{3, 1, 4, 1, 5, 9, 2, 6}

result, index := MaxIndex(list)

fmt.Printf("%d %d", result, index)

Output:

9 5

list := []int{}

result, index := MaxIndex(list)

fmt.Printf("%d %d", result, index)

Output:

0 -1

type User struct {
	Name string
	Age  int
}

users := []User{
	{Name: "Alice", Age: 25},
	{Name: "Bob", Age: 30},
	{Name: "Charlie", Age: 35},
}

result, index := MaxIndexBy(users, func(a, b User) bool {
	return a.Age > b.Age
})

fmt.Printf("%s %d", result.Name, index)

Output:

Charlie 2

type User struct {
	Name string
	Age  int
}

users := []User{
	{Name: "Alice", Age: 25},
	{Name: "Bob", Age: 30},
	{Name: "Charlie", Age: 35},
}

_, _, err := MaxIndexByErr(users, func(a, b User) (bool, error) {
	if b.Name == "Bob" {
		return false, errors.New("bob is not allowed")
	}
	return a.Age > b.Age, nil
})

fmt.Printf("%v", err)

Output:

bob is not allowed

list := []int{1, 2, 3, 4, 5}

result := Mean(list)

fmt.Printf("%v", result)

Output:

3

list := []string{"foo", "bar"}

result := MeanBy(list, func(item string) int {
	return len(item)
})

fmt.Printf("%v", result)

Output:

3

list := []string{"foo", "bar", "baz"}

_, err := MeanByErr(list, func(item string) (int, error) {
	if item == "bar" {
		return 0, errors.New("bar is not allowed")
	}
	return len(item), nil
})

fmt.Printf("%v", err)

Output:

bar is not allowed

list := []int{3, 1, 4, 1, 5, 9, 2, 6}

result := Min(list)

fmt.Printf("%d", result)

Output:

1

list := []int{}

result := Min(list)

fmt.Printf("%d", result)

Output:

0

type User struct {
	Name string
	Age  int
}

users := []User{
	{Name: "Alice", Age: 25},
	{Name: "Bob", Age: 30},
	{Name: "Charlie", Age: 35},
}

result := MinBy(users, func(a, b User) bool {
	return a.Age < b.Age
})

fmt.Printf("%s", result.Name)

Output:

Alice

type User struct {
	Name string
	Age  int
}

users := []User{
	{Name: "Alice", Age: 25},
	{Name: "Bob", Age: 30},
	{Name: "Charlie", Age: 35},
}

result, err := MinByErr(users, func(a, b User) (bool, error) {
	if a.Name == "Bob" {
		return false, errors.New("bob is not allowed")
	}
	return a.Age < b.Age, nil
})

fmt.Printf("%v %v", result.Name, err)

Output:

bob is not allowed

list := []int{3, 1, 4, 1, 5, 9, 2, 6}

result, index := MinIndex(list)

fmt.Printf("%d %d", result, index)

Output:

1 1

list := []int{}

result, index := MinIndex(list)

fmt.Printf("%d %d", result, index)

Output:

0 -1

type User struct {
	Name string
	Age  int
}

users := []User{
	{Name: "Alice", Age: 25},
	{Name: "Bob", Age: 30},
	{Name: "Charlie", Age: 35},
}

result, index := MinIndexBy(users, func(a, b User) bool {
	return a.Age < b.Age
})

fmt.Printf("%s %d", result.Name, index)

Output:

Alice 0

type User struct {
	Name string
	Age  int
}

users := []User{
	{Name: "Alice", Age: 25},
	{Name: "Bob", Age: 30},
	{Name: "Charlie", Age: 35},
}

result, _, err := MinIndexByErr(users, func(a, b User) (bool, error) {
	if a.Name == "Bob" {
		return false, errors.New("bob is not allowed")
	}
	return a.Age < b.Age, nil
})

fmt.Printf("%v %v", result.Name, err)

Output:

bob is not allowed

defer func() {
	_ = recover()
}()

// won't panic
Must(42, nil)

// won't panic
cb := func() (int, error) {
	return 42, nil
}
Must(cb())

// will panic
Must(42, errors.New("my error"))

// will panic with error message
Must(42, errors.New("world"), "hello")

defer func() {
	_ = recover()
}()

// won't panic
Must0(nil)

// will panic
Must0(errors.New("my error"))

// will panic with error message
Must0(errors.New("world"), "hello")

defer func() {
	_ = recover()
}()

// won't panic
Must1(42, nil)

// won't panic
cb := func() (int, error) {
	return 42, nil
}
Must1(cb())

// will panic
Must1(42, errors.New("my error"))

// will panic with error message
Must1(42, errors.New("world"), "hello")

defer func() {
	_ = recover()
}()

// won't panic
Must2(42, "hello", nil)

// will panic
Must2(42, "hello", errors.New("my error"))

// will panic with error message
Must2(42, "hello", errors.New("world"), "hello")

defer func() {
	_ = recover()
}()

// won't panic
Must3(42, "hello", 4.2, nil)

// will panic
Must3(42, "hello", 4.2, errors.New("my error"))

// will panic with error message
Must3(42, "hello", 4.2, errors.New("world"), "hello")

defer func() {
	_ = recover()
}()

// won't panic
Must4(42, "hello", 4.2, true, nil)

// will panic
Must4(42, "hello", 4.2, true, errors.New("my error"))

// will panic with error message
Must4(42, "hello", 4.2, true, errors.New("world"), "hello")

defer func() {
	_ = recover()
}()

// won't panic
Must5(42, "hello", 4.2, true, foo{}, nil)

// will panic
Must5(42, "hello", 4.2, true, foo{}, errors.New("my error"))

// will panic with error message
Must5(42, "hello", 4.2, true, foo{}, errors.New("world"), "hello")

defer func() {
	_ = recover()
}()

// won't panic
Must5(42, "hello", 4.2, true, foo{}, "foobar", nil)

// will panic
Must5(42, "hello", 4.2, true, foo{}, "foobar", errors.New("my error"))

// will panic with error message
Must5(42, "hello", 4.2, true, foo{}, "foobar", errors.New("world"), "hello")

i := int32(0)
calls := []int32{}
mu := sync.Mutex{}

debounce, cancel := NewDebounce(time.Millisecond, func() {
	mu.Lock()
	defer mu.Unlock()
	calls = append(calls, atomic.LoadInt32(&i))
})

debounce()
atomic.AddInt32(&i, 1)

time.Sleep(5 * time.Millisecond)

debounce()
atomic.AddInt32(&i, 1)
debounce()
atomic.AddInt32(&i, 1)
debounce()
atomic.AddInt32(&i, 1)

time.Sleep(5 * time.Millisecond)

cancel()

mu.Lock()
fmt.Printf("%v", calls)
mu.Unlock()

Output:

[1 4]

calls := map[string][]int{}
mu := sync.Mutex{}

debounce, cancel := NewDebounceBy(time.Millisecond, func(userID string, count int) {
	mu.Lock()
	defer mu.Unlock()

	if _, ok := calls[userID]; !ok {
		calls[userID] = []int{}
	}

	calls[userID] = append(calls[userID], count)
})

debounce("samuel")
debounce("john")

time.Sleep(5 * time.Millisecond)

debounce("john")
debounce("john")
debounce("samuel")
debounce("john")

time.Sleep(5 * time.Millisecond)

cancel("samuel")
cancel("john")

mu.Lock()
fmt.Printf("samuel: %v\n", calls["samuel"])
fmt.Printf("john: %v\n", calls["john"])
mu.Unlock()

Output:

samuel: [1 1]
john: [1 3]

throttle, reset := NewThrottle(100*time.Millisecond, func() {
	fmt.Println("Called once in every 100ms")
})

for j := 0; j < 10; j++ {
	throttle()
	time.Sleep(30 * time.Millisecond)
}

reset()

Output:

Called once in every 100ms
Called once in every 100ms
Called once in every 100ms

throttle, reset := NewThrottleBy(100*time.Millisecond, func(key string) {
	fmt.Println(key, "Called once in every 100ms")
})

for j := 0; j < 10; j++ {
	throttle("foo")
	throttle("bar")
	time.Sleep(30 * time.Millisecond)
}

reset()

Output:

foo Called once in every 100ms
bar Called once in every 100ms
foo Called once in every 100ms
bar Called once in every 100ms
foo Called once in every 100ms
bar Called once in every 100ms

throttle, reset := NewThrottleByWithCount(100*time.Millisecond, 2, func(key string) {
	fmt.Println(key, "Called once in every 100ms")
})

for j := 0; j < 10; j++ {
	throttle("foo")
	throttle("bar")
	time.Sleep(30 * time.Millisecond)
}

reset()

Output:

foo Called once in every 100ms
bar Called once in every 100ms
foo Called once in every 100ms
bar Called once in every 100ms
foo Called once in every 100ms
bar Called once in every 100ms
foo Called once in every 100ms
bar Called once in every 100ms
foo Called once in every 100ms
bar Called once in every 100ms
foo Called once in every 100ms
bar Called once in every 100ms

throttle, reset := NewThrottleWithCount(100*time.Millisecond, 2, func() {
	fmt.Println("Called once in every 100ms")
})

for j := 0; j < 10; j++ {
	throttle()
	time.Sleep(30 * time.Millisecond)
}

reset()

Output:

Called once in every 100ms
Called once in every 100ms
Called once in every 100ms
Called once in every 100ms
Called once in every 100ms
Called once in every 100ms

list := []int{1, 2, 3, 4, 5}

result, err := Nth(list, 2)

fmt.Printf("%d %v", result, err)

Output:

3 <nil>

list := []int{1, 2, 3, 4, 5}

result, err := Nth(list, -2)

fmt.Printf("%d %v", result, err)

Output:

4 <nil>

list := []int{1, 2, 3, 4, 5}

result, err := Nth(list, 10)

fmt.Printf("%d %v", result, err)

Output:

0 nth: 10 out of slice bounds

list := []int{1, 2, 3, 4, 5}

result := NthOr(list, 2, -1)

fmt.Printf("%d", result)

Output:

3

list := []int{1, 2, 3, 4, 5}

result := NthOr(list, 10, -1)

fmt.Printf("%d", result)

Output:

-1

list := []int{1, 2, 3, 4, 5}

result := NthOrEmpty(list, 2)

fmt.Printf("%d", result)

Output:

3

list := []int{1, 2, 3, 4, 5}

result := NthOrEmpty(list, 10)

fmt.Printf("%d", result)

Output:

0

kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}

result := OmitBy(kv, func(key string, value int) bool {
	return value%2 == 1
})

fmt.Printf("%v", result)

Output:

map[bar:2]

kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}

_, err := OmitByErr(kv, func(key string, value int) (bool, error) {
	if key == "bar" {
		return false, errors.New("key bar is not allowed")
	}
	return value%2 == 1, nil
})

fmt.Printf("%v", err)

Output:

key bar is not allowed

kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}

result := OmitByKeys(kv, []string{"foo", "baz"})

fmt.Printf("%v", result)

Output:

map[bar:2]

kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}

result := OmitByValues(kv, []int{1, 3})

fmt.Printf("%v", result)

Output:

map[bar:2]

list := []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 _, item := range result {
	fmt.Printf("%v\n", item)
}

Output:

[-2 -1]
[0 2 4]
[1 3]

list := []int{-2, -1, 0, 1, 2, 3, 4}

_, err := PartitionByErr(list, func(x int) (string, error) {
	if x == 0 {
		return "", errors.New("zero is not allowed")
	}
	if x < 0 {
		return "negative", nil
	} else if x%2 == 0 {
		return "even", nil
	}
	return "odd", nil
})

fmt.Printf("%v", err)

Output:

zero is not allowed

kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}

result := PickBy(kv, func(key string, value int) bool {
	return value%2 == 1
})

fmt.Printf("%v %v %v", len(result), result["foo"], result["baz"])

Output:

2 1 3

kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}

_, err := PickByErr(kv, func(key string, value int) (bool, error) {
	if key == "bar" {
		return false, errors.New("key bar is not allowed")
	}
	return value%2 == 1, nil
})

fmt.Printf("%v", err)

Output:

key bar is not allowed

kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}

result := PickByKeys(kv, []string{"foo", "baz"})

fmt.Printf("%v %v %v", len(result), result["foo"], result["baz"])

Output:

2 1 3

kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}

result := PickByValues(kv, []int{1, 3})

fmt.Printf("%v %v %v", len(result), result["foo"], result["baz"])

Output:

2 1 3

list := []int{1, 2, 3, 4, 5}

result := Product(list)

fmt.Printf("%v", result)

Output:

120

list := []string{"foo", "bar"}

result := ProductBy(list, func(item string) int {
	return len(item)
})

fmt.Printf("%v", result)

Output:

9

list := []string{"foo", "bar", "baz"}

_, err := ProductByErr(list, func(item string) (int, error) {
	if item == "bar" {
		return 0, errors.New("bar is not allowed")
	}
	return len(item), nil
})

fmt.Printf("%v", err)

Output:

bar is not allowed

result1 := Range(4)
result2 := Range(-4)
result3 := RangeFrom(1, 5)
result4 := RangeFrom(1.0, 5)
result5 := RangeWithSteps(0, 20, 5)
result6 := RangeWithSteps[float32](-1.0, -4.0, -1.0)
result7 := RangeWithSteps(1, 4, -1)
result8 := Range(0)

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)
fmt.Printf("%v\n", result6)
fmt.Printf("%v\n", result7)
fmt.Printf("%v\n", result8)

Output:

[0 1 2 3]
[0 -1 -2 -3]
[1 2 3 4 5]
[1 2 3 4 5]
[0 5 10 15]
[-1 -2 -3]
[]
[]

list := []int64{1, 2, 3, 4}

result := Reduce(list, func(agg, item int64, index int) int64 {
	return agg + item
}, 0)

fmt.Printf("%v", result)

Output:

10

list := []int64{1, 2, 3, 4}

_, err := ReduceErr(list, func(agg, item int64, index int) (int64, error) {
	if item == 3 {
		return 0, errors.New("number 3 is not allowed")
	}
	return agg + item, nil
}, 0)

fmt.Printf("%v", err)

Output:

number 3 is not allowed

list := [][]int{{0, 1}, {2, 3}, {4, 5}}

result := ReduceRight(list, func(agg, item []int, index int) []int {
	return append(agg, item...)
}, []int{})

fmt.Printf("%v", result)

Output:

[4 5 2 3 0 1]

list := [][]int{{0, 1}, {2, 3}, {4, 5}}

_, err := ReduceRightErr(list, func(agg, item []int, index int) ([]int, error) {
	if index == 0 {
		return nil, errors.New("index 0 is not allowed")
	}
	return append(agg, item...), nil
}, []int{})

fmt.Printf("%v", err)

Output:

index 0 is not allowed

list := []int{0, 1, 2, 3, 4, 5}

result := Reject(list, func(x, _ int) bool {
	return x%2 == 0
})

fmt.Printf("%v", result)

Output:

[1 3 5]

list := []int64{0, 1, 2, 3, 4, 5}

result, err := RejectErr(list, func(x int64, index int) (bool, error) {
	if x == 3 {
		return false, errors.New("number 3 is not allowed")
	}
	return x%2 == 0, nil
})
fmt.Printf("%v, %v\n", result, err)

result, err = RejectErr([]int64{0, 1, 2, 4, 6}, func(x int64, index int) (bool, error) {
	return x%2 == 0, nil
})
fmt.Printf("%v, %v\n", result, err)

Output:

[], number 3 is not allowed
[1], <nil>

result := Repeat(2, foo{"a"})

fmt.Printf("%v", result)

Output:

[{a} {a}]

result := RepeatBy(5, func(i int) string {
	return strconv.FormatInt(int64(math.Pow(float64(i), 2)), 10)
})

fmt.Printf("%v", result)

Output:

[0 1 4 9 16]

result, err := RepeatByErr(5, func(i int) (string, error) {
	if i == 3 {
		return "", errors.New("index 3 is not allowed")
	}
	return fmt.Sprintf("item-%d", i), nil
})

fmt.Printf("%d %v", len(result), err)

Output:

0 index 3 is not allowed

list := []int{0, 1, 0, 1, 2, 3, 0}

result := Replace(list, 0, 42, 1)
fmt.Printf("%v\n", result)

result = Replace(list, -1, 42, 1)
fmt.Printf("%v\n", result)

result = Replace(list, 0, 42, 2)
fmt.Printf("%v\n", result)

result = Replace(list, 0, 42, -1)
fmt.Printf("%v\n", 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 Reverse[T any, Slice ~[]T](collection Slice) Slice

Reverse reverses a slice so that the first element becomes the last, the second element becomes the second to last, and so on. Play: https://go.dev/play/p/iv2e9jslfBM

Deprecated: use mutable.Reverse() instead.

list := []int{0, 1, 2, 3, 4, 5}

result := Reverse(list)

fmt.Printf("%v", result)

Output:

[5 4 3 2 1 0]

result1, chars1 := RuneLength("hellô"), len("hellô")
result2, chars2 := RuneLength("🤘"), len("🤘")

fmt.Printf("%v %v\n", result1, chars1)
fmt.Printf("%v %v\n", result2, chars2)

Output:

5 6
1 4

func Shuffle[T any, Slice ~[]T](collection Slice) Slice

Shuffle returns a slice of shuffled values. Uses the Fisher-Yates shuffle algorithm. Play: https://go.dev/play/p/ZTGG7OUCdnp

Deprecated: use mutable.Shuffle() instead.

list := []int{0, 1, 2, 3, 4, 5}

result := Shuffle(list)

fmt.Printf("%v", result)

list := []int{0, 1, 2, 3, 4, 5}

result := Slice(list, 1, 4)
fmt.Printf("%v\n", result)

result = Slice(list, 4, 1)
fmt.Printf("%v\n", result)

result = Slice(list, 4, 5)
fmt.Printf("%v\n", result)

Output:

[1 2 3]
[]
[4]

list := []string{"a", "aa", "aaa"}

result := SliceToMap(list, func(str string) (string, int) {
	return str, len(str)
})

fmt.Printf("%v", result)

Output:

map[a:1 aa:2 aaa:3]

list := []int{1, 2, 3, 4, 5, 6, 7, 8}

// Overlapping windows (step < size)
result1 := Sliding(list, 3, 1)
fmt.Printf("Overlapping: %v\n", result1)

// Non-overlapping windows (step == size, like Chunk)
result2 := Sliding(list, 3, 3)
fmt.Printf("Non-overlapping: %v\n", result2)

// Step > size (skipping elements)
result3 := Sliding(list, 2, 3)
fmt.Printf("With step: %v\n", result3)

Output:

Overlapping: [[1 2 3] [2 3 4] [3 4 5] [4 5 6] [5 6 7] [6 7 8]]
Non-overlapping: [[1 2 3] [4 5 6]]
With step: [[1 2] [4 5] [7 8]]

list := []int{0, 1, 2, 3, 4, 5}

result := Subset(list, 2, 3)

fmt.Printf("%v", result)

Output:

[2 3 4]

result1 := Substring("hello", 2, 3)
result2 := Substring("hello", -4, 3)
result3 := Substring("hello", -2, math.MaxUint)
result4 := Substring("🏠🐶🐱", 0, 2)
result5 := Substring("你好，世界", 0, 3)

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:

llo
ell
lo
🏠🐶
你好，

list := []int{1, 2, 3, 4, 5}

sum := Sum(list)

fmt.Printf("%v", sum)

Output:

15

list := []string{"foo", "bar"}

result := SumBy(list, func(item string) int {
	return len(item)
})

fmt.Printf("%v", result)

Output:

6

list := []string{"foo", "bar", "baz"}

_, err := SumByErr(list, func(item string) (int, error) {
	if item == "bar" {
		return 0, errors.New("bar is not allowed")
	}
	return len(item), nil
})

fmt.Printf("%v", err)

Output:

bar is not allowed

result1 := Switch[int, string](1).
	Case(1, "1").
	Case(2, "2").
	Default("3")

result2 := Switch[int, string](2).
	Case(1, "1").
	Case(2, "2").
	Default("3")

result3 := Switch[int, string](42).
	Case(1, "1").
	Case(2, "2").
	Default("3")

result4 := Switch[int, string](1).
	CaseF(1, func() string { return "1" }).
	CaseF(2, func() string { return "2" }).
	DefaultF(func() string { return "3" })

result5 := Switch[int, string](2).
	CaseF(1, func() string { return "1" }).
	CaseF(2, func() string { return "2" }).
	DefaultF(func() string { return "3" })

result6 := Switch[int, string](42).
	CaseF(1, func() string { return "1" }).
	CaseF(2, func() string { return "2" }).
	DefaultF(func() string { return "3" })

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)
fmt.Printf("%v\n", result6)

Output:

1
2
3
1
2
3

list := []int{0, 1, 2, 3, 4, 5}

result := Take(list, 3)

fmt.Printf("%v", result)

Output:

[0 1 2]

list := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

result := TakeFilter(
	list, 3, func(val, index int) bool {
		return val%2 == 0
	},
)

fmt.Printf("%v", result)

Output:

[2 4 6]

list := []int{0, 1, 2, 3, 4, 5}

result := TakeWhile(list, func(val int) bool {
	return val < 3
})

fmt.Printf("%v", result)

Output:

[0 1 2]

result := Ternary(true, "a", "b")

fmt.Printf("%v", result)

Output:

a

result := TernaryF(true, func() string { return "a" }, func() string { return "b" })

fmt.Printf("%v", result)

Output:

a

result := Times(3, func(i int) string {
	return strconv.FormatInt(int64(i), 10)
})

fmt.Printf("%v", result)

Output:

[0 1 2]

collection := []int{0, 1, 2, 0, 3, 0}

// Test with valid cutset
result := Trim(collection, []int{0})
fmt.Printf("Trim with cutset {0}: %v\n", result)

// Test with string collection
words := []string{"  hello  ", "world", "  "}
result2 := Trim(words, []string{" "})
fmt.Printf("Trim with string cutset: %v\n", result2)

// Test with no cutset elements
result3 := Trim(collection, []int{5})
fmt.Printf("Trim with cutset {5} (not present): %v\n", 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]

collection := []int{0, 1, 2, 0, 3, 0}

// Test with valid cutset
result := TrimLeft(collection, []int{0})
fmt.Printf("TrimLeft with cutset {0}: %v\n", result)

// Test with string collection
words := []string{"  hello  ", "world", "  "}
result2 := TrimLeft(words, []string{" "})
fmt.Printf("TrimLeft with string cutset: %v\n", result2)

// Test with no cutset elements
result3 := TrimLeft(collection, []int{5})
fmt.Printf("TrimLeft with cutset {5} (not present): %v\n", result3)

Output:

TrimLeft with cutset {0}: [1 2 0 3 0]
TrimLeft with string cutset: [  hello   world   ]
TrimLeft with cutset {5} (not present): [0 1 2 0 3 0]

collection := []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", result)

// Test with string collection
words := []string{"hello", "hello", "world"}
result2 := TrimPrefix(words, []string{"hello"})
fmt.Printf("TrimPrefix with string prefix: %v\n", result2)

// Test with prefix not present
result3 := TrimPrefix(collection, []int{5, 6})
fmt.Printf("TrimPrefix with prefix {5,6} (not present): %v\n", 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]

collection := []int{0, 1, 2, 0, 3, 0}

// Test with valid cutset
result := TrimRight(collection, []int{0})
fmt.Printf("TrimRight with cutset {0}: %v\n", result)

// Test with string collection
words := []string{"  hello  ", "world", "  "}
result2 := TrimRight(words, []string{" "})
fmt.Printf("TrimRight with string cutset: %v\n", result2)

// Test with no cutset elements
result3 := TrimRight(collection, []int{5})
fmt.Printf("TrimRight with cutset {5} (not present): %v\n", result3)

Output:

TrimRight with cutset {0}: [0 1 2 0 3]
TrimRight with string cutset: [  hello   world   ]
TrimRight with cutset {5} (not present): [0 1 2 0 3 0]

collection := []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", result)

// Test with string collection
words := []string{"hello", "world", "test"}
result2 := TrimSuffix(words, []string{"test"})
fmt.Printf("TrimSuffix with string suffix: %v\n", result2)

// Test with suffix not present
result3 := TrimSuffix(collection, []int{5, 6})
fmt.Printf("TrimSuffix with suffix {5,6} (not present): %v\n", 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]

ok1 := Try(func() error {
	return nil
})
ok2 := Try(func() error {
	return errors.New("my error")
})
ok3 := Try(func() error {
	panic("my error")
})

fmt.Printf("%v\n", ok1)
fmt.Printf("%v\n", ok2)
fmt.Printf("%v\n", ok3)

Output:

true
false
false

ok1 := Try1(func() error {
	return nil
})
ok2 := Try1(func() error {
	return errors.New("my error")
})
ok3 := Try1(func() error {
	panic("my error")
})

fmt.Printf("%v\n", ok1)
fmt.Printf("%v\n", ok2)
fmt.Printf("%v\n", ok3)

Output:

true
false
false

ok1 := Try2(func() (int, error) {
	return 42, nil
})
ok2 := Try2(func() (int, error) {
	return 42, errors.New("my error")
})
ok3 := Try2(func() (int, error) {
	panic("my error")
})

fmt.Printf("%v\n", ok1)
fmt.Printf("%v\n", ok2)
fmt.Printf("%v\n", ok3)

Output:

true
false
false

ok1 := Try3(func() (int, string, error) {
	return 42, "foobar", nil
})
ok2 := Try3(func() (int, string, error) {
	return 42, "foobar", errors.New("my error")
})
ok3 := Try3(func() (int, string, error) {
	panic("my error")
})

fmt.Printf("%v\n", ok1)
fmt.Printf("%v\n", ok2)
fmt.Printf("%v\n", ok3)

Output:

true
false
false

ok1 := Try4(func() (int, string, float64, error) {
	return 42, "foobar", 4.2, nil
})
ok2 := Try4(func() (int, string, float64, error) {
	return 42, "foobar", 4.2, errors.New("my error")
})
ok3 := Try4(func() (int, string, float64, error) {
	panic("my error")
})

fmt.Printf("%v\n", ok1)
fmt.Printf("%v\n", ok2)
fmt.Printf("%v\n", ok3)

Output:

true
false
false

ok1 := Try5(func() (int, string, float64, bool, error) {
	return 42, "foobar", 4.2, true, nil
})
ok2 := Try5(func() (int, string, float64, bool, error) {
	return 42, "foobar", 4.2, true, errors.New("my error")
})
ok3 := Try5(func() (int, string, float64, bool, error) {
	panic("my error")
})

fmt.Printf("%v\n", ok1)
fmt.Printf("%v\n", ok2)
fmt.Printf("%v\n", ok3)

Output:

true
false
false

ok1 := Try6(func() (int, string, float64, bool, foo, error) {
	return 42, "foobar", 4.2, true, foo{}, nil
})
ok2 := Try6(func() (int, string, float64, bool, foo, error) {
	return 42, "foobar", 4.2, true, foo{}, errors.New("my error")
})
ok3 := Try6(func() (int, string, float64, bool, foo, error) {
	panic("my error")
})

fmt.Printf("%v\n", ok1)
fmt.Printf("%v\n", ok2)
fmt.Printf("%v\n", ok3)

Output:

true
false
false

TryCatchWithErrorValue(
	func() error {
		panic("trigger an error")
	},
	func(err any) {
		fmt.Printf("catch: %s", err)
	},
)

Output:

catch: trigger an error

value1, ok1 := TryOr(func() (int, error) {
	return 42, nil
}, 21)
value2, ok2 := TryOr(func() (int, error) {
	return 42, errors.New("my error")
}, 21)
value3, ok3 := TryOr(func() (int, error) {
	panic("my error")
}, 21)

fmt.Printf("%v %v\n", value1, ok1)
fmt.Printf("%v %v\n", value2, ok2)
fmt.Printf("%v %v\n", value3, ok3)

Output:

42 true
21 false
21 false

value1, ok1 := TryOr1(func() (int, error) {
	return 42, nil
}, 21)
value2, ok2 := TryOr1(func() (int, error) {
	return 42, errors.New("my error")
}, 21)
value3, ok3 := TryOr1(func() (int, error) {
	panic("my error")
}, 21)

fmt.Printf("%v %v\n", value1, ok1)
fmt.Printf("%v %v\n", value2, ok2)
fmt.Printf("%v %v\n", value3, ok3)

Output:

42 true
21 false
21 false

value1, value2, ok3 := TryOr2(func() (int, string, error) {
	panic("my error")
}, 21, "hello")

fmt.Printf("%v %v %v\n", value1, value2, ok3)

Output:

21 hello false

value1, value2, value3, ok3 := TryOr3(func() (int, string, bool, error) {
	panic("my error")
}, 21, "hello", false)

fmt.Printf("%v %v %v %v\n", value1, value2, value3, ok3)

Output:

21 hello false false

value1, value2, value3, value4, ok3 := TryOr4(func() (int, string, bool, foo, error) {
	panic("my error")
}, 21, "hello", false, foo{bar: "bar"})

fmt.Printf("%v %v %v %v %v\n", value1, value2, value3, value4, ok3)

Output:

21 hello false {bar} false

value1, value2, value3, value4, value5, ok3 := TryOr5(func() (int, string, bool, foo, float64, error) {
	panic("my error")
}, 21, "hello", false, foo{bar: "bar"}, 4.2)

fmt.Printf("%v %v %v %v %v %v\n", value1, value2, value3, value4, value5, ok3)

Output:

21 hello false {bar} 4.2 false

value1, value2, value3, value4, value5, value6, ok3 := TryOr6(func() (int, string, bool, foo, float64, string, error) {
	panic("my error")
}, 21, "hello", false, foo{bar: "bar"}, 4.2, "world")

fmt.Printf("%v %v %v %v %v %v %v\n", value1, value2, value3, value4, value5, value6, ok3)

Output:

21 hello false {bar} 4.2 world false

err1, ok1 := TryWithErrorValue(func() error {
	return nil
})
err2, ok2 := TryWithErrorValue(func() error {
	return errors.New("my error")
})
err3, ok3 := TryWithErrorValue(func() error {
	panic("my error")
})

fmt.Printf("%v %v\n", err1, ok1)
fmt.Printf("%v %v\n", err2, ok2)
fmt.Printf("%v %v\n", err3, ok3)

Output:

<nil> true
my error false
my error false

list := []int{1, 2, 2, 1}

result := Uniq(list)

fmt.Printf("%v", result)

Output:

[1 2]

list := []int{0, 1, 2, 3, 4, 5}

result := UniqBy(list, func(i int) int {
	return i % 3
})

fmt.Printf("%v", result)

Output:

[0 1 2]

list := []int{0, 1, 2, 3, 4, 5}

_, err := UniqByErr(list, func(i int) (int, error) {
	if i == 3 {
		return 0, errors.New("number 3 is not allowed")
	}
	return i % 3, nil
})

fmt.Printf("%v", err)

Output:

number 3 is not allowed

kv := map[string]int{"foo": 1, "bar": 2}
kv2 := map[string]int{"bar": 3}

result := UniqKeys(kv, kv2)
sort.Strings(result)
fmt.Printf("%v", result)

Output:

[bar foo]

type User struct {
	Name string
	Age  int
}
users := []User{{Name: "Alex", Age: 10}, {Name: "Alex", Age: 12}, {Name: "Bob", Age: 11}, {Name: "Alice", Age: 20}}

result := UniqMap(users, func(u User, index int) string {
	return u.Name
})

sort.Strings(result)

fmt.Printf("%v", result)

Output:

[Alex Alice Bob]

kv := map[string]int{"foo": 1, "bar": 2}
kv2 := map[string]int{"baz": 2}

result := UniqValues(kv, kv2)

sort.Ints(result)
fmt.Printf("%v", result)

Output:

[1 2]

a, b := Unpack2(T2("hello", 2))
fmt.Printf("%v %v", a, b)

Output:

hello 2

a, b, c := Unpack3(T3("hello", 2, true))
fmt.Printf("%v %v %v", a, b, c)

Output:

hello 2 true

a, b, c, d := Unpack4(T4("hello", 2, true, foo{bar: "bar"}))
fmt.Printf("%v %v %v %v", a, b, c, d)

Output:

hello 2 true {bar}

a, b, c, d, e := Unpack5(T5("hello", 2, true, foo{bar: "bar"}, 4.2))
fmt.Printf("%v %v %v %v %v", a, b, c, d, e)

Output:

hello 2 true {bar} 4.2

a, b, c, d, e, f := Unpack6(T6("hello", 2, true, foo{bar: "bar"}, 4.2, "plop"))
fmt.Printf("%v %v %v %v %v %v", a, b, c, d, e, f)

Output:

hello 2 true {bar} 4.2 plop

a, b, c, d, e, f, g := Unpack7(T7("hello", 2, true, foo{bar: "bar"}, 4.2, "plop", false))
fmt.Printf("%v %v %v %v %v %v %v", a, b, c, d, e, f, g)

Output:

hello 2 true {bar} 4.2 plop false

a, b, c, d, e, f, g, h := Unpack8(T8("hello", 2, true, foo{bar: "bar"}, 4.2, "plop", false, 42))
fmt.Printf("%v %v %v %v %v %v %v %v", a, b, c, d, e, f, g, h)

Output:

hello 2 true {bar} 4.2 plop false 42

a, b, c, d, e, f, g, h, i := Unpack9(T9("hello", 2, true, foo{bar: "bar"}, 4.2, "plop", false, 42, "hello world"))
fmt.Printf("%v %v %v %v %v %v %v %v %v", a, b, c, d, e, f, g, h, i)

Output:

hello 2 true {bar} 4.2 plop false 42 hello world

a, b := Unzip2([]Tuple2[string, int]{T2("hello", 2)})
fmt.Printf("%v %v", a, b)

Output:

[hello] [2]

a, b, c := Unzip3([]Tuple3[string, int, bool]{T3("hello", 2, true)})
fmt.Printf("%v %v %v", a, b, c)

Output:

[hello] [2] [true]

a, b, c, d := Unzip4([]Tuple4[string, int, bool, foo]{T4("hello", 2, true, foo{bar: "bar"})})
fmt.Printf("%v %v %v %v", a, b, c, d)

Output:

[hello] [2] [true] [{bar}]

a, b, c, d, e := Unzip5([]Tuple5[string, int, bool, foo, float64]{T5("hello", 2, true, foo{bar: "bar"}, 4.2)})
fmt.Printf("%v %v %v %v %v", a, b, c, d, e)

Output:

[hello] [2] [true] [{bar}] [4.2]

a, b, c, d, e, f := Unzip6([]Tuple6[string, int, bool, foo, float64, string]{T6("hello", 2, true, foo{bar: "bar"}, 4.2, "plop")})
fmt.Printf("%v %v %v %v %v %v", a, b, c, d, e, f)

Output:

[hello] [2] [true] [{bar}] [4.2] [plop]

a, b, c, d, e, f, g := Unzip7([]Tuple7[string, int, bool, foo, float64, string, bool]{T7("hello", 2, true, foo{bar: "bar"}, 4.2, "plop", false)})
fmt.Printf("%v %v %v %v %v %v %v", a, b, c, d, e, f, g)

Output:

[hello] [2] [true] [{bar}] [4.2] [plop] [false]

a, b, c, d, e, f, g, h := Unzip8([]Tuple8[string, int, bool, foo, float64, string, bool, int]{T8("hello", 2, true, foo{bar: "bar"}, 4.2, "plop", false, 42)})
fmt.Printf("%v %v %v %v %v %v %v %v", a, b, c, d, e, f, g, h)

Output:

[hello] [2] [true] [{bar}] [4.2] [plop] [false] [42]

a, b, c, d, e, f, g, h, i := Unzip9([]Tuple9[string, int, bool, foo, float64, string, bool, int, string]{T9("hello", 2, true, foo{bar: "bar"}, 4.2, "plop", false, 42, "hello world")})
fmt.Printf("%v %v %v %v %v %v %v %v %v", a, b, c, d, e, f, g, h, i)

Output:

[hello] [2] [true] [{bar}] [4.2] [plop] [false] [42] [hello world]

a, b, err := UnzipByErr2([]string{"hello", "error", "world"}, func(str string) (string, int, error) {
	if str == "error" {
		return "", 0, errors.New("error string not allowed")
	}
	return str, len(str), nil
})
fmt.Printf("%v %v %v", len(a), len(b), err)

Output:

0 0 error string not allowed

a, b, c, err := UnzipByErr3([]string{"hello", "error", "world"}, func(str string) (string, int, bool, error) {
	if str == "error" {
		return "", 0, false, errors.New("error string not allowed")
	}
	return str, len(str), len(str) > 4, nil
})
fmt.Printf("%v %v %v %v", len(a), len(b), len(c), err)

Output:

0 0 0 error string not allowed

a, b, c, d, err := UnzipByErr4([]string{"hello", "error", "world"}, func(str string) (string, int, bool, float32, error) {
	if str == "error" {
		return "", 0, false, 0, errors.New("error string not allowed")
	}
	return str, len(str), len(str) > 4, float32(len(str)), nil
})
fmt.Printf("%v %v %v %v %v", len(a), len(b), len(c), len(d), err)

Output:

0 0 0 0 error string not allowed

a, b, c, d, e, err := UnzipByErr5([]string{"hello", "error", "world"}, func(str string) (string, int, bool, float32, float64, error) {
	if str == "error" {
		return "", 0, false, 0, 0, errors.New("error string not allowed")
	}
	return str, len(str), len(str) > 4, float32(len(str)), float64(len(str)), nil
})
fmt.Printf("%v %v %v %v %v %v", len(a), len(b), len(c), len(d), len(e), err)

Output:

0 0 0 0 0 error string not allowed

a, b, c, d, e, f, err := UnzipByErr6([]string{"hello", "error", "world"}, func(str string) (string, int, bool, float32, float64, int8, error) {
	if str == "error" {
		return "", 0, false, 0, 0, 0, errors.New("error string not allowed")
	}
	return str, len(str), len(str) > 4, float32(len(str)), float64(len(str)), int8(len(str)), nil
})
fmt.Printf("%v %v %v %v %v %v %v", len(a), len(b), len(c), len(d), len(e), len(f), err)

Output:

0 0 0 0 0 0 error string not allowed

a, b, c, d, e, f, g, err := UnzipByErr7([]string{"hello", "error", "world"}, func(str string) (string, int, bool, float32, float64, int8, int16, error) {
	if str == "error" {
		return "", 0, false, 0, 0, 0, 0, errors.New("error string not allowed")
	}
	return str, len(str), len(str) > 4, float32(len(str)), float64(len(str)), int8(len(str)), int16(len(str)), nil
})
fmt.Printf("%v %v %v %v %v %v %v %v", len(a), len(b), len(c), len(d), len(e), len(f), len(g), err)

Output:

0 0 0 0 0 0 0 error string not allowed

a, b, c, d, e, f, g, h, err := UnzipByErr8([]string{"hello", "error", "world"}, func(str string) (string, int, bool, float32, float64, int8, int16, int32, error) {
	if str == "error" {
		return "", 0, false, 0, 0, 0, 0, 0, errors.New("error string not allowed")
	}
	return str, len(str), len(str) > 4, float32(len(str)), float64(len(str)), int8(len(str)), int16(len(str)), int32(len(str)), nil
})
fmt.Printf("%v %v %v %v %v %v %v %v %v", len(a), len(b), len(c), len(d), len(e), len(f), len(g), len(h), err)

Output:

0 0 0 0 0 0 0 0 error string not allowed

a, b, c, d, e, f, g, h, i, err := UnzipByErr9([]string{"hello", "error", "world"}, func(str string) (string, int, bool, float32, float64, int8, int16, int32, int64, error) {
	if str == "error" {
		return "", 0, false, 0, 0, 0, 0, 0, 0, errors.New("error string not allowed")
	}
	return str, len(str), len(str) > 4, float32(len(str)), float64(len(str)), int8(len(str)), int16(len(str)), int32(len(str)), int64(len(str)), nil
})
fmt.Printf("%v %v %v %v %v %v %v %v %v %v", len(a), len(b), len(c), len(d), len(e), len(f), len(g), len(h), len(i), err)

Output:

0 0 0 0 0 0 0 0 0 error string not allowed

i := 42

err1 := Validate(i < 0, "expected %d < 0", i)
err2 := Validate(i > 0, "expected %d > 0", i)

fmt.Printf("%v\n%v", err1, err2)

Output:

expected 42 < 0
<nil>

kv := map[string]int{"foo": 1, "bar": 2}

result1 := ValueOr(kv, "foo", 42)
result2 := ValueOr(kv, "baz", 42)

fmt.Printf("%v %v", result1, result2)

Output:

1 42

kv := map[string]int{"foo": 1, "bar": 2}
kv2 := map[string]int{"baz": 3}

result := Values(kv, kv2)

sort.Ints(result)
fmt.Printf("%v", result)

Output:

[1 2 3]

list := []int{1, 2, 3, 4, 5}

result := Window(list, 3)

for _, item := range result {
	fmt.Printf("%v\n", item)
}

Output:

[1 2 3]
[2 3 4]
[3 4 5]

type User struct {
	ID   int
	Name string
}
// original users
users := []User{
	{ID: 1, Name: "Alice"},
	{ID: 2, Name: "Bob"},
	{ID: 3, Name: "Charlie"},
}

// exclude users with IDs 2 and 3
excludedIDs := []int{2, 3}

// extract function to get the user ID
extractID := func(user User) int {
	return user.ID
}

// filtering users
filteredUsers := WithoutBy(users, extractID, excludedIDs...)

// output the filtered users
fmt.Printf("%v", filteredUsers)

Output:

[{1 Alice}]

type User struct {
	ID   int
	Name string
}
// original users
users := []User{
	{ID: 1, Name: "Alice"},
	{ID: 2, Name: "Bob"},
	{ID: 3, Name: "Charlie"},
}

// exclude users with IDs 2 and 3
excludedIDs := []int{2, 3}

// extract function to get the user ID
extractID := func(user User) (int, error) {
	if user.ID == 2 {
		return 0, errors.New("user 2 extraction failed")
	}
	return user.ID, nil
}

// filtering users
filteredUsers, err := WithoutByErr(users, extractID, excludedIDs...)

// output the filtered users
fmt.Printf("%v %v", filteredUsers, err)

Output:

[] user 2 extraction failed

func WithoutEmpty[T comparable, Slice ~[]T](collection Slice) Slice

WithoutEmpty returns a slice excluding zero values.

Deprecated: Use lo.Compact instead.

result, err := ZipByErr2([]string{"a", "b", "c"}, []int{1, 2, 3}, func(a string, b int) (string, error) {
	if a == "b" {
		return "", errors.New("b is not allowed")
	}
	return fmt.Sprintf("%v-%v", a, b), nil
})
if err != nil {
	fmt.Printf("error: %v\n", err)
	return
}
for _, r := range result {
	fmt.Printf("%v\n", r)
}

Output:

error: b is not allowed

transaction := NewTransaction[int]().
	Then(
		func(state int) (int, error) {
			fmt.Println("step 1")
			return state + 10, nil
		},
		func(state int) int {
			fmt.Println("rollback 1")
			return state - 10
		},
	).
	Then(
		func(state int) (int, error) {
			fmt.Println("step 2")
			return state + 15, nil
		},
		func(state int) int {
			fmt.Println("rollback 2")
			return state - 15
		},
	).
	Then(
		func(state int) (int, error) {
			fmt.Println("step 3")

			if true {
				return state, errors.New("error")
			}

			return state + 42, nil
		},
		func(state int) int {
			fmt.Println("rollback 3")
			return state - 42
		},
	)

_, _ = transaction.Process(-5)

Output:

step 1
step 2
step 3
rollback 2
rollback 1

transaction := NewTransaction[int]().
	Then(
		func(state int) (int, error) {
			return state + 10, nil
		},
		func(state int) int {
			return state - 10
		},
	).
	Then(
		func(state int) (int, error) {
			return state, errors.New("error")
		},
		func(state int) int {
			return state - 15
		},
	).
	Then(
		func(state int) (int, error) {
			return state + 42, nil
		},
		func(state int) int {
			return state - 42
		},
	)

state, err := transaction.Process(-5)

fmt.Println(state)
fmt.Println(err)

Output:

-5
error

transaction := NewTransaction[int]().
	Then(
		func(state int) (int, error) {
			return state + 10, nil
		},
		func(state int) int {
			return state - 10
		},
	).
	Then(
		func(state int) (int, error) {
			return state + 15, nil
		},
		func(state int) int {
			return state - 15
		},
	).
	Then(
		func(state int) (int, error) {
			return state + 42, nil
		},
		func(state int) int {
			return state - 42
		},
	)

state, err := transaction.Process(-5)

fmt.Println(state)
fmt.Println(err)

Output:

62
<nil>