lo: Lodash-inspired utility library for Go

samber/lo is a Lodash-style utility library for Go, built on Go 1.18+ Generics. It provides synchronous helpers to simplify working with slices, maps, strings, channels, and functions.

While it overlaps with the Go standard library's slices and maps packages in some areas, it provides a broader set of abstractions for common coding tasks.

When choosing between debounce implementations in lo:

• NewDebounce: Applies a single debounce timer to all calls. If any call is made, the timer resets for everyone.
• NewDebounceBy: Applies a separate debounce timer for every unique key provided. Activity on key_A does not reset or delay the timer for key_B.

When using lo, you should choose your approach based on your performance and safety requirements:

• Immutable Operations (Default): Most functions return new collections. This is safer for concurrent programming and prevents side effects when sharing data.
• Mutable Operations: These modify collections in-place. While they are more memory efficient, they are less safe in concurrent scenarios or when multiple parts of your code share the same data.

In addition to lo.Trim, the lo library provides specialized trimming functions for more granular control:

• lo.TrimLeft: Removes elements only from the beginning of the collection.
• lo.TrimRight: Removes elements only from the end of the collection.
• lo.TrimPrefix: Removes a specific prefix from a collection.
• lo.TrimSuffix: Removes a specific suffix from a collection.

The lo library is built on four core principles to provide a Lodash-like experience in Go:

1. Type Safety Through Generics: Built on Go 1.18+ generics, ensuring compile-time type safety and eliminating the need for runtime type assertions.
2. Immutable by Default: The primary lo package returns new collections instead of modifying the input, making code more predictable.
3. Performance Specialization: When immutability or single-threaded execution is not ideal, use specialized packages:
   • lo/mutable for in-place modifications.
   • lo/parallel for concurrent processing.
   • lo/it for lazy evaluation via Go 1.23+ iterators.
4. Minimal Dependencies: Zero external dependencies beyond the Go standard library.

Depending on your specific needs, you might want to use a variation of KeyBy:

• lo.KeyByErr: Use this if your iteratee function can return an error. It returns the map and an error if the iteratee fails.
• lo.GroupBy: Use this if you want to group multiple items under the same key (returns map[K][]V) instead of having a single item per key.
• lo.GroupByErr: A version of GroupBy that handles errors from the iteratee.
• lo.PartitionBy: Use this to split a slice into two slices based on a predicate.
• lo.Associate: A map-based alternative for creating associations.

The lo library provides a fluent API for constructing conditional chains (If/ElseIf/Else) that are more readable than nested ternary-like structures. You can start a chain with lo.If or lo.IfF and extend it with ElseIf or ElseIfF before concluding with Else or ElseF to return the final value.

Use the standard versions (If, ElseIf, Else) when the results are simple values. Use the function-based versions (IfF, ElseIfF, ElseF) when the result requires expensive computation, as these versions evaluate the provided function lazily (only if the condition is met).

// Standard chain
result := lo.If(false, 1).ElseIf(false, 2).Else(3)
// 3

// Lazy chain using functions
result := lo.IfF(true, func() int {
    return 1
}).Else(3)
// 1

Use OmitByErr when your predicate function needs to return an error. If your predicate only needs to return a bool to decide whether to omit an entry, use lo.OmitBy instead.

OmitByErr is specifically designed for cases where the filtering process itself might encounter a failure that should halt the entire operation.

The TryX family of functions allows you to execute a callback and safely handle both returned errors and runtime panics. If the callback returns an error or triggers a panic, the Try function returns false. Otherwise, it returns true.

This pattern is useful for simplifying control flow when you want to attempt an operation and proceed only if it succeeds without manually checking if err != nil or using recover() for panics.

// Returns false if the function returns an error
ok := lo.Try(func() error {
    return fmt.Errorf("boom")
})
// ok == false

// Returns false if the function panics
ok = lo.Try0(func() {
    panic("boom")
})
// ok == false

// Returns true if the function succeeds
ok = lo.Try2(func() (int, error) {
    return 42, nil
})
// ok == true

Install the lo library using go get. The library is currently at v1 and follows Semantic Versioning (SemVer) strictly. It has zero dependencies outside of the Go standard library.

To install the v1 branch:

go get -u github.com/samber/lo@v1