Slice - Core helpers

This page lists all operations on slices, available in the core package of lo.

Help improve this documentation

This documentation is still new and evolving. If you spot any mistakes, unclear explanations, or missing details, please open an issue.

Your feedback helps us improve!

Count
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Counts the number of elements in the collection that equal a given value.
lo.Count([]int{1, 5, 1}, 1) // 2
Similar:
countby countvalues every some
Prototype:
func Count[T comparable](collection []T, value T) int
CountBy
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Counts the number of elements for which the predicate is true.
lo.CountBy([]int{1, 5, 1}, func(i int) bool { return i < 4 }) // 2
Similar:
count countbyerr every filter find some
Prototype:
func CountBy[T any](collection []T, predicate func(item T) bool) int
CountValues
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Counts the number of occurrences of each element in the collection.
lo.CountValues([]int{1, 2, 2}) // map[int]int{1: 1, 2: 2}
Similar:
count countby countvaluesby groupby uniq
Prototype:
func CountValues[T comparable](collection []T) map[T]int

Counts the number of each transformed value (equivalent to Map followed by CountValues).

isEven := func(v int) bool {
    return v%2 == 0
}
lo.CountValuesBy([]int{1, 2, 2}, isEven)
// map[bool]int{false: 1, true: 2}

Similar:

countvalues groupby map mapvalues

Prototype:

func CountValuesBy[T any, U comparable](collection []T, transform func(item T) U) map[U]int

Slices the collection around the first instance of the separator, returning before, after, and whether it was found.

left, right, found := lo.Cut([]string{"a", "b", "c", "d", "e", "f", "g"}, []string{"b", "c", "d"})
// left: []string{"a"}
// right: []string{"e", "f", "g"}
// found: true

left, right, found = lo.Cut([]string{"a", "b", "c"}, []string{"z"})
// left: []string{"a", "b", "c"}
// right: []string{}
// found: false

Prototype:

func Cut[T comparable, Slice ~[]T](collection Slice, separator Slice) (before Slice, after Slice, found bool)

Returns the collection without the provided leading prefix and a boolean indicating whether it was present.

right, found := lo.CutPrefix([]string{"a", "b", "c", "d"}, []string{"a", "b", "c"})
// right: []string{"d"}
// found: true

right, found = lo.CutPrefix([]string{"a", "b", "c"}, []string{"b"})
// right: []string{"a", "b", "c"}
// found: false

Prototype:

func CutPrefix[T comparable, Slice ~[]T](collection Slice, separator Slice) (after Slice, found bool)

Returns the collection without the provided trailing suffix and a boolean indicating whether it was present.

left, found := lo.CutSuffix([]string{"a", "b", "c", "d", "e", "f", "g"}, []string{"f", "g"})
// left: []string{"a", "b", "c", "d", "e"}
// found: true

left, found = lo.CutSuffix([]string{"a", "b", "c"}, []string{"b"})
// left: []string{"a", "b", "c"}
// found: false

Prototype:

func CutSuffix[T comparable, Slice ~[]T](collection Slice, separator Slice) (before Slice, found bool)

Filter
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Iterates over a collection and returns a slice of all the elements the predicate function returns true for.
even := lo.Filter([]int{1, 2, 3, 4}, func(x int, index int) bool { return x%2 == 0 }) // []int{2, 4}
Similar:
filtererr filtermap filterreject reject rejectmap takefilter parallel› filter mutable› filter
Prototype:
func Filter[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) bool) Slice
IsSorted
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Checks if a slice is sorted in ascending order.
lo.IsSorted([]int{0, 1, 2, 3, 4, 5}) // true
Similar:
issortedby max min reverse
Prototype:
func IsSorted[T constraints.Ordered](collection []T) bool

Checks if a slice is sorted based on a key computed for each element.

ok := lo.IsSortedBy([]string{"a", "bb", "ccc"}, func(s string) int {
    return len(s)
})
// true

Similar:

issorted maxby minby reverse

Prototype:

func IsSortedBy[T any, K constraints.Ordered](collection []T, iteratee func(item T) K) bool

Replace
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns a copy of the slice with the first n non-overlapping instances of old replaced by new.
in := []int{0, 1, 0, 1, 2, 3, 0} lo.Replace(in, 0, 42, 2) // []int{42, 1, 42, 1, 2, 3, 0}
Similar:
fill replace replaceall slice splice
Prototype:
func Replace[T comparable, Slice ~[]T](collection Slice, old T, nEw T, n int) Slice
ReplaceAll
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns a copy of the slice with all non-overlapping instances of old replaced by new.
in := []int{0, 1, 0, 1, 2, 3, 0} lo.ReplaceAll(in, 0, 42) // []int{42, 1, 42, 1, 2, 3, 42}
Similar:
filtermap map replace
Prototype:
func ReplaceAll[T comparable, Slice ~[]T](collection Slice, old T, nEw T) Slice
Slice
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns a copy of a slice from start up to, but not including, end. Like slice[start:end], but does not panic on overflow.
in := []int{0, 1, 2, 3, 4} lo.Slice(in, 2, 6) // []int{2, 3, 4}
Similar:
drop dropright replace splice subset
Prototype:
func Slice[T any, Slice ~[]T](collection Slice, start int, end int) Slice

Inserts multiple elements at the specified index, with support for negative indices and automatic bounds handling. Negative indices count from the end (-1 means before last element), and indices beyond the slice length append to the end.

