💥 A Lodash-style Go library based on Go 1.18+ Generics (map, filter, contains, find...)
💥 A Lodash-style Go library based on Go 1.18+ Generics (map, filter, contains, find...)
✨ samber/lo is a Lodash-style Go library based on Go 1.18+ Generics.
A utility library based on Go 1.18+ generics that makes it easier to work with slices, maps, strings, channels, and functions. It provides dozens of handy methods to simplify common coding tasks and improve code readability. It may look like Lodash in some aspects.
5 to 10 helpers may overlap with those from the Go standard library, in packages slices and maps. I feel this library is legitimate and offers many more valuable abstractions.
See also:
What makes it different from samber/ro?
Why this name?
I wanted a short name, similar to "Lodash", and no Go package uses this name.
go get github.com/samber/lo@v1
# AI Agent Skill
npx skills add https://github.com/samber/cc-skills-golang --skill golang-samber-lo
This library is v1 and follows SemVer strictly.
No breaking changes will be made to exported APIs before v2.0.0, except for experimental packages under exp/.
This library has no dependencies outside the Go standard library.
You can import lo using:
import (
"github.com/samber/lo"
lop "github.com/samber/lo/parallel"
lom "github.com/samber/lo/mutable"
loi "github.com/samber/lo/it"
)
Then use one of the helpers below:
names := lo.Uniq([]string{"Samuel", "John", "Samuel"})
// []string{"Samuel", "John"}
I cannot recommend it, but in case you are too lazy for repeating lo. everywhere, you can import the entire library into the namespace.
import (
. "github.com/samber/lo"
)
I take no responsibility for this junk. 😁 💩
GoDoc: godoc.org/github.com/samber/lo
Documentation: lo.samber.dev
Supported helpers for slices:
Supported helpers for maps:
Supported math helpers:
Supported helpers for strings:
Supported helpers for tuples:
Supported helpers for time and duration:
Supported helpers for channels:
Supported intersection helpers:
Supported search helpers:
Conditional helpers:
Type manipulation helpers:
Function helpers:
Concurrency helpers:
Error handling:
Constraints:
Iterates over a collection and returns a slice of all the elements the predicate function returns true for.
result := lo.Filter([]int{1, 2, 3, 4}, func(x int, index int) bool {
return x%2 == 0
})
// []int{2, 4}
[play]
// Use FilterErr when the predicate can return an error
result, err := lo.FilterErr([]int{1, 2, 3, 4}, func(x int, _ int) (bool, error) {
if x == 3 {
return false, fmt.Errorf("number 3 is not allowed")
}
return x%2 == 0, nil
})
// []int(nil), error("number 3 is not allowed")
[play]
Mutable: like lo.Filter(), but the slice is updated in place.
import lom "github.com/samber/lo/mutable"
list := []int{1, 2, 3, 4}
newList := lom.Filter(list, func(x int) bool {
return x%2 == 0
})
list
// []int{2, 4, 3, 4}
newList
// []int{2, 4}
[play]
Manipulates a slice of one type and transforms it into a slice of another type:
import "github.com/samber/lo"
result1:= lo.Map([]int64{1, 2, 3, 4}, func(x int64, index int) string {
return strconv.FormatInt(x, 10)
})
// []string{"1", "2", "3", "4"}
// Use MapErr when the transform function can return an error
result2, 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")
[play]
Parallel processing: like lo.Map(), but the transform function is called in a goroutine. Results are returned in the same order.
import lop "github.com/samber/lo/parallel"
partitionedByParity := lop.Map([]int64{1, 2, 3, 4}, func(x int64, _ int) string {
return strconv.FormatInt(x, 10)
})
// []string{"1", "2", "3", "4"}
[play]
Mutable: like lo.Map(), but the slice is updated in place.
import lom "github.com/samber/lo/mutable"
list := []int{1, 2, 3, 4}
lom.Map(list, func(x int) int {
return x*2
})
// []int{2, 4, 6, 8}
[play]
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 in