lo - Iterate over slices, maps, channels...

✨ 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:

• samber/ro: Reactive Programming for Go: declarative and composable API for event-driven applications
• samber/do: A dependency injection toolkit based on Go 1.18+ Generics
• samber/mo: Monads based on Go 1.18+ Generics (Option, Result, Either...)

What makes it different from samber/ro? - lo: synchronous helpers across finite sequences (maps, slices...) - ro: processing of infinite data streams for event-driven scenarios

^{💖 Sponsored by:}

  <img width="200" alt="dbos" src="https://github.com/user-attachments/assets/d583cb62-7735-4d3c-beb7-e6ef1a5faf49" />






  DBOS - Durable workflow orchestration library for Go

Why this name?

I wanted a short name, similar to "Lodash", and no Go package uses this name.

🚀 Install

go get github.com/samber/lo@v1

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.

💡 Usage

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

Tips for lazy developers

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. 😁 💩

🤠 Spec

GoDoc: godoc.org/github.com/samber/lo

Documentation: lo.samber.dev

Supported helpers for slices:

• Filter
• Map
• UniqMap
• FilterMap
• FlatMap
• Reduce
• ReduceRight
• ForEach
• ForEachWhile
• Times
• Uniq
• UniqBy
• GroupBy
• GroupByMap
• Chunk
• Window
• Sliding
• PartitionBy
• Flatten
• Concat
• Interleave
• Shuffle
• Reverse
• Fill
• Repeat
• RepeatBy
• KeyBy
• SliceToMap / Associate
• FilterSliceToMap
• Keyify
• Take
• TakeWhile
• TakeFilter
• Drop
• DropRight
• DropWhile
• DropRightWhile
• DropByIndex
• Reject
• RejectMap
• FilterReject
• Count
• CountBy
• CountValues
• CountValuesBy
• Subset
• Slice
• Replace
• ReplaceAll
• Clone
• Compact
• IsSorted
• IsSortedBy
• Splice
• Cut
• CutPrefix
• CutSuffix
• Trim
• TrimLeft
• TrimPrefix
• TrimRight
• TrimSuffix

Supported helpers for maps:

• Keys
• UniqKeys
• HasKey
• ValueOr
• Values
• UniqValues
• PickBy
• PickByKeys
• PickByValues
• OmitBy
• OmitByKeys
• OmitByValues
• Entries / ToPairs
• FromEntries / FromPairs
• Invert
• Assign (merge of maps)
• ChunkEntries
• MapKeys
• MapValues
• MapEntries
• MapToSlice
• FilterMapToSlice
• FilterKeys
• FilterValues

Supported math helpers:

• Range / RangeFrom / RangeWithSteps
• Clamp
• Sum
• SumBy
• Product
• ProductBy
• Mean
• MeanBy
• Mode

Supported helpers for strings:

• RandomString
• Substring
• ChunkString
• RuneLength
• PascalCase
• CamelCase
• KebabCase
• SnakeCase
• Words
• Capitalize
• Ellipsis

Supported helpers for tuples:

• T2 -> T9
• Unpack2 -> Unpack9
• Zip2 -> Zip9
• ZipBy2 -> ZipBy9
• Unzip2 -> Unzip9
• UnzipBy2 -> UnzipBy9
• CrossJoin2 -> CrossJoin2
• CrossJoinBy2 -> CrossJoinBy2

Supported helpers for time and duration:

• Duration
• Duration0 -> Duration10

Supported helpers for channels:

• ChannelDispatcher
• SliceToChannel
• ChannelToSlice
• Generator
• Buffer
• BufferWithContext
• BufferWithTimeout
• FanIn
• FanOut

Supported intersection helpers:

• Contains
• ContainsBy
• Every
• EveryBy
• Some
• SomeBy
• None
• NoneBy
• Intersect
• IntersectBy
• Difference
• Union
• Without
• WithoutBy
• WithoutEmpty
• WithoutNth
• ElementsMatch
• ElementsMatchBy

Supported search helpers:

• IndexOf
• LastIndexOf
• HasPrefix
• HasSuffix
• Find
• FindIndexOf
• FindLastIndexOf
• FindOrElse
• FindKey
• FindKeyBy
• FindUniques
• FindUniquesBy
• FindDuplicates
• FindDuplicatesBy
• Min
• MinIndex
• MinBy
• MinIndexBy
• Earliest
• EarliestBy
• Max
• MaxIndex
• MaxBy
• MaxIndexBy
• Latest
• LatestBy
• First
• FirstOrEmpty
• FirstOr
• Last
• LastOrEmpty
• LastOr
• Nth
• NthOr
• NthOrEmpty
• Sample
• SampleBy
• Samples
• SamplesBy

Conditional helpers:

• Ternary
• TernaryF
• If / ElseIf / Else
• Switch / Case / Default

Type manipulation helpers:

• IsNil
• IsNotNil
• ToPtr
• Nil
• EmptyableToPtr
• FromPtr
• FromPtrOr
• ToSlicePtr
• FromSlicePtr
• FromSlicePtrOr
• ToAnySlice
• FromAnySlice
• Empty
• IsEmpty
• IsNotEmpty
• Coalesce
• CoalesceOrEmpty
• CoalesceSlice
• CoalesceSliceOrEmpty
• CoalesceMap
• CoalesceMapOrEmpty

Function helpers:

• Partial
• Partial2 -> Partial5

Concurrency helpers:

• Attempt
• AttemptWhile
• AttemptWithDelay
• AttemptWhileWithDelay
• Debounce
• DebounceBy
• Throttle
• ThrottleWithCount
• ThrottleBy
• ThrottleByWithCount
• Synchronize
• Async
• Async{0->6}
• Transaction
• WaitFor
• WaitForWithContext

Error handling:

• Validate
• Must
• Try
• Try1 -> Try6
• TryOr
• TryOr1 -> TryOr6
• TryCatch
• TryWithErrorValue
• TryCatchWithErrorValue
• ErrorsAs
• Assert
• Assertf

Constraints:

• Clonable

Filter

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}

// Use FilterErr when the predicate can return an error
even, 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}

Map

Manipulates a slice of one type and transforms it into a slice of another type:

import "github.com/samber/lo"

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
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")

[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"

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]

UniqMap

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

[play]

FilterMap

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

[play]

FlatMap

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.

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

```go // Use FlatMapErr when the transform function can return an error result, err := lo.FlatMapErr([]int64{0, 1, 2, 3}, func(x int64, _ int) ([]string, error) { if x == 2 { return n