// Basic insertion at position 1
result := lo.Splice([]string{"a", "b"}, 1, "1", "2")
// result: []string{"a", "1", "2", "b"}

// Negative index: -1 means before the last element
result = lo.Splice([]string{"a", "b"}, -1, "1", "2")
// result: []string{"a", "1", "2", "b"}

// Index overflow: when index > len(slice), elements are appended
result = lo.Splice([]string{"a", "b"}, 42, "1", "2")
// result: []string{"a", "b", "1", "2"}

// Insert at beginning (index 0)
result = lo.Splice([]int{3, 4, 5}, 0, 1, 2)
// result: []int{1, 2, 3, 4, 5}

// Insert before last element with negative index
result = lo.Splice([]int{1, 2, 3}, -2, 99)
// result: []int{1, 99, 2, 3}

// No elements to insert returns original slice
result = lo.Splice([]string{"a", "b"}, 1)
// result: []string{"a", "b"}

Similar:

drop dropright insert slice

Prototype:

func Splice[T any, Slice ~[]T](collection Slice, i int, elements ...T) Slice

Subset
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns a copy of a slice from offset up to length elements. Like slice[start:start+length], but does not panic on overflow.
in := []int{0, 1, 2, 3, 4} lo.Subset(in, 2, 3) // []int{2, 3, 4}
Similar:
chunk drop dropright slice
Prototype:
func Subset[T any, Slice ~[]T](collection Slice, offset int, length uint) Slice

Removes all leading and trailing elements in the cutset from the collection.

result := lo.Trim([]int{0, 1, 2, 0, 3, 0}, []int{1, 0})
// []int{2, 0, 3}

result = lo.Trim([]string{"hello", "world", " "}, []string{" ", ""})
// []string{"hello", "world"}

Prototype:

func Trim[T comparable, Slice ~[]T](collection Slice, cutset Slice) Slice

Removes all leading elements found in the cutset from the collection.

result := lo.TrimLeft([]int{0, 1, 2, 0, 3, 0}, []int{1, 0})
// []int{2, 0, 3, 0}

result = lo.TrimLeft([]string{"hello", "world", " "}, []string{" ", ""})
// []string{"hello", "world", " "}

Similar:

trim trimprefix trimright trimsuffix

Prototype:

func TrimLeft[T comparable, Slice ~[]T](collection Slice, cutset Slice) Slice

Removes all leading occurrences of the given prefix from the collection.

result := lo.TrimPrefix([]int{1, 2, 1, 2, 3, 1, 2, 4}, []int{1, 2})
// []int{3, 1, 2, 4}

result = lo.TrimPrefix([]string{"hello", "world", "hello", "test"}, []string{"hello"})
// []string{"world", "hello", "test"}

Similar:

trim trimleft trimright trimsuffix

Prototype:

func TrimPrefix[T comparable, Slice ~[]T](collection Slice, prefix Slice) Slice

Removes all trailing elements found in the cutset from the collection.

result := lo.TrimRight([]int{0, 1, 2, 0, 3, 0}, []int{0, 3})
// []int{0, 1, 2}

result = lo.TrimRight([]string{"hello", "world", "  "}, []string{" ", ""})
// []string{"hello", "world", ""}

Similar:

trim trimleft trimprefix trimsuffix

Prototype:

func TrimRight[T comparable, Slice ~[]T](collection Slice, cutset Slice) Slice

Removes all trailing occurrences of the given suffix from the collection.

result := lo.TrimSuffix([]int{1, 2, 3, 1, 2, 4, 2, 4, 2, 4}, []int{2, 4})
// []int{1, 2, 3, 1}

result = lo.TrimSuffix([]string{"hello", "world", "hello", "test"}, []string{"test"})
// []string{"hello", "world", "hello"}

Similar:

trim trimleft trimprefix trimright

Prototype:

func TrimSuffix[T comparable, Slice ~[]T](collection Slice, suffix Slice) Slice

Counts the number of elements for which the predicate is true. Returns an error if the predicate function fails, stopping iteration immediately.

count, err := lo.CountByErr([]int{1, 5, 1}, func(i int) (bool, error) {
    if i == 5 {
        return false, fmt.Errorf("5 not allowed")
    }
    return i < 4, nil
})
// 0, error("5 not allowed")

count, err := lo.CountByErr([]int{1, 5, 1}, func(i int) (bool, error) {
    return i < 4, nil
})
// 2, nil

Similar:

count countby everybyerr somebyerr

Prototype:

func CountByErr[T any](collection []T, predicate func(item T) (bool, error)) (int, error)

Iterates over a collection and returns a slice of all the elements the predicate function returns true for. If the predicate returns an error, iteration stops immediately and returns the error.

even, err := lo.FilterErr([]int{1, 2, 3, 4}, func(x int, index int) (bool, error) {
    if x == 3 {
        return false, errors.New("number 3 is not allowed")
    }
    return x%2 == 0, nil
})
// []int(nil), error("number 3 is not allowed")

even, err := lo.FilterErr([]int{1, 2, 3, 4}, func(x int, index int) (bool, error) {
    return x%2 == 0, nil
})
// []int{2, 4}, nil

Similar:

filter filtermap filterreject reject

Prototype:

func FilterErr[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) (bool, error)) (Slice, error)

Transforms each element in a slice to a new type using a function. Takes both the element and its index, making it useful for transformations that need positional context.

// Basic type transformation
transformed := lo.Map([]int64{1, 2, 3, 4}, func(x int64, index int) string {
    return strconv.FormatInt(x, 10)
})
// transformed: []string{"1", "2", "3", "4"}

// Transforming structs
type Person struct {
    FirstName string
    LastName  string
    Age       int
}

people := []Person{
    {FirstName: "John", LastName: "Doe", Age: 25},
    {FirstName: "Jane", LastName: "Smith", Age: 30},
}

fullNames := lo.Map(people, func(p Person, index int) string {
    return fmt.Sprintf("%s %s", p.FirstName, p.LastName)
})
// fullNames: []string{"John Doe", "Jane Smith"}

Prototype:

func Map[T any, R any](collection []T, transform func(item T, index int) R) []R

Transforms each element in a slice to a new type using a function that can return an error. Stops iteration immediately when an error is encountered.

// Error case - stops on first error
result, err := lo.MapErr([]int{1, 2, 3, 4}, func(x int, _ int) (string, error) {
    if x == 3 {
        return "", fmt.Errorf("number 3 is not allowed")
    }
    return strconv.Itoa(x), nil
})
// []string(nil), error("number 3 is not allowed")

// Success case
result, err := lo.MapErr([]int{1, 2, 3, 4}, func(x int, _ int) (string, error) {
    return strconv.Itoa(x), nil
})
// []string{"1", "2", "3", "4"}, nil

Prototype:

func MapErr[T any, R any](collection []T, transform func(item T, index int) (R, error)) ([]R, error)

Manipulates a slice and transforms it to a slice of another type with unique values.

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}}

names := lo.UniqMap(users, func(u User, index int) string {
    return u.Name
})
// []string{"Alex", "Bob", "Alice"}

Prototype:

func UniqMap[T any, R comparable](collection []T, transform func(item T, index int) R) []R

FilterMap
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns a slice obtained after both filtering and mapping using the given callback function.

The callback function should return two values: the result of the mapping operation and whether the result element should be included or not.
matching := lo.FilterMap([]string{"cpu", "gpu", "mouse", "keyboard"}, func(x string, _ int) (string, bool) { if strings.HasSuffix(x, "pu") { return "xpu", true } return "", false }) // []string{"xpu", "xpu"}
Similar:
filter filtermaptoslice map rejectmap takefilter uniqmap parallel› filtermap
Prototype:
func FilterMap[T any, R any](collection []T, callback func(item T, index int) (R, bool)) []R
FlatMap
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Manipulates a slice and transforms and flattens it to a slice of another type. The transform function can either return a slice or a nil, and in the nil case no value is added to the final slice.
out := lo.FlatMap([]int64{0, 1, 2}, func(x int64, _ int) []string { return []string{strconv.FormatInt(x, 10), strconv.FormatInt(x, 10)} }) // []string{"0", "0", "1", "1", "2", "2"}
Similar:
filtermap flatmaperr map maperr parallel› map mutable› map
Prototype:
func FlatMap[T any, R any](collection []T, transform func(item T, index int) []R) []R

Manipulates a slice and transforms and flattens it to a slice of another type using a function that can return an error. Stops iteration immediately when an error is encountered.

// Error case - stops on first error
result, err := lo.FlatMapErr([]int64{0, 1, 2, 3}, func(x int64, _ int) ([]string, error) {
    if x == 2 {
        return nil, fmt.Errorf("number 2 is not allowed")
    }
    return []string{strconv.FormatInt(x, 10), strconv.FormatInt(x, 10)}, nil
})
// []string(nil), error("number 2 is not allowed")

// Success case
result, err := lo.FlatMapErr([]int64{0, 1, 2}, func(x int64, _ int) ([]string, error) {
    return []string{strconv.FormatInt(x, 10), strconv.FormatInt(x, 10)}, nil
})
// []string{"0", "0", "1", "1", "2", "2"}, nil

Similar:

filtermap flatmap map maperr

Prototype:

func FlatMapErr[T any, R any](collection []T, transform func(item T, index int) ([]R, error)) ([]R, error)

Reduce
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Reduces a collection to a single value by accumulating results of an accumulator function. Each call receives the previous result value.
sum := lo.Reduce([]int{1, 2, 3, 4}, func(agg int, item int, _ int) int { return agg + item }, 0) // 10
Similar:
mean meanby product productby reduceerr reduceright sum sumby sumbyerr
Prototype:
func Reduce[T any, R any](collection []T, accumulator func(agg R, item T, index int) R, initial R) R

Reduces a collection to a single value by accumulating results of an accumulator function that can return an error. Stops iteration immediately when an error is encountered.

// Error case - stops on first error
result, err := lo.ReduceErr([]int{1, 2, 3, 4}, func(agg int, item int, _ int) (int, error) {
    if item == 3 {
        return 0, fmt.Errorf("number 3 is not allowed")
    }
    return agg + item, nil
}, 0)
// 0, error("number 3 is not allowed")

// Success case
result, err := lo.ReduceErr([]int{1, 2, 3, 4}, func(agg int, item int, _ int) (int, error) {
    return agg + item, nil
}, 0)
// 10, nil

Similar:

reduce reduceright sum sumby sumbyerr

Prototype:

func ReduceErr[T any, R any](collection []T, accumulator func(agg R, item T, index int) (R, error), initial R) (R, error)

Like Reduce except it iterates from right to left and accumulates into a single value.

result := lo.ReduceRight([][]int{{0, 1}, {2, 3}, {4, 5}}, func(agg []int, item []int, _ int) []int {
    return append(agg, item...)
}, []int{})
// []int{4, 5, 2, 3, 0, 1}

Prototype:

func ReduceRight[T any, R any](collection []T, accumulator func(agg R, item T, index int) R, initial R) R

Like Reduce but iterates from right to left and accumulates into a single value using an accumulator function that can return an error. Stops iteration immediately when an error is encountered.

// Error case - stops on first error (from right to left)
result, err := lo.ReduceRightErr([][]int{{0, 1}, {2, 3}, {4, 5}}, func(agg []int, item []int, _ int) ([]int, error) {
    if len(item) > 0 && item[0] == 4 {
        return nil, fmt.Errorf("element starting with 4 is not allowed")
    }
    return append(agg, item...), nil
}, []int{})
// []int(nil), error("element starting with 4 is not allowed")

// Success case
result, err := lo.ReduceRightErr([]int{1, 2, 3, 4}, func(agg int, item int, _ int) (int, error) {
    return agg + item, nil
}, 0)
// 10, nil

Similar:

reduce reduceerr reduceright

Prototype:

func ReduceRightErr[T any, R any](collection []T, accumulator func(agg R, item T, index int) (R, error), initial R) (R, error)

ForEach
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Iterates over elements of a collection and invokes the callback for each element.
lo.ForEach([]string{"hello", "world"}, func(x string, _ int) { println(x) }) // prints "hello\nworld\n"
Similar:
foreachwhile map times parallel› foreach
Prototype:
func ForEach[T any](collection []T, callback func(item T, index int))

Iterates over elements of a collection and invokes the predicate for each element until false is returned.

numbers := []int64{1, 2, -9223372036854775808, 4}
lo.ForEachWhile(numbers, func(x int64, _ int) bool {
    if x < 0 {
        return false
    }
    fmt.Println(x)
    return true
})
// Output:
// 1
// 2

Prototype:

func ForEachWhile[T any](collection []T, predicate func(item T, index int) bool)

Times
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Invokes the predicate n times, returning a slice of results. The predicate receives the index on each call.
lo.Times(3, func(i int) string { return strconv.Itoa(i) }) // []string{"0", "1", "2"}
Similar:
foreach repeat repeatby parallel› times
Prototype:
func Times[T any](count int, iteratee func(index int) T) []T
Uniq
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns a duplicate-free version of a slice, keeping only the first occurrence of each value. Order is preserved.
lo.Uniq([]int{1, 2, 2, 1}) // []int{1, 2}
Similar:
isuniq isuniqby uniqby uniqkeys uniqmap uniqvalues
Prototype:
func Uniq[T comparable, Slice ~[]T](collection Slice) Slice
UniqBy
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns a duplicate-free version of a slice based on a computed key. Keeps only the first element for each unique key.
lo.UniqBy( []int{0, 1, 2, 3, 4, 5}, func(i int) int { return i % 3 }, ) // []int{0, 1, 2}
Similar:
isuniq isuniqby partitionby uniq uniqbyerr uniqmap
Prototype:
func UniqBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) Slice

Returns a duplicate-free version of a slice based on a computed key using an iteratee that can return an error. Stops iteration immediately when an error is encountered. Keeps only the first element for each unique key.

// Error case - stops on first error
result, err := lo.UniqByErr([]int{0, 1, 2, 3, 4, 5}, func(i int) (int, error) {
    if i == 3 {
        return 0, fmt.Errorf("number 3 is not allowed")
    }
    return i % 3, nil
})
// []int(nil), error("number 3 is not allowed")

// Success case
result, err := lo.UniqByErr([]int{0, 1, 2, 3, 4, 5}, func(i int) (int, error) {
    return i % 3, nil
})
// []int{0, 1, 2}, nil

Prototype:

func UniqByErr[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) (U, error)) (Slice, error)

IsUniq
slicecore
🧩 Source 📚 GoDoc
Returns true if all elements in the slice are unique, false otherwise. Returns true for nil and empty slices.
lo.IsUniq([]int{1, 2, 3}) // true lo.IsUniq([]int{1, 2, 1}) // false
Similar:
findduplicates finduniques isuniqby uniq
Prototype:
func IsUniq[T comparable, Slice ~[]T](collection Slice) bool

Returns true if all elements in the slice are unique based on a custom criterion. The iteratee is invoked for each element to generate the key by which uniqueness is computed. Returns true for nil and empty slices.

type User struct {
    ID   int
    Name string
}

lo.IsUniqBy([]User{{ID: 1}, {ID: 2}, {ID: 3}}, func(u User) int {
    return u.ID
})
// true

lo.IsUniqBy([]User{{ID: 1}, {ID: 2}, {ID: 1}}, func(u User) int {
    return u.ID
})
// false

Prototype:

func IsUniqBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) bool

Groups elements by a key computed from each element. The result is a map keyed by the group key with slices of original elements.

groups := lo.GroupBy(
    []int{0, 1, 2, 3, 4, 5},
    func(i int) int {
        return i % 3
    },
)
// map[int][]int{0: {0, 3}, 1: {1, 4}, 2: {2, 5}}

Prototype:

func GroupBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) map[U]Slice

Groups elements by a key computed from each element using an iteratee that can return an error. Stops iteration immediately when an error is encountered. The result is a map keyed by the group key with slices of original elements.

// Error case - stops on first error
result, err := lo.GroupByErr([]int{0, 1, 2, 3, 4, 5}, func(i int) (int, error) {
    if i == 3 {
        return 0, fmt.Errorf("number 3 is not allowed")
    }
    return i % 3, nil
})
// map[int][]int(nil), error("number 3 is not allowed")

// Success case
result, err := lo.GroupByErr([]int{0, 1, 2, 3, 4, 5}, func(i int) (int, error) {
    return i % 3, nil
})
// map[int][]int{0: {0, 3}, 1: {1, 4}, 2: {2, 5}}, nil

Prototype:

func GroupByErr[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) (U, error)) (map[U]Slice, error)

Filters elements and takes the first n elements that match the predicate. Equivalent to calling Take(Filter(...)), but more efficient as it stops after finding n matches.

lo.TakeFilter([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 3, func(val int, index int) bool {
    return val%2 == 0
})
// []int{2, 4, 6}

lo.TakeFilter([]string{"a", "aa", "aaa", "aaaa"}, 2, func(val string, index int) bool {
    return len(val) > 1
})
// []string{"aa", "aaa"}

Prototype:

func TakeFilter[T any, Slice ~[]T](collection Slice, n int, predicate func(item T, index int) bool) Slice

Groups items by a key computed from each element and maps each element to a value.

groups := lo.GroupByMap(
    []int{0, 1, 2, 3, 4, 5},
    func(i int) (int, int) {
        return i % 3, i * 2
    },
)
// map[int][]int{0:{0,6}, 1:{2,8}, 2:{4,10}}

Prototype:

func GroupByMap[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K][]V

Groups items by a key computed from each element and maps each element to a value using a transform function that can return an error. Stops iteration immediately when an error is encountered.

// Error case - stops on first error
result, err := lo.GroupByMapErr([]int{0, 1, 2, 3, 4, 5}, func(i int) (int, int, error) {
    if i == 3 {
        return 0, 0, fmt.Errorf("number 3 is not allowed")
    }
    return i % 3, i * 2, nil
})
// map[int][]int(nil), error("number 3 is not allowed")

// Success case
result, err := lo.GroupByMapErr([]int{0, 1, 2, 3, 4, 5}, func(i int) (int, int, error) {
    return i % 3, i * 2, nil
})
// map[int][]int{0: {0, 6}, 1: {2, 8}, 2: {4, 10}}, nil

Prototype:

func GroupByMapErr[T any, K comparable, V any](collection []T, transform func(item T) (K, V, error)) (map[K][]V, error)

Chunk
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Splits a slice into chunks of the given size. The final chunk may be smaller.
lo.Chunk([]int{0, 1, 2, 3, 4, 5}, 2) // [][]int{{0, 1}, {2, 3}, {4, 5}} lo.Chunk([]int{0, 1, 2, 3, 4, 5, 6}, 2) // [][]int{{0, 1}, {2, 3}, {4, 5}, {6}}
Note

lo.ChunkString and lo.Chunk functions behave inconsistently for empty input: lo.ChunkString("", n) returns [""] instead of [].

See https://github.com/samber/lo/issues/788
Similar:
chunkentries drop flatten partitionby slice sliding window
Prototype:
func Chunk[T any, Slice ~[]T](collection Slice, size int) []Slice
Window
slicecore
🧩 Source 📚 GoDoc
Creates a slice of sliding windows of a given size. Each window overlaps with the previous one by size-1 elements. This is equivalent to Sliding(collection, size, 1).
lo.Window([]int{1, 2, 3, 4, 5}, 3) // [][]int{{1, 2, 3}, {2, 3, 4}, {3, 4, 5}} lo.Window([]float64{20, 22, 21, 23, 24}, 3) // [][]float64{{20, 22, 21}, {22, 21, 23}, {21, 23, 24}}
Similar:
chunk flatten partitionby sliding iter› window
Prototype:
func Window[T any, Slice ~[]T](collection Slice, size int) []Slice
PartitionBy
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Partitions a slice into groups determined by a key computed from each element, preserving original order.

Similar:
chunk groupby groupbyerr groupbymap keyby partitionbyerr
Prototype:
func PartitionBy[T any, K comparable, Slice ~[]T](collection Slice, iteratee func(item T) K) []Slice

Creates a slice of sliding windows of a given size with a given step. If step is equal to size, windows don't overlap (similar to Chunk). If step is less than size, windows overlap.

// Overlapping windows (step < size)
lo.Sliding([]int{1, 2, 3, 4, 5, 6}, 3, 1)
// [][]int{{1, 2, 3}, {2, 3, 4}, {3, 4, 5}, {4, 5, 6}}

// Non-overlapping windows (step == size, like Chunk)
lo.Sliding([]int{1, 2, 3, 4, 5, 6}, 3, 3)
// [][]int{{1, 2, 3}, {4, 5, 6}}

// Step > size (skipping elements)
lo.Sliding([]int{1, 2, 3, 4, 5, 6, 7, 8}, 2, 3)
// [][]int{{1, 2}, {4, 5}, {7, 8}}

Prototype:

func Sliding[T any, Slice ~[]T](collection Slice, size, step int) []Slice

Partitions a slice into groups determined by a key computed from each element using an iteratee that can return an error. Stops iteration immediately when an error is encountered. Preserves original order.

// Error case - stops on first error
result, err := lo.PartitionByErr([]int{-2, -1, 0, 1, 2, 3}, func(x int) (string, error) {
    if x == 0 {
        return "", fmt.Errorf("zero is not allowed")
    }
    if x < 0 {
        return "negative", nil
    } else if x%2 == 0 {
        return "even", nil
    }
    return "odd", nil
})
// [][]int(nil), error("zero is not allowed")

// Success case
result, err := lo.PartitionByErr([]int{-2, -1, 0, 1, 2}, func(x int) (string, error) {
    if x < 0 {
        return "negative", nil
    } else if x%2 == 0 {
        return "even", nil
    }
    return "odd", nil
})
// [][]int{{-2, -1}, {0, 2}, {1}}, nil

Prototype:

func PartitionByErr[T any, K comparable, Slice ~[]T](collection Slice, iteratee func(item T) (K, error)) ([]Slice, error)

Returns a shallow copy of the collection.

in := []int{1, 2, 3, 4, 5}
cloned := lo.Clone(in)
// Verify it's a different slice by checking that modifying one doesn't affect the other
in[0] = 99
// cloned is []int{1, 2, 3, 4, 5}

Similar:

fill repeat

Prototype:

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

Concat
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns a new slice containing all the elements in collections. Concat conserves the order of the elements.
list1 := []int{0, 1} list2 := []int{2, 3, 4, 5} combined := lo.Concat(list1, list2) // []int{0, 1, 2, 3, 4, 5}
Similar:
flatten union iter› concat
Prototype:
func Concat[T any, Slice ~[]T](collections ...Slice) Slice

Flattens a slice of slices by one level.

flat := lo.Flatten([][]int{{0, 1}, {2, 3, 4, 5}})
// []int{0, 1, 2, 3, 4, 5}

Similar:

chunk interleave slice

Prototype:

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

Drop
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Drops n elements from the beginning of a slice.
lo.Drop([]int{0, 1, 2, 3, 4, 5}, 2) // []int{2, 3, 4, 5}
Similar:
cutprefix dropbyindex dropright droprightwhile dropwhile slice take takewhile
Prototype:
func Drop[T any, Slice ~[]T](collection Slice, n int) Slice

Round-robins input slices by index, appending values sequentially into the result.

lo.Interleave([]int{1, 4, 7}, []int{2, 5, 8}, []int{3, 6, 9})
// []int{1, 2, 3, 4, 5, 6, 7, 8, 9}

lo.Interleave([]int{1}, []int{2, 5, 8}, []int{3, 6}, []int{4, 7, 9, 10})
// []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Similar:

chunk flatten shuffle slice

Prototype:

func Interleave[T any, Slice ~[]T](collections ...Slice) Slice

Takes the first n elements from a slice.

lo.Take([]int{0, 1, 2, 3, 4, 5}, 3)
// []int{0, 1, 2}

lo.Take([]int{0, 1, 2}, 5)
// []int{0, 1, 2}

Prototype:

func Take[T any, Slice ~[]T](collection Slice, n int) Slice

DropRight
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Drops n elements from the end of a slice.
lo.DropRight([]int{0, 1, 2, 3, 4, 5}, 2) // []int{0, 1, 2, 3}
Similar:
cutsuffix drop dropbyindex droprightwhile dropwhile slice trimright
Prototype:
func DropRight[T any, Slice ~[]T](collection Slice, n int) Slice
Shuffle
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns a slice of shuffled values (Fisher–Yates). Deprecated: use mutable.Shuffle.

Similar:
sample sampleby samples samplesby mutable› shuffle
Prototype:
func Shuffle[T any, Slice ~[]T](collection Slice) Slice

Drops elements from the beginning while the predicate returns true.

lo.DropWhile([]string{"a", "aa", "aaa", "aa", "aa"}, func(val string) bool {
    return len(val) <= 2
})
// []string{"aaa", "aa", "aa"}

Prototype:

func DropWhile[T any, Slice ~[]T](collection Slice, predicate func(item T) bool) Slice

Reverse
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Reverses a slice in place. Deprecated: use mutable.Reverse.

Similar:
drop dropright flatten slice mutable› reverse
Prototype:
func Reverse[T any, Slice ~[]T](collection Slice) Slice

Takes elements from the beginning while the predicate returns true.

lo.TakeWhile([]int{0, 1, 2, 3, 4, 5}, func(val int) bool {
    return val < 3
})
// []int{0, 1, 2}

lo.TakeWhile([]string{"a", "aa", "aaa", "aa"}, func(val string) bool {
    return len(val) <= 2
})
// []string{"a", "aa"}

Prototype:

func TakeWhile[T any, Slice ~[]T](collection Slice, predicate func(item T) bool) Slice

Drops elements from the end while the predicate returns true.

lo.DropRightWhile([]string{"a", "aa", "aaa", "aa", "aa"}, func(val string) bool {
    return len(val) <= 2
})
// []string{"a", "aa", "aaa"}

Prototype:

func DropRightWhile[T any, Slice ~[]T](collection Slice, predicate func(item T) bool) Slice

Fill
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Fills a slice with clones of the provided initial value.
type foo struct{ bar string } func (f foo) Clone() foo { return foo{f.bar} } lo.Fill([]foo{{"a"}, {"a"}}, foo{"b"}) // []foo{{"b"}, {"b"}}
Similar:
chunk chunkentries drop dropright droprightwhile dropwhile flatten interleave repeat reverse sample shuffle slice
Prototype:
func Fill[T Clonable[T], Slice ~[]T](collection Slice, initial T) Slice
DropByIndex
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Drops elements from a slice by index. Negative indexes count from the end.
lo.DropByIndex([]int{0, 1, 2, 3, 4, 5}, 2, 4, -1) // []int{0, 1, 3}
Similar:
drop dropright droprightwhile dropwhile slice splice withoutnth
Prototype:
func DropByIndex[T any, Slice ~[]T](collection Slice, indexes ...int) Slice
Repeat
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Builds a slice with N copies of initial value.
lo.Repeat(5, "42") // []string{"42", "42", "42", "42", "42"}
Similar:
repeatby times
Prototype:
func Repeat[T any](count int, initial T) []T

Builds a slice by calling the callback N times with the current index.

lo.RepeatBy(5, func(i int) string {
    return strconv.Itoa(i * i)
})
// []string{"0", "1", "4", "9", "16"}

Variant:

repeatbyerr

Similar:

repeat times

Prototype:

func RepeatBy[T any](count int, callback func(index int) T) []T

Builds a slice by calling the callback N times with the current index. The callback can return an error to stop iteration immediately.

result, err := lo.RepeatByErr(5, func(i int) (int, error) {
    return i * i, nil
})
// []int{0, 1, 4, 9, 16}, <nil>

Example with error:

result, err := lo.RepeatByErr(5, func(i int) (int, error) {
    if i == 3 {
        return 0, fmt.Errorf("number 3 is not allowed")
    }
    return i * i, nil
})
// []int(nil), error("number 3 is not allowed")

Similar:

repeat repeatby times

Prototype:

func RepeatByErr[T any](count int, callback func(index int) (T, error)) ([]T, error)

Transforms a slice to a map using a pivot callback to compute keys.

m := lo.KeyBy(
    []string{"a", "aa", "aaa"},
    func(str string) int {
        return len(str)
    },
)
// map[int]string{1: "a", 2: "aa", 3: "aaa"}

Prototype:

func KeyBy[K comparable, V any](collection []V, iteratee func(item V) K) map[K]V

Transforms a slice to a map using a pivot callback to compute keys. Stops iteration immediately when an error is encountered.

// Error case - stops on first error
result, err := lo.KeyByErr([]string{"a", "aa", "aaa", ""}, func(str string) (int, error) {
    if str == "" {
        return 0, fmt.Errorf("empty string not allowed")
    }
    return len(str), nil
})
// map[int]string(nil), error("empty string not allowed")

// Success case
result, err := lo.KeyByErr([]string{"a", "aa", "aaa"}, func(str string) (int, error) {
    if str == "" {
        return 0, fmt.Errorf("empty string not allowed")
    }
    return len(str), nil
})
// map[int]string{1: "a", 2: "aa", 3: "aaa"}, nil

Prototype:

func KeyByErr[K comparable, V any](collection []V, iteratee func(item V) (K, error)) (map[K]V, error)

Builds a map from a slice using a transform function that yields key/value pairs for each item. Perfect for converting collections to lookup maps.

Associate

Transforms each element into a key-value pair. Later items with the same key will overwrite earlier ones.

type foo struct {
    baz string
    bar int
}

in := []*foo{{baz: "apple", bar: 1}, {baz: "banana", bar: 2}}

m := lo.Associate(in, func(f *foo) (string, int) {
    return f.baz, f.bar
})
// m: map[string]int{"apple": 1, "banana": 2}

AssociateI

Variant that includes the element index in the transform function, useful when you need the position in the original slice.

type User struct {
    Name string
    Age  int
}

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

result := lo.AssociateI(users, func(user User, index int) (string, int) {
    return fmt.Sprintf("%s-%d", user.Name, index), user.Age
})
// result: map[string]int{"Alice-0": 25, "Bob-1": 30}

SliceToMap

Alias for Associate - provides the same functionality with a more explicit name.

products := []string{"apple", "banana", "cherry"}

result := lo.SliceToMap(products, func(product string) (string, int) {
    return product, len(product)
})
// result: map[string]int{"apple": 5, "banana": 6, "cherry": 6}

Variant:

associatei slicetomap

Prototypes:

func Associate[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K]V
func AssociateI[T any, K comparable, V any](collection []T, transform func(item T, index int) (K, V)) map[K]V
func SliceToMap[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K]V

Alias of Associate: transforms a slice into a map using a key/value transform function.

type foo struct {
    baz string
    bar int
}

in := []*foo{{baz: "apple", bar: 1}, {baz: "banana", bar: 2}}

m := lo.SliceToMap(in, func(f *foo) (string, int) {
    return f.baz, f.bar
})
// map[string]int{"apple": 1, "banana": 2}

Variant:

associate associatei

Prototypes:

func SliceToMap[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K]V
func Associate[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K]V
func AssociateI[T any, K comparable, V any](collection []T, transform func(item T, index int) (K, V)) map[K]V

Transforms elements to key/value pairs and includes them in the result only when the transform's boolean is true.

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

m := lo.FilterSliceToMap(list, func(str string) (string, int, bool) {
    return str, len(str), len(str) > 1
})
// map[string]int{"aa": 2, "aaa": 3}

Similar:

filter groupby keyby map

Prototype:

func FilterSliceToMap[T any, K comparable, V any](collection []T, transform func(item T) (K, V, bool)) map[K]V

Returns the elements for which the predicate returns false (opposite of Filter).

lo.Reject(
    []int{1, 2, 3, 4},
    func(x int, _ int) bool {
        return x%2 == 0
    },
)
// []int{1, 3}

Prototype:

func Reject[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) bool) Slice

The opposite of FilterErr. Returns the elements for which the predicate returns false. If the predicate returns an error, iteration stops immediately and returns the error.

odd, err := lo.RejectErr([]int{1, 2, 3, 4}, func(x int, index int) (bool, error) {
    if x == 3 {
        return false, errors.New("number 3 is not allowed")
    }
    return x%2 == 0, nil
})
// []int(nil), error("number 3 is not allowed")

odd, err := lo.RejectErr([]int{1, 2, 3, 4}, func(x int, index int) (bool, error) {
    return x%2 == 0, nil
})
// []int{1, 3}, nil

Similar:

filtererr filterreject reject rejectmap

Prototype:

func RejectErr[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) (bool, error)) (Slice, error)

Compact
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns a slice of all non-zero elements.
lo.Compact([]string{"", "foo", "", "bar", ""}) // []string{"foo", "bar"}
Similar:
filter reject without withoutempty
Prototype:
func Compact[T comparable, Slice ~[]T](collection Slice) Slice
Keyify
slicecore
🧩 Source 📚 GoDoc 🎮 Try on Go Playground
Returns a set-like map where each unique element of the slice is a key.
set := lo.Keyify([]int{1, 1, 2, 3, 4}) // map[int]struct{}{1: {}, 2: {}, 3: {}, 4: {}}
Similar:
groupby keyby uniq uniqby
Prototype:
func Keyify[T comparable, Slice ~[]T](collection Slice) map[T]struct{}

Opposite of FilterMap: maps each item and includes results where the predicate returned false.

items := lo.RejectMap([]int{1, 2, 3, 4}, func(x int, _ int) (int, bool) {
    return x * 10, x%2 == 0
})
// []int{10, 30}

Similar:

filter filtermap map reject

Prototype:

func RejectMap[T any, R any](collection []T, callback func(item T, index int) (R, bool)) []R

Returns two slices: elements kept (predicate true) and elements rejected (predicate false).

kept, rejected := lo.FilterReject(
    []int{1, 2, 3, 4},
    func(x int, _ int) bool {
        return x%2 == 0
    },
)
// kept: []int{2, 4}
// rejected: []int{1, 3}

Prototype:

func FilterReject[T any, Slice ~[]T](collection Slice, predicate func(T, int) bool) (kept Slice, rejected Slice)

Count​

CountBy​

CountValues​

CountValuesBy​

Cut​

CutPrefix​

CutSuffix​

Filter​

IsSorted​

IsSortedBy​

Replace​

ReplaceAll​

Slice​

Splice​

Subset​

Trim​

TrimLeft​

TrimPrefix​

TrimRight​

TrimSuffix​

CountByErr​

FilterErr​

Map​

MapErr​

UniqMap​

FilterMap​

FlatMap​

FlatMapErr​

Reduce​

ReduceErr​

ReduceRight​

ReduceRightErr​

ForEach​

ForEachWhile​

Times​

Uniq​

UniqBy​

UniqByErr​

IsUniq​

IsUniqBy​

GroupBy​

GroupByErr​

TakeFilter​

GroupByMap​

GroupByMapErr​

Chunk​

Note

Window​

PartitionBy​

Sliding​

PartitionByErr​

Clone​

Concat​

Flatten​

Drop​

Interleave​

Take​

DropRight​

Shuffle​

DropWhile​

Reverse​

TakeWhile​

DropRightWhile​

Fill​

DropByIndex​

Repeat​

RepeatBy​

RepeatByErr​

KeyBy​

KeyByErr​

Associate​

Associate

AssociateI

SliceToMap

SliceToMap​

FilterSliceToMap​

Reject​

RejectErr​

Compact​

Keyify​

Count

CountBy

CountValues

CountValuesBy

Cut

CutPrefix

CutSuffix

Filter

IsSorted

IsSortedBy

Replace

ReplaceAll

Slice

Splice

Subset

Trim

TrimLeft

TrimPrefix

TrimRight

TrimSuffix

CountByErr

FilterErr

Map

MapErr

UniqMap

FilterMap

FlatMap

FlatMapErr

Reduce

ReduceErr

ReduceRight

ReduceRightErr

ForEach

ForEachWhile

Times

Uniq

UniqBy

UniqByErr

IsUniq

IsUniqBy

GroupBy

GroupByErr

TakeFilter

GroupByMap

GroupByMapErr

Chunk

Window

PartitionBy

Sliding

PartitionByErr

Clone

Concat

Flatten

Drop

Interleave

Take

DropRight

Shuffle

DropWhile

Reverse

TakeWhile

DropRightWhile

Fill

DropByIndex

Repeat

RepeatBy

RepeatByErr

KeyBy

KeyByErr

Associate

SliceToMap

FilterSliceToMap

Reject

RejectErr

Compact

Keyify

RejectMap

FilterReject