lo

package module
v1.47.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 13, 2024 License: MIT Imports: 15 Imported by: 7,398

README

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

tag Go Version GoDoc Build Status Go report Coverage Contributors License

✨ samber/lo is a Lodash-style Go library based on Go 1.18+ Generics.

This project started as an experiment with the new generics implementation. It may look like Lodash in some aspects. I used to code with the fantastic "go-funk" package, but "go-funk" uses reflection and therefore is not typesafe.

As expected, benchmarks demonstrate that generics are much faster than implementations based on the "reflect" package. Benchmarks also show similar performance gains compared to pure for loops. See below.

In the future, 5 to 10 helpers will overlap with those coming into the Go standard library (under package names slices and maps). I feel this library is legitimate and offers many more valuable abstractions.

See also:

  • samber/do: A dependency injection toolkit based on Go 1.18+ Generics
  • samber/mo: Monads based on Go 1.18+ Generics (Option, Result, Either...)

Why this name?

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

lo

🚀 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.

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

Then use one of the helpers below:

names := lo.Uniq([]string{"Samuel", "John", "Samuel"})
// []string{"Samuel", "John"}

Most of the time, the compiler will be able to infer the type so that you can call: lo.Uniq([]string{...}).

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 on this junk. 😁 💩

🤠 Spec

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

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:

  • Clonable
Filter

Iterates over a collection and returns an array 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}

[play]

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

[play]

Parallel processing: like lo.Map(), but the mapper 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"}
FilterMap

Returns a slice which 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"}

[play]

Reduce

Reduces a collection to a single value. The value is calculated by accumulating the result of running each element in the collection through an accumulator function. Each successive invocation is supplied with the return value returned by the previous call.

sum := lo.Reduce([]int{1, 2, 3, 4}, func(agg int, item int, _ int) int {
    return agg + item
}, 0)
// 10

[play]

ReduceRight

Like lo.Reduce except that it iterates over elements of collection from right to left.

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}

[play]

ForEach

Iterates over elements of a collection and invokes the function over each element.

import "github.com/samber/lo"

lo.ForEach([]string{"hello", "world"}, func(x string, _ int) {
    println(x)
})
// prints "hello\nworld\n"

[play]

Parallel processing: like lo.ForEach(), but the callback is called as a goroutine.

import lop "github.com/samber/lo/parallel"

lop.ForEach([]string{"hello", "world"}, func(x string, _ int) {
    println(x)
})
// prints "hello\nworld\n" or "world\nhello\n"
ForEachWhile

Iterates over collection elements and invokes iteratee for each element collection return value decide to continue or break, like do while().

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

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

[play]

Times

Times invokes the iteratee n times, returning an array of the results of each invocation. The iteratee is invoked with index as argument.

import "github.com/samber/lo"

lo.Times(3, func(i int) string {
    return strconv.FormatInt(int64(i), 10)
})
// []string{"0", "1", "2"}

[play]

Parallel processing: like lo.Times(), but callback is called in goroutine.

import lop "github.com/samber/lo/parallel"

lop.Times(3, func(i int) string {
    return strconv.FormatInt(int64(i), 10)
})
// []string{"0", "1", "2"}
Uniq

Returns a duplicate-free version of an array, in which only the first occurrence of each element is kept. The order of result values is determined by the order they occur in the array.

uniqValues := lo.Uniq([]int{1, 2, 2, 1})
// []int{1, 2}

[play]

UniqBy

Returns a duplicate-free version of an array, in which only the first occurrence of each element is kept. The order of result values is determined by the order they occur in the array. It accepts iteratee which is invoked for each element in array to generate the criterion by which uniqueness is computed.

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

[play]

GroupBy

Returns an object composed of keys generated from the results of running each element of collection through iteratee.

import lo "github.com/samber/lo"

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

[play]

Parallel processing: like lo.GroupBy(), but callback is called in goroutine.

import lop "github.com/samber/lo/parallel"

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

Returns an array of elements split into groups the length of size. If array can't be split evenly, the final chunk will be the remaining elements.

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

lo.Chunk([]int{}, 2)
// [][]int{}

lo.Chunk([]int{0}, 2)
// [][]int{{0}}

[play]

PartitionBy

Returns an array of elements split into groups. The order of grouped values is determined by the order they occur in collection. The grouping is generated from the results of running each element of collection through iteratee.

import lo "github.com/samber/lo"

partitions := lo.PartitionBy([]int{-2, -1, 0, 1, 2, 3, 4, 5}, func(x int) string {
    if x < 0 {
        return "negative"
    } else if x%2 == 0 {
        return "even"
    }
    return "odd"
})
// [][]int{{-2, -1}, {0, 2, 4}, {1, 3, 5}}

[play]

Parallel processing: like lo.PartitionBy(), but callback is called in goroutine. Results are returned in the same order.

import lop "github.com/samber/lo/parallel"

partitions := lop.PartitionBy([]int{-2, -1, 0, 1, 2, 3, 4, 5}, func(x int) string {
    if x < 0 {
        return "negative"
    } else if x%2 == 0 {
        return "even"
    }
    return "odd"
})
// [][]int{{-2, -1}, {0, 2, 4}, {1, 3, 5}}
Flatten

Returns an array a single level deep.

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

[play]

Interleave

Round-robin alternating input slices and sequentially appending value at index into result.

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

interleaved := 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}

[play]

Shuffle

Returns an array of shuffled values. Uses the Fisher-Yates shuffle algorithm.

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

[play]

Reverse

Reverses array so that the first element becomes the last, the second element becomes the second to last, and so on.

⚠️ This helper is mutable. This behavior might change in v2.0.0. See #160.

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

[play]

Fill

Fills elements of array with initial value.

type foo struct {
  bar string
}

func (f foo) Clone() foo {
  return foo{f.bar}
}

initializedSlice := lo.Fill([]foo{foo{"a"}, foo{"a"}}, foo{"b"})
// []foo{foo{"b"}, foo{"b"}}

[play]

Repeat

Builds a slice with N copies of initial value.

type foo struct {
  bar string
}

func (f foo) Clone() foo {
  return foo{f.bar}
}

slice := lo.Repeat(2, foo{"a"})
// []foo{foo{"a"}, foo{"a"}}

[play]

RepeatBy

Builds a slice with values returned by N calls of callback.

slice := lo.RepeatBy(0, func (i int) string {
    return strconv.FormatInt(int64(math.Pow(float64(i), 2)), 10)
})
// []string{}

slice := lo.RepeatBy(5, func(i int) string {
    return strconv.FormatInt(int64(math.Pow(float64(i), 2)), 10)
})
// []string{"0", "1", "4", "9", "16"}

[play]

KeyBy

Transforms a slice or an array of structs to a map based on a pivot callback.

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

type Character struct {
  dir  string
  code int
}
characters := []Character{
    {dir: "left", code: 97},
    {dir: "right", code: 100},
}
result := lo.KeyBy(characters, func(char Character) string {
    return string(rune(char.code))
})
//map[a:{dir:left code:97} d:{dir:right code:100}]

[play]

Associate (alias: SliceToMap)

Returns a map containing key-value pairs provided by transform function applied to elements of the given slice. If any of two pairs would have the same key the last one gets added to the map.

The order of keys in returned map is not specified and is not guaranteed to be the same from the original array.

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

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

[play]

Drop

Drops n elements from the beginning of a slice or array.

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

[play]

DropRight

Drops n elements from the end of a slice or array.

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

[play]

DropWhile

Drop elements from the beginning of a slice or array while the predicate returns true.

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

[play]

DropRightWhile

Drop elements from the end of a slice or array while the predicate returns true.

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

[play]

DropByIndex

Drops elements from a slice or array by the index. A negative index will drop elements from the end of the slice.

l := lo.DropByIndex([]int{0, 1, 2, 3, 4, 5}, 2, 4, -1)
// []int{0, 1, 3}

[play]

Reject

The opposite of Filter, this method returns the elements of collection that predicate does not return truthy for.

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

[play]

RejectMap

The opposite of FilterMap, this method returns a slice which 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.
items := lo.RejectMap([]int{1, 2, 3, 4}, func(x int, _ int) (int, bool) {
    return x*10, x%2 == 0
})
// []int{10, 30}
FilterReject

Mixes Filter and Reject, this method returns two slices, one for the elements of collection that predicate returns truthy for and one for the elements that predicate does not return truthy for.

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

Counts the number of elements in the collection that compare equal to value.

count := lo.Count([]int{1, 5, 1}, 1)
// 2

[play]

CountBy

Counts the number of elements in the collection for which predicate is true.

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

[play]

CountValues

Counts the number of each element in the collection.

lo.CountValues([]int{})
// map[int]int{}

lo.CountValues([]int{1, 2})
// map[int]int{1: 1, 2: 1}

lo.CountValues([]int{1, 2, 2})
// map[int]int{1: 1, 2: 2}

lo.CountValues([]string{"foo", "bar", ""})
// map[string]int{"": 1, "foo": 1, "bar": 1}

lo.CountValues([]string{"foo", "bar", "bar"})
// map[string]int{"foo": 1, "bar": 2}

[play]

CountValuesBy

Counts the number of each element in the collection. It ss equivalent to chaining lo.Map and lo.CountValues.

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

lo.CountValuesBy([]int{}, isEven)
// map[bool]int{}

lo.CountValuesBy([]int{1, 2}, isEven)
// map[bool]int{false: 1, true: 1}

lo.CountValuesBy([]int{1, 2, 2}, isEven)
// map[bool]int{false: 1, true: 2}

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

lo.CountValuesBy([]string{"foo", "bar", ""}, length)
// map[int]int{0: 1, 3: 2}

lo.CountValuesBy([]string{"foo", "bar", "bar"}, length)
// map[int]int{3: 3}

[play]

Subset

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}

sub := lo.Subset(in, 2, 3)
// []int{2, 3, 4}

sub := lo.Subset(in, -4, 3)
// []int{1, 2, 3}

sub := lo.Subset(in, -2, math.MaxUint)
// []int{3, 4}

[play]

Slice

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}

slice := lo.Slice(in, 0, 5)
// []int{0, 1, 2, 3, 4}

slice := lo.Slice(in, 2, 3)
// []int{2}

slice := lo.Slice(in, 2, 6)
// []int{2, 3, 4}

slice := lo.Slice(in, 4, 3)
// []int{}

[play]

Replace

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}

slice := lo.Replace(in, 0, 42, 1)
// []int{42, 1, 0, 1, 2, 3, 0}

slice := lo.Replace(in, -1, 42, 1)
// []int{0, 1, 0, 1, 2, 3, 0}

slice := lo.Replace(in, 0, 42, 2)
// []int{42, 1, 42, 1, 2, 3, 0}

slice := lo.Replace(in, 0, 42, -1)
// []int{42, 1, 42, 1, 2, 3, 42}

[play]

ReplaceAll

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}

slice := lo.ReplaceAll(in, 0, 42)
// []int{42, 1, 42, 1, 2, 3, 42}

slice := lo.ReplaceAll(in, -1, 42)
// []int{0, 1, 0, 1, 2, 3, 0}

[play]

Compact

Returns a slice of all non-zero elements.

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

slice := lo.Compact(in)
// []string{"foo", "bar"}

[play]

IsSorted

Checks if a slice is sorted.

slice := lo.IsSorted([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
// true

[play]

IsSortedByKey

Checks if a slice is sorted by iteratee.

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

[play]

Splice

Splice inserts multiple elements at index i. A negative index counts back from the end of the slice. The helper is protected against overflow errors.

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

// negative
result = lo.Splice([]string{"a", "b"}, -1, "1", "2")
// []string{"a", "1", "2", "b"}

// overflow
result = lo.Splice([]string{"a", "b"}, 42, "1", "2")
// []string{"a", "b", "1", "2"}

[play]

Keys

Creates a slice of the map keys.

Use the UniqKeys variant to deduplicate common keys.

keys := lo.Keys(map[string]int{"foo": 1, "bar": 2})
// []string{"foo", "bar"}

keys := lo.Keys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3})
// []string{"foo", "bar", "baz"}

keys := lo.Keys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"bar": 3})
// []string{"foo", "bar", "bar"}

[play]

UniqKeys

Creates an array of unique map keys.

keys := lo.Keys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3})
// []string{"foo", "bar", "baz"}

keys := lo.Keys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"bar": 3})
// []string{"foo", "bar"}

[play]

HasKey

Returns whether the given key exists.

exists := lo.HasKey(map[string]int{"foo": 1, "bar": 2}, "foo")
// true

exists := lo.HasKey(map[string]int{"foo": 1, "bar": 2}, "baz")
// false

[play]

Values

Creates an array of the map values.

Use the UniqValues variant to deduplicate common values.

values := lo.Values(map[string]int{"foo": 1, "bar": 2})
// []int{1, 2}

values := lo.Values(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3})
// []int{1, 2, 3}

values := lo.Values(map[string]int{"foo": 1, "bar": 2}, map[string]int{"bar": 2})
// []int{1, 2, 2}

[play]

UniqValues

Creates an array of unique map values.

values := lo.UniqValues(map[string]int{"foo": 1, "bar": 2})
// []int{1, 2}

values := lo.UniqValues(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3})
// []int{1, 2, 3}

values := lo.UniqValues(map[string]int{"foo": 1, "bar": 2}, map[string]int{"bar": 2})
// []int{1, 2}

[play]

ValueOr

Returns the value of the given key or the fallback value if the key is not present.

value := lo.ValueOr(map[string]int{"foo": 1, "bar": 2}, "foo", 42)
// 1

value := lo.ValueOr(map[string]int{"foo": 1, "bar": 2}, "baz", 42)
// 42

[play]

PickBy

Returns same map type filtered by given predicate.

m := lo.PickBy(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(key string, value int) bool {
    return value%2 == 1
})
// map[string]int{"foo": 1, "baz": 3}

[play]

PickByKeys

Returns same map type filtered by given keys.

m := lo.PickByKeys(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []string{"foo", "baz"})
// map[string]int{"foo": 1, "baz": 3}

[play]

PickByValues

Returns same map type filtered by given values.

m := lo.PickByValues(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []int{1, 3})
// map[string]int{"foo": 1, "baz": 3}

[play]

OmitBy

Returns same map type filtered by given predicate.

m := lo.OmitBy(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(key string, value int) bool {
    return value%2 == 1
})
// map[string]int{"bar": 2}

[play]

OmitByKeys

Returns same map type filtered by given keys.

m := lo.OmitByKeys(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []string{"foo", "baz"})
// map[string]int{"bar": 2}

[play]

OmitByValues

Returns same map type filtered by given values.

m := lo.OmitByValues(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []int{1, 3})
// map[string]int{"bar": 2}

[play]

Entries (alias: ToPairs)

Transforms a map into array of key/value pairs.

entries := lo.Entries(map[string]int{"foo": 1, "bar": 2})
// []lo.Entry[string, int]{
//     {
//         Key: "foo",
//         Value: 1,
//     },
//     {
//         Key: "bar",
//         Value: 2,
//     },
// }

[play]

FromEntries (alias: FromPairs)

Transforms an array of key/value pairs into a map.

m := lo.FromEntries([]lo.Entry[string, int]{
    {
        Key: "foo",
        Value: 1,
    },
    {
        Key: "bar",
        Value: 2,
    },
})
// map[string]int{"foo": 1, "bar": 2}

[play]

Invert

Creates a map composed of the inverted keys and values. If map contains duplicate values, subsequent values overwrite property assignments of previous values.

m1 := lo.Invert(map[string]int{"a": 1, "b": 2})
// map[int]string{1: "a", 2: "b"}

m2 := lo.Invert(map[string]int{"a": 1, "b": 2, "c": 1})
// map[int]string{1: "c", 2: "b"}

[play]

Assign

Merges multiple maps from left to right.

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

[play]

MapKeys

Manipulates a map keys and transforms it to a map of another type.

m2 := lo.MapKeys(map[int]int{1: 1, 2: 2, 3: 3, 4: 4}, func(_ int, v int) string {
    return strconv.FormatInt(int64(v), 10)
})
// map[string]int{"1": 1, "2": 2, "3": 3, "4": 4}

[play]

MapValues

Manipulates a map values and transforms it to a map of another type.

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

m2 := lo.MapValues(m1, func(x int64, _ int) string {
    return strconv.FormatInt(x, 10)
})
// map[int]string{1: "1", 2: "2", 3: "3"}

[play]

MapEntries

Manipulates a map entries and transforms it to a map of another type.

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

out := lo.MapEntries(in, func(k string, v int) (int, string) {
    return v,k
})
// map[int]string{1: "foo", 2: "bar"}

[play]

MapToSlice

Transforms a map into a slice based on specific iteratee.

m := map[int]int64{1: 4, 2: 5, 3: 6}

s := lo.MapToSlice(m, func(k int, v int64) string {
    return fmt.Sprintf("%d_%d", k, v)
})
// []string{"1_4", "2_5", "3_6"}

[play]

Range / RangeFrom / RangeWithSteps

Creates an array of numbers (positive and/or negative) progressing from start up to, but not including end.

result := lo.Range(4)
// [0, 1, 2, 3]

result := lo.Range(-4)
// [0, -1, -2, -3]

result := lo.RangeFrom(1, 5)
// [1, 2, 3, 4, 5]

result := lo.RangeFrom[float64](1.0, 5)
// [1.0, 2.0, 3.0, 4.0, 5.0]

result := lo.RangeWithSteps(0, 20, 5)
// [0, 5, 10, 15]

result := lo.RangeWithSteps[float32](-1.0, -4.0, -1.0)
// [-1.0, -2.0, -3.0]

result := lo.RangeWithSteps(1, 4, -1)
// []

result := lo.Range(0)
// []

[play]

Clamp

Clamps number within the inclusive lower and upper bounds.

r1 := lo.Clamp(0, -10, 10)
// 0

r2 := lo.Clamp(-42, -10, 10)
// -10

r3 := lo.Clamp(42, -10, 10)
// 10

[play]

Sum

Sums the values in a collection.

If collection is empty 0 is returned.

list := []int{1, 2, 3, 4, 5}
sum := lo.Sum(list)
// 15

[play]

SumBy

Summarizes the values in a collection using the given return value from the iteration function.

If collection is empty 0 is returned.

strings := []string{"foo", "bar"}
sum := lo.SumBy(strings, func(item string) int {
    return len(item)
})
// 6

[play]

Mean

Calculates the mean of a collection of numbers.

If collection is empty 0 is returned.

mean := lo.Mean([]int{2, 3, 4, 5})
// 3

mean := lo.Mean([]float64{2, 3, 4, 5})
// 3.5

mean := lo.Mean([]float64{})
// 0
MeanBy

Calculates the mean of a collection of numbers using the given return value from the iteration function.

If collection is empty 0 is returned.

list := []string{"aa", "bbb", "cccc", "ddddd"}
mapper := func(item string) float64 {
    return float64(len(item))
}

mean := lo.MeanBy(list, mapper)
// 3.5

mean := lo.MeanBy([]float64{}, mapper)
// 0
RandomString

Returns a random string of the specified length and made of the specified charset.

str := lo.RandomString(5, lo.LettersCharset)
// example: "eIGbt"

[play]

Substring

Return part of a string.

sub := lo.Substring("hello", 2, 3)
// "llo"

sub := lo.Substring("hello", -4, 3)
// "ell"

sub := lo.Substring("hello", -2, math.MaxUint)
// "lo"

[play]

ChunkString

Returns an array of strings split into groups the length of size. If array can't be split evenly, the final chunk will be the remaining elements.

lo.ChunkString("123456", 2)
// []string{"12", "34", "56"}

lo.ChunkString("1234567", 2)
// []string{"12", "34", "56", "7"}

lo.ChunkString("", 2)
// []string{""}

lo.ChunkString("1", 2)
// []string{"1"}

[play]

RuneLength

An alias to utf8.RuneCountInString which returns the number of runes in string.

sub := lo.RuneLength("hellô")
// 5

sub := len("hellô")
// 6

[play]

PascalCase

Converts string to pascal case.

str := lo.PascalCase("hello_world")
// HelloWorld

[play]

CamelCase

Converts string to camel case.

str := lo.CamelCase("hello_world")
// helloWorld

[play]

KebabCase

Converts string to kebab case.

str := lo.KebabCase("helloWorld")
// hello-world

[play]

SnakeCase

Converts string to snake case.

str := lo.SnakeCase("HelloWorld")
// hello_world

[play]

Words

Splits string into an array of its words.

str := lo.Words("helloWorld")
// []string{"hello", "world"}

[play]

Capitalize

Converts the first character of string to upper case and the remaining to lower case.

str := lo.Capitalize("heLLO")
// Hello
Elipse

Truncates a string to a specified length and appends an ellipsis if truncated.

str := lo.Elipse("Lorem Ipsum", 5)
// Lo...

str := lo.Elipse("Lorem Ipsum", 100)
// Lorem Ipsum

str := lo.Elipse("Lorem Ipsum", 3)
// ...
T2 -> T9

Creates a tuple from a list of values.

tuple1 := lo.T2("x", 1)
// Tuple2[string, int]{A: "x", B: 1}

func example() (string, int) { return "y", 2 }
tuple2 := lo.T2(example())
// Tuple2[string, int]{A: "y", B: 2}

[play]

Unpack2 -> Unpack9

Returns values contained in tuple.

r1, r2 := lo.Unpack2(lo.Tuple2[string, int]{"a", 1})
// "a", 1

Unpack is also available as a method of TupleX.

tuple2 := lo.T2("a", 1)
a, b := tuple2.Unpack()
// "a", 1

[play]

Zip2 -> Zip9

Zip creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on.

When collections have different size, the Tuple attributes are filled with zero value.

tuples := lo.Zip2([]string{"a", "b"}, []int{1, 2})
// []Tuple2[string, int]{{A: "a", B: 1}, {A: "b", B: 2}}

[play]

ZipBy2 -> ZipBy9

ZipBy creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on.

When collections have different size, the Tuple attributes are filled with zero value.

items := lo.ZipBy2([]string{"a", "b"}, []int{1, 2}, func(a string, b int) string {
    return fmt.Sprintf("%s-%d", a, b)
})
// []string{"a-1", "b-2"}
Unzip2 -> Unzip9

Unzip accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration.

a, b := lo.Unzip2([]Tuple2[string, int]{{A: "a", B: 1}, {A: "b", B: 2}})
// []string{"a", "b"}
// []int{1, 2}

[play]

UnzipBy2 -> UnzipBy9

UnzipBy2 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.

a, b := lo.UnzipBy2([]string{"hello", "john", "doe"}, func(str string) (string, int) {
    return str, len(str)
})
// []string{"hello", "john", "doe"}
// []int{5, 4, 3}
Duration

Returns the time taken to execute a function.

duration := lo.Duration(func() {
    // very long job
})
// 3s
Duration0 -> Duration10

Returns the time taken to execute a function.

duration := lo.Duration0(func() {
    // very long job
})
// 3s

err, duration := lo.Duration1(func() error {
    // very long job
    return fmt.Errorf("an error")
})
// an error
// 3s

str, nbr, err, duration := lo.Duration3(func() (string, int, error) {
    // very long job
    return "hello", 42, nil
})
// hello
// 42
// nil
// 3s
ChannelDispatcher

Distributes messages from input channels into N child channels. Close events are propagated to children.

Underlying channels can have a fixed buffer capacity or be unbuffered when cap is 0.

ch := make(chan int, 42)
for i := 0; i <= 10; i++ {
    ch <- i
}

children := lo.ChannelDispatcher(ch, 5, 10, DispatchingStrategyRoundRobin[int])
// []<-chan int{...}

consumer := func(c <-chan int) {
    for {
        msg, ok := <-c
        if !ok {
            println("closed")

            break
        }

        println(msg)
    }
}

for i := range children {
    go consumer(children[i])
}

Many distributions strategies are available:

Some strategies bring fallback, in order to favor non-blocking behaviors. See implementations.

For custom strategies, just implement the lo.DispatchingStrategy prototype:

type DispatchingStrategy[T any] func(message T, messageIndex uint64, channels []<-chan T) int

Eg:

type Message struct {
    TenantID uuid.UUID
}

func hash(id uuid.UUID) int {
    h := fnv.New32a()
    h.Write([]byte(id.String()))
    return int(h.Sum32())
}

// Routes messages per TenantID.
customStrategy := func(message string, messageIndex uint64, channels []<-chan string) int {
    destination := hash(message) % len(channels)

    // check if channel is full
    if len(channels[destination]) < cap(channels[destination]) {
        return destination
    }

    // fallback when child channel is full
    return utils.DispatchingStrategyRoundRobin(message, uint64(destination), channels)
}

children := lo.ChannelDispatcher(ch, 5, 10, customStrategy)
...
SliceToChannel

Returns a read-only channels of collection elements. Channel is closed after last element. Channel capacity can be customized.

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

for v := range lo.SliceToChannel(2, list) {
    println(v)
}
// prints 1, then 2, then 3, then 4, then 5
ChannelToSlice

Returns a slice built from channels items. Blocks until channel closes.

list := []int{1, 2, 3, 4, 5}
ch := lo.SliceToChannel(2, list)

items := ChannelToSlice(ch)
// []int{1, 2, 3, 4, 5}
Generator

Implements the generator design pattern. Channel is closed after last element. Channel capacity can be customized.

generator := func(yield func(int)) {
    yield(1)
    yield(2)
    yield(3)
}

for v := range lo.Generator(2, generator) {
    println(v)
}
// prints 1, then 2, then 3
Buffer

Creates a slice of n elements from a channel. Returns the slice, the slice length, the read time and the channel status (opened/closed).

ch := lo.SliceToChannel(2, []int{1, 2, 3, 4, 5})

items1, length1, duration1, ok1 := lo.Buffer(ch, 3)
// []int{1, 2, 3}, 3, 0s, true
items2, length2, duration2, ok2 := lo.Buffer(ch, 3)
// []int{4, 5}, 2, 0s, false

Example: RabbitMQ consumer 👇

ch := readFromQueue()

for {
    // read 1k items
    items, length, _, ok := lo.Buffer(ch, 1000)

    // do batching stuff

    if !ok {
        break
    }
}
BufferWithTimeout

Creates a slice of n elements from a channel, with timeout. Returns the slice, the slice length, the read time and the channel status (opened/closed).

generator := func(yield func(int)) {
    for i := 0; i < 5; i++ {
        yield(i)
        time.Sleep(35*time.Millisecond)
    }
}

ch := lo.Generator(0, generator)

items1, length1, duration1, ok1 := lo.BufferWithTimeout(ch, 3, 100*time.Millisecond)
// []int{1, 2}, 2, 100ms, true
items2, length2, duration2, ok2 := lo.BufferWithTimeout(ch, 3, 100*time.Millisecond)
// []int{3, 4, 5}, 3, 75ms, true
items3, length3, duration2, ok3 := lo.BufferWithTimeout(ch, 3, 100*time.Millisecond)
// []int{}, 0, 10ms, false

Example: RabbitMQ consumer 👇

ch := readFromQueue()

for {
    // read 1k items
    // wait up to 1 second
    items, length, _, ok := lo.BufferWithTimeout(ch, 1000, 1*time.Second)

    // do batching stuff

    if !ok {
        break
    }
}

Example: Multithreaded RabbitMQ consumer 👇

ch := readFromQueue()

// 5 workers
// prefetch 1k messages per worker
children := lo.ChannelDispatcher(ch, 5, 1000, lo.DispatchingStrategyFirst[int])

consumer := func(c <-chan int) {
    for {
        // read 1k items
        // wait up to 1 second
        items, length, _, ok := lo.BufferWithTimeout(ch, 1000, 1*time.Second)

        // do batching stuff

        if !ok {
            break
        }
    }
}

for i := range children {
    go consumer(children[i])
}
FanIn

Merge messages from multiple input channels into a single buffered channel. Output messages has no priority. When all upstream channels reach EOF, downstream channel closes.

stream1 := make(chan int, 42)
stream2 := make(chan int, 42)
stream3 := make(chan int, 42)

all := lo.FanIn(100, stream1, stream2, stream3)
// <-chan int
FanOut

Broadcasts all the upstream messages to multiple downstream channels. When upstream channel reach EOF, downstream channels close. If any downstream channels is full, broadcasting is paused.

stream := make(chan int, 42)

all := lo.FanOut(5, 100, stream)
// [5]<-chan int
Contains

Returns true if an element is present in a collection.

present := lo.Contains([]int{0, 1, 2, 3, 4, 5}, 5)
// true
ContainsBy

Returns true if the predicate function returns true.

present := lo.ContainsBy([]int{0, 1, 2, 3, 4, 5}, func(x int) bool {
    return x == 3
})
// true
Every

Returns true if all elements of a subset are contained into a collection or if the subset is empty.

ok := lo.Every([]int{0, 1, 2, 3, 4, 5}, []int{0, 2})
// true

ok := lo.Every([]int{0, 1, 2, 3, 4, 5}, []int{0, 6})
// false
EveryBy

Returns true if the predicate returns true for all of the elements in the collection or if the collection is empty.

b := EveryBy([]int{1, 2, 3, 4}, func(x int) bool {
    return x < 5
})
// true
Some

Returns true if at least 1 element of a subset is contained into a collection. If the subset is empty Some returns false.

ok := lo.Some([]int{0, 1, 2, 3, 4, 5}, []int{0, 2})
// true

ok := lo.Some([]int{0, 1, 2, 3, 4, 5}, []int{-1, 6})
// false
SomeBy

Returns true if the predicate returns true for any of the elements in the collection. If the collection is empty SomeBy returns false.

b := SomeBy([]int{1, 2, 3, 4}, func(x int) bool {
    return x < 3
})
// true
None

Returns true if no element of a subset are contained into a collection or if the subset is empty.

b := None([]int{0, 1, 2, 3, 4, 5}, []int{0, 2})
// false
b := None([]int{0, 1, 2, 3, 4, 5}, []int{-1, 6})
// true
NoneBy

Returns true if the predicate returns true for none of the elements in the collection or if the collection is empty.

b := NoneBy([]int{1, 2, 3, 4}, func(x int) bool {
    return x < 0
})
// true
Intersect

Returns the intersection between two collections.

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

result2 := lo.Intersect([]int{0, 1, 2, 3, 4, 5}, []int{0, 6})
// []int{0}

result3 := lo.Intersect([]int{0, 1, 2, 3, 4, 5}, []int{-1, 6})
// []int{}
Difference

Returns the difference between two collections.

  • The first value is the collection of element absent of list2.
  • The second value is the collection of element absent of list1.
left, right := lo.Difference([]int{0, 1, 2, 3, 4, 5}, []int{0, 2, 6})
// []int{1, 3, 4, 5}, []int{6}

left, right := lo.Difference([]int{0, 1, 2, 3, 4, 5}, []int{0, 1, 2, 3, 4, 5})
// []int{}, []int{}
Union

Returns all distinct elements from given collections. Result will not change the order of elements relatively.

union := lo.Union([]int{0, 1, 2, 3, 4, 5}, []int{0, 2}, []int{0, 10})
// []int{0, 1, 2, 3, 4, 5, 10}
Without

Returns slice excluding all given values.

subset := lo.Without([]int{0, 2, 10}, 2)
// []int{0, 10}

subset := lo.Without([]int{0, 2, 10}, 0, 1, 2, 3, 4, 5)
// []int{10}
WithoutEmpty

Returns slice excluding empty values.

subset := lo.WithoutEmpty([]int{0, 2, 10})
// []int{2, 10}
IndexOf

Returns the index at which the first occurrence of a value is found in an array or return -1 if the value cannot be found.

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

notFound := lo.IndexOf([]int{0, 1, 2, 1, 2, 3}, 6)
// -1
LastIndexOf

Returns the index at which the last occurrence of a value is found in an array or return -1 if the value cannot be found.

found := lo.LastIndexOf([]int{0, 1, 2, 1, 2, 3}, 2)
// 4

notFound := lo.LastIndexOf([]int{0, 1, 2, 1, 2, 3}, 6)
// -1
Find

Search an element in a slice based on a predicate. It returns element and true if element was found.

str, ok := lo.Find([]string{"a", "b", "c", "d"}, func(i string) bool {
    return i == "b"
})
// "b", true

str, ok := lo.Find([]string{"foobar"}, func(i string) bool {
    return i == "b"
})
// "", false
FindIndexOf

FindIndexOf searches an element in a slice based on a predicate and returns the index and true. It returns -1 and false if the element is not found.

str, index, ok := lo.FindIndexOf([]string{"a", "b", "a", "b"}, func(i string) bool {
    return i == "b"
})
// "b", 1, true

str, index, ok := lo.FindIndexOf([]string{"foobar"}, func(i string) bool {
    return i == "b"
})
// "", -1, false
FindLastIndexOf

FindLastIndexOf searches an element in a slice based on a predicate and returns the index and true. It returns -1 and false if the element is not found.

str, index, ok := lo.FindLastIndexOf([]string{"a", "b", "a", "b"}, func(i string) bool {
    return i == "b"
})
// "b", 4, true

str, index, ok := lo.FindLastIndexOf([]string{"foobar"}, func(i string) bool {
    return i == "b"
})
// "", -1, false
FindOrElse

Search an element in a slice based on a predicate. It returns the element if found or a given fallback value otherwise.

str := lo.FindOrElse([]string{"a", "b", "c", "d"}, "x", func(i string) bool {
    return i == "b"
})
// "b"

str := lo.FindOrElse([]string{"foobar"}, "x", func(i string) bool {
    return i == "b"
})
// "x"
FindKey

Returns the key of the first value matching.

result1, ok1 := lo.FindKey(map[string]int{"foo": 1, "bar": 2, "baz": 3}, 2)
// "bar", true

result2, ok2 := lo.FindKey(map[string]int{"foo": 1, "bar": 2, "baz": 3}, 42)
// "", false

type test struct {
    foobar string
}
result3, ok3 := lo.FindKey(map[string]test{"foo": test{"foo"}, "bar": test{"bar"}, "baz": test{"baz"}}, test{"foo"})
// "foo", true
FindKeyBy

Returns the key of the first element predicate returns truthy for.

result1, ok1 := lo.FindKeyBy(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(k string, v int) bool {
    return k == "foo"
})
// "foo", true

result2, ok2 := lo.FindKeyBy(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(k string, v int) bool {
    return false
})
// "", false
FindUniques

Returns a slice with all the unique elements of the collection. The order of result values is determined by the order they occur in the array.

uniqueValues := lo.FindUniques([]int{1, 2, 2, 1, 2, 3})
// []int{3}
FindUniquesBy

Returns a slice with all the unique elements of the collection. The order of result values is determined by the order they occur in the array. It accepts iteratee which is invoked for each element in array to generate the criterion by which uniqueness is computed.

uniqueValues := lo.FindUniquesBy([]int{3, 4, 5, 6, 7}, func(i int) int {
    return i%3
})
// []int{5}
FindDuplicates

Returns a slice with the first occurrence of each duplicated elements of the collection. The order of result values is determined by the order they occur in the array.

duplicatedValues := lo.FindDuplicates([]int{1, 2, 2, 1, 2, 3})
// []int{1, 2}
FindDuplicatesBy

Returns a slice with the first occurrence of each duplicated elements of the collection. The order of result values is determined by the order they occur in the array. It accepts iteratee which is invoked for each element in array to generate the criterion by which uniqueness is computed.

duplicatedValues := lo.FindDuplicatesBy([]int{3, 4, 5, 6, 7}, func(i int) int {
    return i%3
})
// []int{3, 4}
Min

Search the minimum value of a collection.

Returns zero value when the collection is empty.

min := lo.Min([]int{1, 2, 3})
// 1

min := lo.Min([]int{})
// 0

min := lo.Min([]time.Duration{time.Second, time.Hour})
// 1s
MinBy

Search the minimum value of a collection using the given comparison function.

If several values of the collection are equal to the smallest value, returns the first such value.

Returns zero value when the collection is empty.

min := lo.MinBy([]string{"s1", "string2", "s3"}, func(item string, min string) bool {
    return len(item) < len(min)
})
// "s1"

min := lo.MinBy([]string{}, func(item string, min string) bool {
    return len(item) < len(min)
})
// ""
Earliest

Search the minimum time.Time of a collection.

Returns zero value when the collection is empty.

earliest := lo.Earliest(time.Now(), time.Time{})
// 0001-01-01 00:00:00 +0000 UTC
EarliestBy

Search the minimum time.Time of a collection using the given iteratee function.

Returns zero value when the collection is empty.

type foo struct {
    bar time.Time
}

earliest := lo.EarliestBy([]foo{{time.Now()}, {}}, func(i foo) time.Time {
    return i.bar
})
// {bar:{2023-04-01 01:02:03 +0000 UTC}}
Max

Search the maximum value of a collection.

Returns zero value when the collection is empty.

max := lo.Max([]int{1, 2, 3})
// 3

max := lo.Max([]int{})
// 0

max := lo.Max([]time.Duration{time.Second, time.Hour})
// 1h
MaxBy

Search the maximum value of a collection using the given comparison function.

If several values of the collection are equal to the greatest value, returns the first such value.

Returns zero value when the collection is empty.

max := lo.MaxBy([]string{"string1", "s2", "string3"}, func(item string, max string) bool {
    return len(item) > len(max)
})
// "string1"

max := lo.MaxBy([]string{}, func(item string, max string) bool {
    return len(item) > len(max)
})
// ""
Latest

Search the maximum time.Time of a collection.

Returns zero value when the collection is empty.

latest := lo.Latest([]time.Time{time.Now(), time.Time{}})
// 2023-04-01 01:02:03 +0000 UTC
LatestBy

Search the maximum time.Time of a collection using the given iteratee function.

Returns zero value when the collection is empty.

type foo struct {
    bar time.Time
}

latest := lo.LatestBy([]foo{{time.Now()}, {}}, func(i foo) time.Time {
    return i.bar
})
// {bar:{2023-04-01 01:02:03 +0000 UTC}}
First

Returns the first element of a collection and check for availability of the first element.

first, ok := lo.First([]int{1, 2, 3})
// 1, true

first, ok := lo.First([]int{})
// 0, false
FirstOrEmpty

Returns the first element of a collection or zero value if empty.

first := lo.FirstOrEmpty([]int{1, 2, 3})
// 1

first := lo.FirstOrEmpty([]int{})
// 0
FirstOr

Returns the first element of a collection or the fallback value if empty.

first := lo.FirstOr([]int{1, 2, 3}, 245)
// 1

first := lo.FirstOr([]int{}, 31)
// 31
Last

Returns the last element of a collection or error if empty.

last, ok := lo.Last([]int{1, 2, 3})
// 3
// true

last, ok := lo.Last([]int{})
// 0
// false
LastOrEmpty

Returns the first element of a collection or zero value if empty.

last := lo.LastOrEmpty([]int{1, 2, 3})
// 3

last := lo.LastOrEmpty([]int{})
// 0
LastOr

Returns the first element of a collection or the fallback value if empty.

last := lo.LastOr([]int{1, 2, 3}, 245)
// 3

last := lo.LastOr([]int{}, 31)
// 31
Nth

Returns the element at index nth of collection. If nth is negative, the nth element from the end is returned. An error is returned when nth is out of slice bounds.

nth, err := lo.Nth([]int{0, 1, 2, 3}, 2)
// 2

nth, err := lo.Nth([]int{0, 1, 2, 3}, -2)
// 2
Sample

Returns a random item from collection.

lo.Sample([]string{"a", "b", "c"})
// a random string from []string{"a", "b", "c"}

lo.Sample([]string{})
// ""
Samples

Returns N random unique items from collection.

lo.Samples([]string{"a", "b", "c"}, 3)
// []string{"a", "b", "c"} in random order
Ternary

A 1 line if/else statement.

result := lo.Ternary(true, "a", "b")
// "a"

result := lo.Ternary(false, "a", "b")
// "b"

[play]

TernaryF

A 1 line if/else statement whose options are functions.

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

result := lo.TernaryF(false, func() string { return "a" }, func() string { return "b" })
// "b"

Useful to avoid nil-pointer dereferencing in initializations, or avoid running unnecessary code

var s *string

someStr := TernaryF(s == nil, func() string { return uuid.New().String() }, func() string { return *s })
// ef782193-c30c-4e2e-a7ae-f8ab5e125e02

[play]

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

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

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

Using callbacks:

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

Mixed:

result := lo.IfF(true, func () int {
        return 1
    }).
    Else(42)
// 1

[play]

Switch / Case / Default
result := lo.Switch(1).
    Case(1, "1").
    Case(2, "2").
    Default("3")
// "1"

result := lo.Switch(2).
    Case(1, "1").
    Case(2, "2").
    Default("3")
// "2"

result := lo.Switch(42).
    Case(1, "1").
    Case(2, "2").
    Default("3")
// "3"

Using callbacks:

result := lo.Switch(1).
    CaseF(1, func() string {
        return "1"
    }).
    CaseF(2, func() string {
        return "2"
    }).
    DefaultF(func() string {
        return "3"
    })
// "1"

Mixed:

result := lo.Switch(1).
    CaseF(1, func() string {
        return "1"
    }).
    Default("42")
// "1"

[play]

IsNil

Checks if a value is nil or if it's a reference type with a nil underlying value.

var x int
IsNil(x))
// false

var k struct{}
IsNil(k)
// false

var i *int
IsNil(i)
// true

var ifaceWithNilValue any = (*string)(nil)
IsNil(ifaceWithNilValue)
// true
ifaceWithNilValue == nil
// false
ToPtr

Returns a pointer copy of the value.

ptr := lo.ToPtr("hello world")
// *string{"hello world"}
Nil

Returns a nil pointer of type.

ptr := lo.Nil[float64]()
// nil
EmptyableToPtr

Returns a pointer copy of value if it's nonzero. Otherwise, returns nil pointer.

ptr := lo.EmptyableToPtr(nil)
// nil

ptr := lo.EmptyableToPtr("")
// nil

ptr := lo.EmptyableToPtr([]int{})
// *[]int{}

ptr := lo.EmptyableToPtr("hello world")
// *string{"hello world"}
FromPtr

Returns the pointer value or empty.

str := "hello world"
value := lo.FromPtr(&str)
// "hello world"

value := lo.FromPtr(nil)
// ""
FromPtrOr

Returns the pointer value or the fallback value.

str := "hello world"
value := lo.FromPtrOr(&str, "empty")
// "hello world"

value := lo.FromPtrOr(nil, "empty")
// "empty"
ToSlicePtr

Returns a slice of pointer copy of value.

ptr := lo.ToSlicePtr([]string{"hello", "world"})
// []*string{"hello", "world"}
FromSlicePtr

Returns a slice with the pointer values. Returns a zero value in case of a nil pointer element.

str1 := "hello"
str2 := "world"

ptr := lo.FromSlicePtr[string]([]*string{&str1, &str2, nil})
// []string{"hello", "world", ""}

ptr := lo.Compact(
    lo.FromSlicePtr[string]([]*string{&str1, &str2, nil}),
)
// []string{"hello", "world"}
FromSlicePtrOr

Returns a slice with the pointer values or the fallback value.

str1 := "hello"
str2 := "world"

ptr := lo.FromSlicePtrOr[string]([]*string{&str1, &str2, "fallback value"})
// []string{"hello", "world", "fallback value"}
ToAnySlice

Returns a slice with all elements mapped to any type.

elements := lo.ToAnySlice([]int{1, 5, 1})
// []any{1, 5, 1}
FromAnySlice

Returns an any slice with all elements mapped to a type. Returns false in case of type conversion failure.

elements, ok := lo.FromAnySlice([]any{"foobar", 42})
// []string{}, false

elements, ok := lo.FromAnySlice([]any{"foobar", "42"})
// []string{"foobar", "42"}, true
Empty

Returns an empty value.

lo.Empty[int]()
// 0
lo.Empty[string]()
// ""
lo.Empty[bool]()
// false
IsEmpty

Returns true if argument is a zero value.

lo.IsEmpty(0)
// true
lo.IsEmpty(42)
// false

lo.IsEmpty("")
// true
lo.IsEmpty("foobar")
// false

type test struct {
    foobar string
}

lo.IsEmpty(test{foobar: ""})
// true
lo.IsEmpty(test{foobar: "foobar"})
// false
IsNotEmpty

Returns true if argument is a zero value.

lo.IsNotEmpty(0)
// false
lo.IsNotEmpty(42)
// true

lo.IsNotEmpty("")
// false
lo.IsNotEmpty("foobar")
// true

type test struct {
    foobar string
}

lo.IsNotEmpty(test{foobar: ""})
// false
lo.IsNotEmpty(test{foobar: "foobar"})
// true
Coalesce

Returns the first non-empty arguments. Arguments must be comparable.

result, ok := lo.Coalesce(0, 1, 2, 3)
// 1 true

result, ok := lo.Coalesce("")
// "" false

var nilStr *string
str := "foobar"
result, ok := lo.Coalesce(nil, nilStr, &str)
// &"foobar" true
CoalesceOrEmpty

Returns the first non-empty arguments. Arguments must be comparable.

result := lo.CoalesceOrEmpty(0, 1, 2, 3)
// 1

result := lo.CoalesceOrEmpty("")
// ""

var nilStr *string
str := "foobar"
result := lo.CoalesceOrEmpty(nil, nilStr, &str)
// &"foobar"
Partial

Returns new function that, when called, has its first argument set to the provided value.

add := func(x, y int) int { return x + y }
f := lo.Partial(add, 5)

f(10)
// 15

f(42)
// 47
Partial2 -> Partial5

Returns new function that, when called, has its first argument set to the provided value.

add := func(x, y, z int) int { return x + y + z }
f := lo.Partial2(add, 42)

f(10, 5)
// 57

f(42, -4)
// 80
Attempt

Invokes a function N times until it returns valid output. Returning either the caught error or nil. When first argument is less than 1, the function runs until a successful response is returned.

iter, err := lo.Attempt(42, func(i int) error {
    if i == 5 {
        return nil
    }

    return fmt.Errorf("failed")
})
// 6
// nil

iter, err := lo.Attempt(2, func(i int) error {
    if i == 5 {
        return nil
    }

    return fmt.Errorf("failed")
})
// 2
// error "failed"

iter, err := lo.Attempt(0, func(i int) error {
    if i < 42 {
        return fmt.Errorf("failed")
    }

    return nil
})
// 43
// nil

For more advanced retry strategies (delay, exponential backoff...), please take a look on cenkalti/backoff.

[play]

AttemptWithDelay

Invokes a function N times until it returns valid output, with a pause between each call. Returning either the caught error or nil.

When first argument is less than 1, the function runs until a successful response is returned.

iter, duration, err := lo.AttemptWithDelay(5, 2*time.Second, func(i int, duration time.Duration) error {
    if i == 2 {
        return nil
    }

    return fmt.Errorf("failed")
})
// 3
// ~ 4 seconds
// nil

For more advanced retry strategies (delay, exponential backoff...), please take a look on cenkalti/backoff.

[play]

AttemptWhile

Invokes a function N times until it returns valid output. Returning either the caught error or nil, and along with a bool value to identifying whether it needs invoke function continuously. It will terminate the invoke immediately if second bool value is returned with falsy value.

When first argument is less than 1, the function runs until a successful response is returned.

count1, err1 := lo.AttemptWhile(5, func(i int) (error, bool) {
    err := doMockedHTTPRequest(i)
    if err != nil {
        if errors.Is(err, ErrBadRequest) { // lets assume ErrBadRequest is a critical error that needs to terminate the invoke
            return err, false // flag the second return value as false to terminate the invoke
        }

        return err, true
    }

    return nil, false
})

For more advanced retry strategies (delay, exponential backoff...), please take a look on cenkalti/backoff.

[play]

AttemptWhileWithDelay

Invokes a function N times until it returns valid output, with a pause between each call. Returning either the caught error or nil, and along with a bool value to identifying whether it needs to invoke function continuously. It will terminate the invoke immediately if second bool value is returned with falsy value.

When first argument is less than 1, the function runs until a successful response is returned.

count1, time1, err1 := lo.AttemptWhileWithDelay(5, time.Millisecond, func(i int, d time.Duration) (error, bool) {
    err := doMockedHTTPRequest(i)
    if err != nil {
        if errors.Is(err, ErrBadRequest) { // lets assume ErrBadRequest is a critical error that needs to terminate the invoke
            return err, false // flag the second return value as false to terminate the invoke
        }

        return err, true
    }

    return nil, false
})

For more advanced retry strategies (delay, exponential backoff...), please take a look on cenkalti/backoff.

[play]

Debounce

NewDebounce creates a debounced instance that delays invoking functions given until after wait milliseconds have elapsed, until cancel is called.

f := func() {
    println("Called once after 100ms when debounce stopped invoking!")
}

debounce, cancel := lo.NewDebounce(100 * time.Millisecond, f)
for j := 0; j < 10; j++ {
    debounce()
}

time.Sleep(1 * time.Second)
cancel()

[play]

DebounceBy

NewDebounceBy creates a debounced instance for each distinct key, that delays invoking functions given until after wait milliseconds have elapsed, until cancel is called.

f := func(key string, count int) {
    println(key + ": Called once after 100ms when debounce stopped invoking!")
}

debounce, cancel := lo.NewDebounceBy(100 * time.Millisecond, f)
for j := 0; j < 10; j++ {
    debounce("first key")
    debounce("second key")
}

time.Sleep(1 * time.Second)
cancel("first key")
cancel("second key")

[play]

Synchronize

Wraps the underlying callback in a mutex. It receives an optional mutex.

s := lo.Synchronize()

for i := 0; i < 10; i++ {
    go s.Do(func () {
        println("will be called sequentially")
    })
}

It is equivalent to:

mu := sync.Mutex{}

func foobar() {
    mu.Lock()
    defer mu.Unlock()

    // ...
}
Async

Executes a function in a goroutine and returns the result in a channel.

ch := lo.Async(func() error { time.Sleep(10 * time.Second); return nil })
// chan error (nil)
Async{0->6}

Executes a function in a goroutine and returns the result in a channel. For function with multiple return values, the results will be returned as a tuple inside the channel. For function without return, struct{} will be returned in the channel.

ch := lo.Async0(func() { time.Sleep(10 * time.Second) })
// chan struct{}

ch := lo.Async1(func() int {
  time.Sleep(10 * time.Second);
  return 42
})
// chan int (42)

ch := lo.Async2(func() (int, string) {
  time.Sleep(10 * time.Second);
  return 42, "Hello"
})
// chan lo.Tuple2[int, string] ({42, "Hello"})
Transaction

Implements a Saga pattern.

transaction := NewTransaction().
    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, fmt.Errorf("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
WaitFor

Runs periodically until a condition is validated.

alwaysTrue := func(i int) bool { return true }
alwaysFalse := func(i int) bool { return false }
laterTrue := func(i int) bool {
    return i > 5
}

iterations, duration, ok := lo.WaitFor(alwaysTrue, 10*time.Millisecond, 2 * time.Millisecond)
// 1
// 1ms
// true

iterations, duration, ok := lo.WaitFor(alwaysFalse, 10*time.Millisecond, time.Millisecond)
// 10
// 10ms
// false

iterations, duration, ok := lo.WaitFor(laterTrue, 10*time.Millisecond, time.Millisecond)
// 7
// 7ms
// true

iterations, duration, ok := lo.WaitFor(laterTrue, 10*time.Millisecond, 5*time.Millisecond)
// 2
// 10ms
// false
WaitForWithContext

Runs periodically until a condition is validated or context is invalid.

The condition receives also the context, so it can invalidate the process in the condition checker

ctx := context.Background()

alwaysTrue := func(_ context.Context, i int) bool { return true }
alwaysFalse := func(_ context.Context, i int) bool { return false }
laterTrue := func(_ context.Context, i int) bool {
    return i >= 5
}

iterations, duration, ok := lo.WaitForWithContext(ctx, alwaysTrue, 10*time.Millisecond, 2 * time.Millisecond)
// 1
// 1ms
// true

iterations, duration, ok := lo.WaitForWithContext(ctx, alwaysFalse, 10*time.Millisecond, time.Millisecond)
// 10
// 10ms
// false

iterations, duration, ok := lo.WaitForWithContext(ctx, laterTrue, 10*time.Millisecond, time.Millisecond)
// 5
// 5ms
// true

iterations, duration, ok := lo.WaitForWithContext(ctx, laterTrue, 10*time.Millisecond, 5*time.Millisecond)
// 2
// 10ms
// false

expiringCtx, cancel := context.WithTimeout(ctx, 5*time.Millisecond)
iterations, duration, ok := lo.WaitForWithContext(expiringCtx, alwaysFalse, 100*time.Millisecond, time.Millisecond)
// 5
// 5.1ms
// false
Validate

Helper function that creates an error when a condition is not met.

slice := []string{"a"}
val := lo.Validate(len(slice) == 0, "Slice should be empty but contains %v", slice)
// error("Slice should be empty but contains [a]")

slice := []string{}
val := lo.Validate(len(slice) == 0, "Slice should be empty but contains %v", slice)
// nil

[play]

Must

Wraps a function call to panics if second argument is error or false, returns the value otherwise.

val := lo.Must(time.Parse("2006-01-02", "2022-01-15"))
// 2022-01-15

val := lo.Must(time.Parse("2006-01-02", "bad-value"))
// panics

[play]

Must{0->6}

Must* has the same behavior as Must, but returns multiple values.

func example0() (error)
func example1() (int, error)
func example2() (int, string, error)
func example3() (int, string, time.Date, error)
func example4() (int, string, time.Date, bool, error)
func example5() (int, string, time.Date, bool, float64, error)
func example6() (int, string, time.Date, bool, float64, byte, error)

lo.Must0(example0())
val1 := lo.Must1(example1())    // alias to Must
val1, val2 := lo.Must2(example2())
val1, val2, val3 := lo.Must3(example3())
val1, val2, val3, val4 := lo.Must4(example4())
val1, val2, val3, val4, val5 := lo.Must5(example5())
val1, val2, val3, val4, val5, val6 := lo.Must6(example6())

You can wrap functions like func (...) (..., ok bool).

// math.Signbit(float64) bool
lo.Must0(math.Signbit(v))

// bytes.Cut([]byte,[]byte) ([]byte, []byte, bool)
before, after := lo.Must2(bytes.Cut(s, sep))

You can give context to the panic message by adding some printf-like arguments.

val, ok := lo.Find(myString, func(i string) bool {
    return i == requiredChar
})
lo.Must0(ok, "'%s' must always contain '%s'", myString, requiredChar)

list := []int{0, 1, 2}
item := 5
lo.Must0(lo.Contains(list, item), "'%s' must always contain '%s'", list, item)
...

[play]

Try

Calls the function and returns false in case of error and panic.

ok := lo.Try(func() error {
    panic("error")
    return nil
})
// false

ok := lo.Try(func() error {
    return nil
})
// true

ok := lo.Try(func() error {
    return fmt.Errorf("error")
})
// false

[play]

Try{0->6}

The same behavior as Try, but the callback returns 2 variables.

ok := lo.Try2(func() (string, error) {
    panic("error")
    return "", nil
})
// false

[play]

TryOr

Calls the function and return a default value in case of error and on panic.

str, ok := lo.TryOr(func() (string, error) {
    panic("error")
    return "hello", nil
}, "world")
// world
// false

str, ok := lo.TryOr(func() error {
    return "hello", nil
}, "world")
// hello
// true

str, ok := lo.TryOr(func() error {
    return "hello", fmt.Errorf("error")
}, "world")
// world
// false

[play]

TryOr{0->6}

The same behavior as TryOr, but the callback returns X variables.

str, nbr, ok := lo.TryOr2(func() (string, int, error) {
    panic("error")
    return "hello", 42, nil
}, "world", 21)
// world
// 21
// false

[play]

TryWithErrorValue

The same behavior as Try, but also returns the value passed to panic.

err, ok := lo.TryWithErrorValue(func() error {
    panic("error")
    return nil
})
// "error", false

[play]

TryCatch

The same behavior as Try, but calls the catch function in case of error.

caught := false

ok := lo.TryCatch(func() error {
    panic("error")
    return nil
}, func() {
    caught = true
})
// false
// caught == true

[play]

TryCatchWithErrorValue

The same behavior as TryWithErrorValue, but calls the catch function in case of error.

caught := false

ok := lo.TryCatchWithErrorValue(func() error {
    panic("error")
    return nil
}, func(val any) {
    caught = val == "error"
})
// false
// caught == true

[play]

ErrorsAs

A shortcut for:

err := doSomething()

var rateLimitErr *RateLimitError
if ok := errors.As(err, &rateLimitErr); ok {
    // retry later
}

1 line lo helper:

err := doSomething()

if rateLimitErr, ok := lo.ErrorsAs[*RateLimitError](err); ok {
    // retry later
}

[play]

🛩 Benchmark

We executed a simple benchmark with a dead-simple lo.Map loop:

See the full implementation here.

_ = lo.Map[int64](arr, func(x int64, i int) string {
    return strconv.FormatInt(x, 10)
})

Result:

Here is a comparison between lo.Map, lop.Map, go-funk library and a simple Go for loop.

$ go test -benchmem -bench ./...
goos: linux
goarch: amd64
pkg: github.com/samber/lo
cpu: Intel(R) Core(TM) i5-7267U CPU @ 3.10GHz
cpu: Intel(R) Core(TM) i7 CPU         920  @ 2.67GHz
BenchmarkMap/lo.Map-8         	       8	 132728237 ns/op	39998945 B/op	 1000002 allocs/op
BenchmarkMap/lop.Map-8        	       2	 503947830 ns/op	119999956 B/op	 3000007 allocs/op
BenchmarkMap/reflect-8        	       2	 826400560 ns/op	170326512 B/op	 4000042 allocs/op
BenchmarkMap/for-8            	       9	 126252954 ns/op	39998674 B/op	 1000001 allocs/op
PASS
ok  	github.com/samber/lo	6.657s
  • lo.Map is way faster (x7) than go-funk, a reflection-based Map implementation.
  • lo.Map have the same allocation profile than for.
  • lo.Map is 4% slower than for.
  • lop.Map is slower than lo.Map because it implies more memory allocation and locks. lop.Map will be useful for long-running callbacks, such as i/o bound processing.
  • for beats other implementations for memory and CPU.

🤝 Contributing

Don't hesitate ;)

Helper naming: helpers must be self-explanatory and respect standards (other languages, libraries...). Feel free to suggest many names in your contributions.

With Docker
docker-compose run --rm dev
Without Docker
# Install some dev dependencies
make tools

# Run tests
make test
# or
make watch-test

👤 Contributors

Contributors

💫 Show your support

Give a ⭐️ if this project helped you!

GitHub Sponsors

📝 License

Copyright © 2022 Samuel Berthe.

This project is under MIT license.

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	LowerCaseLettersCharset = []rune("abcdefghijklmnopqrstuvwxyz")
	UpperCaseLettersCharset = []rune("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
	LettersCharset          = append(LowerCaseLettersCharset, UpperCaseLettersCharset...)
	NumbersCharset          = []rune("0123456789")
	AlphanumericCharset     = append(LettersCharset, NumbersCharset...)
	SpecialCharset          = []rune("!@#$%^&*()_+-=[]{}|;':\",./<>?")
	AllCharset              = append(AlphanumericCharset, SpecialCharset...)
)

Functions

func Assign 

func Assign[K comparable, V any, Map ~map[K]V](maps ...Map) Map

Assign merges multiple maps from left to right. Play: https://go.dev/play/p/VhwfJOyxf5o

func Associate added in v1.26.0 

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

Associate returns a map containing key-value pairs provided by transform function applied to elements of the given slice. If any of two pairs would have the same key the last one gets added to the map. The order of keys in returned map is not specified and is not guaranteed to be the same from the original array. Play: https://go.dev/play/p/WHa2CfMO3Lr

func Async added in v1.12.0 

func Async[A any](f func() A) <-chan A

Async executes a function in a goroutine and returns the result in a channel.

func Async0 added in v1.17.0 

func Async0(f func()) <-chan struct{}

Async0 executes a function in a goroutine and returns a channel set once the function finishes.

func Async1 added in v1.17.0 

func Async1[A any](f func() A) <-chan A

Async1 is an alias to Async.

func Async2 added in v1.17.0 

func Async2[A, B any](f func() (A, B)) <-chan Tuple2[A, B]

Async2 has the same behavior as Async, but returns the 2 results as a tuple inside the channel.

func Async3 added in v1.17.0 

func Async3[A, B, C any](f func() (A, B, C)) <-chan Tuple3[A, B, C]

Async3 has the same behavior as Async, but returns the 3 results as a tuple inside the channel.

func Async4 added in v1.17.0 

func Async4[A, B, C, D any](f func() (A, B, C, D)) <-chan Tuple4[A, B, C, D]

Async4 has the same behavior as Async, but returns the 4 results as a tuple inside the channel.

func Async5 added in v1.17.0 

func Async5[A, B, C, D, E any](f func() (A, B, C, D, E)) <-chan Tuple5[A, B, C, D, E]

Async5 has the same behavior as Async, but returns the 5 results as a tuple inside the channel.

func Async6 added in v1.17.0 

func Async6[A, B, C, D, E, F any](f func() (A, B, C, D, E, F)) <-chan Tuple6[A, B, C, D, E, F]

Async6 has the same behavior as Async, but returns the 6 results as a tuple inside the channel.

func Attempt added in v1.5.0 

func Attempt(maxIteration int, f func(index int) error) (int, error)

Attempt invokes a function N times until it returns valid output. Returning either the caught error or nil. When first argument is less than `1`, the function runs until a successful response is returned. Play: https://go.dev/play/p/3ggJZ2ZKcMj

func AttemptWhile added in v1.36.0 

func AttemptWhile(maxIteration int, f func(int) (error, bool)) (int, error)

AttemptWhile invokes a function N times until it returns valid output. Returning either the caught error or nil, and along with a bool value to identify whether it needs invoke function continuously. It will terminate the invoke immediately if second bool value is returned with falsy value. When first argument is less than `1`, the function runs until a successful response is returned.

func AttemptWhileWithDelay added in v1.36.0 

func AttemptWhileWithDelay(maxIteration int, delay time.Duration, f func(int, time.Duration) (error, bool)) (int, time.Duration, error)

AttemptWhileWithDelay invokes a function N times until it returns valid output, with a pause between each call. Returning either the caught error or nil, and along with a bool value to identify whether it needs to invoke function continuously. It will terminate the invoke immediately if second bool value is returned with falsy value. When first argument is less than `1`, the function runs until a successful response is returned.

func AttemptWithDelay added in v1.16.0 

func AttemptWithDelay(maxIteration int, delay time.Duration, f func(index int, duration time.Duration) error) (int, time.Duration, error)

AttemptWithDelay invokes a function N times until it returns valid output, with a pause between each call. Returning either the caught error or nil. When first argument is less than `1`, the function runs until a successful response is returned. Play: https://go.dev/play/p/tVs6CygC7m1

func Batch deprecated added in v1.31.0 

func Batch[T any](ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool)

Batch creates a slice of n elements from a channel. Returns the slice and the slice length.

Deprecated: Use Buffer instead.

func BatchWithTimeout deprecated added in v1.31.0 

func BatchWithTimeout[T any](ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool)

BatchWithTimeout creates a slice of n elements from a channel, with timeout. Returns the slice and the slice length.

Deprecated: Use BufferWithTimeout instead.

func Buffer added in v1.35.0 

func Buffer[T any](ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool)

Buffer creates a slice of n elements from a channel. Returns the slice and the slice length. @TODO: we should probably provide an helper that reuse the same buffer.

func BufferWithTimeout added in v1.35.0 

func BufferWithTimeout[T any](ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool)

BufferWithTimeout creates a slice of n elements from a channel, with timeout. Returns the slice and the slice length. @TODO: we should probably provide an helper that reuse the same buffer.

func CamelCase added in v1.40.0 

func CamelCase(str string) string

CamelCase converts string to camel case.

func Capitalize added in v1.40.0 

func Capitalize(str string) string

Capitalize converts the first character of string to upper case and the remaining to lower case.

func ChannelDispatcher added in v1.28.0 

func ChannelDispatcher[T any](stream <-chan T, count int, channelBufferCap int, strategy DispatchingStrategy[T]) []<-chan T

ChannelDispatcher distributes messages from input channels into N child channels. Close events are propagated to children. Underlying channels can have a fixed buffer capacity or be unbuffered when cap is 0.

func ChannelMerge deprecated added in v1.33.0 

func ChannelMerge[T any](channelBufferCap int, upstreams ...<-chan T) <-chan T

ChannelMerge collects messages from multiple input channels into a single buffered channel. Output messages has no priority. When all upstream channels reach EOF, downstream channel closes.

Deprecated: Use FanIn instead.

func ChannelToSlice added in v1.32.0 

func ChannelToSlice[T any](ch <-chan T) []T

ChannelToSlice returns a slice built from channels items. Blocks until channel closes.

func Chunk 

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

Chunk returns an array of elements split into groups the length of size. If array can't be split evenly, the final chunk will be the remaining elements. Play: https://go.dev/play/p/EeKl0AuTehH

func ChunkString added in v1.27.0 

func ChunkString[T ~string](str T, size int) []T

ChunkString returns an array of strings split into groups the length of size. If array can't be split evenly, the final chunk will be the remaining elements. Play: https://go.dev/play/p/__FLTuJVz54

func Clamp added in v1.13.0 

func Clamp[T constraints.Ordered](value T, min T, max T) T

Clamp clamps number within the inclusive lower and upper bounds. Play: https://go.dev/play/p/RU4lJNC2hlI

func Coalesce added in v1.14.0 

func Coalesce[T comparable](values ...T) (result T, ok bool)

Coalesce returns the first non-empty arguments. Arguments must be comparable.

func CoalesceOrEmpty added in v1.41.0 

func CoalesceOrEmpty[T comparable](v ...T) T

CoalesceOrEmpty returns the first non-empty arguments. Arguments must be comparable.

func Compact added in v1.22.0 

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

Compact returns a slice of all non-zero elements. Play: https://go.dev/play/p/tXiy-iK6PAc

func Contains 

func Contains[T comparable](collection []T, element T) bool

Contains returns true if an element is present in a collection.

func ContainsBy added in v1.7.0 

func ContainsBy[T any](collection []T, predicate func(item T) bool) bool

ContainsBy returns true if predicate function return true.

func Count added in v1.12.0 

func Count[T comparable](collection []T, value T) (count int)

Count counts the number of elements in the collection that compare equal to value. Play: https://go.dev/play/p/Y3FlK54yveC

func CountBy added in v1.12.0 

func CountBy[T any](collection []T, predicate func(item T) bool) (count int)

CountBy counts the number of elements in the collection for which predicate is true. Play: https://go.dev/play/p/ByQbNYQQi4X

func CountValues added in v1.32.0 

func CountValues[T comparable](collection []T) map[T]int

CountValues counts the number of each element in the collection. Play: https://go.dev/play/p/-p-PyLT4dfy

func CountValuesBy added in v1.32.0 

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

CountValuesBy counts the number of each element return from mapper function. Is equivalent to chaining lo.Map and lo.CountValues. Play: https://go.dev/play/p/2U0dG1SnOmS

func Difference 

func Difference[T comparable, Slice ~[]T](list1 Slice, list2 Slice) (Slice, Slice)

Difference returns the difference between two collections. The first value is the collection of element absent of list2. The second value is the collection of element absent of list1.

func DispatchingStrategyFirst added in v1.28.0 

func DispatchingStrategyFirst[T any](msg T, index uint64, channels []<-chan T) int

DispatchingStrategyFirst distributes messages in the first non-full channel. If the capacity of the first channel is exceeded, the second channel will be selected and so on.

func DispatchingStrategyLeast added in v1.28.0 

func DispatchingStrategyLeast[T any](msg T, index uint64, channels []<-chan T) int

DispatchingStrategyLeast distributes messages in the emptiest channel.

func DispatchingStrategyMost added in v1.28.0 

func DispatchingStrategyMost[T any](msg T, index uint64, channels []<-chan T) int

DispatchingStrategyMost distributes messages in the fullest channel. If the channel capacity is exceeded, the next channel will be selected and so on.

func DispatchingStrategyRandom added in v1.28.0 

func DispatchingStrategyRandom[T any](msg T, index uint64, channels []<-chan T) int

DispatchingStrategyRandom distributes messages in a random manner. If the channel capacity is exceeded, another random channel will be selected and so on.

func DispatchingStrategyRoundRobin added in v1.28.0 

func DispatchingStrategyRoundRobin[T any](msg T, index uint64, channels []<-chan T) int

DispatchingStrategyRoundRobin distributes messages in a rotating sequential manner. If the channel capacity is exceeded, the next channel will be selected and so on.

func Drop added in v1.9.0 

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

Drop drops n elements from the beginning of a slice or array. Play: https://go.dev/play/p/JswS7vXRJP2

func DropByIndex added in v1.44.0 

func DropByIndex[T any](collection []T, indexes ...int) []T

DropByIndex drops elements from a slice or array by the index. A negative index will drop elements from the end of the slice. Play: https://go.dev/play/p/bPIH4npZRxS

func DropRight added in v1.9.0 

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

DropRight drops n elements from the end of a slice or array. Play: https://go.dev/play/p/GG0nXkSJJa3

func DropRightWhile added in v1.9.0 

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

DropRightWhile drops elements from the end of a slice or array while the predicate returns true. Play: https://go.dev/play/p/3-n71oEC0Hz

func DropWhile added in v1.9.0 

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

DropWhile drops elements from the beginning of a slice or array while the predicate returns true. Play: https://go.dev/play/p/7gBPYw2IK16

func Duration added in v1.41.0 

func Duration(cb func()) time.Duration

Duration returns the time taken to execute a function.

func Duration0 added in v1.41.0 

func Duration0(cb func()) time.Duration

Duration0 returns the time taken to execute a function.

func Duration1 added in v1.41.0 

func Duration1[A any](cb func() A) (A, time.Duration)

Duration1 returns the time taken to execute a function.

func Duration10 added in v1.41.0 

func Duration10[A, B, C, D, E, F, G, H, I, J any](cb func() (A, B, C, D, E, F, G, H, I, J)) (A, B, C, D, E, F, G, H, I, J, time.Duration)

Duration10 returns the time taken to execute a function.

func Duration2 added in v1.41.0 

func Duration2[A, B any](cb func() (A, B)) (A, B, time.Duration)

Duration2 returns the time taken to execute a function.

func Duration3 added in v1.41.0 

func Duration3[A, B, C any](cb func() (A, B, C)) (A, B, C, time.Duration)

Duration3 returns the time taken to execute a function.

func Duration4 added in v1.41.0 

func Duration4[A, B, C, D any](cb func() (A, B, C, D)) (A, B, C, D, time.Duration)

Duration4 returns the time taken to execute a function.

func Duration5 added in v1.41.0 

func Duration5[A, B, C, D, E any](cb func() (A, B, C, D, E)) (A, B, C, D, E, time.Duration)

Duration5 returns the time taken to execute a function.

func Duration6 added in v1.41.0 

func Duration6[A, B, C, D, E, F any](cb func() (A, B, C, D, E, F)) (A, B, C, D, E, F, time.Duration)

Duration6 returns the time taken to execute a function.

func Duration7 added in v1.41.0 

func Duration7[A, B, C, D, E, F, G any](cb func() (A, B, C, D, E, F, G)) (A, B, C, D, E, F, G, time.Duration)

Duration7 returns the time taken to execute a function.

func Duration8 added in v1.41.0 

func Duration8[A, B, C, D, E, F, G, H any](cb func() (A, B, C, D, E, F, G, H)) (A, B, C, D, E, F, G, H, time.Duration)

Duration8 returns the time taken to execute a function.

func Duration9 added in v1.41.0 

func Duration9[A, B, C, D, E, F, G, H, I any](cb func() (A, B, C, D, E, F, G, H, I)) (A, B, C, D, E, F, G, H, I, time.Duration)

Duration9 returns the time taken to execute a function.

func Earliest added in v1.41.0 

func Earliest(times ...time.Time) time.Time

Earliest search the minimum time.Time of a collection. Returns zero value when the collection is empty.

func EarliestBy added in v1.45.0 

func EarliestBy[T any](collection []T, iteratee func(item T) time.Time) T

EarliestBy search the minimum time.Time of a collection using the given iteratee function. Returns zero value when the collection is empty.

func Elipse added in v1.41.0 

func Elipse(str string, length int) string

Elipse truncates a string to a specified length and appends an ellipsis if truncated.

func Empty added in v1.6.0 

func Empty[T any]() T

Empty returns an empty value.

func EmptyableToPtr added in v1.38.0 

func EmptyableToPtr[T any](x T) *T

EmptyableToPtr returns a pointer copy of value if it's nonzero. Otherwise, returns nil pointer.

func ErrorsAs added in v1.29.0 

func ErrorsAs[T error](err error) (T, bool)

ErrorsAs is a shortcut for errors.As(err, &&T). Play: https://go.dev/play/p/8wk5rH8UfrE

func Every 

func Every[T comparable](collection []T, subset []T) bool

Every returns true if all elements of a subset are contained into a collection or if the subset is empty.

func EveryBy added in v1.18.0 

func EveryBy[T any](collection []T, predicate func(item T) bool) bool

EveryBy returns true if the predicate returns true for all of the elements in the collection or if the collection is empty.

func FanIn added in v1.34.0 

func FanIn[T any](channelBufferCap int, upstreams ...<-chan T) <-chan T

FanIn collects messages from multiple input channels into a single buffered channel. Output messages has no priority. When all upstream channels reach EOF, downstream channel closes.

func FanOut added in v1.34.0 

func FanOut[T any](count int, channelsBufferCap int, upstream <-chan T) []<-chan T

FanOut broadcasts all the upstream messages to multiple downstream channels. When upstream channel reach EOF, downstream channels close. If any downstream channels is full, broadcasting is paused.

func Fill 

func Fill[T Clonable[T]](collection []T, initial T) []T

Fill fills elements of array with `initial` value. Play: https://go.dev/play/p/VwR34GzqEub

func Filter 

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

Filter iterates over elements of collection, returning an array of all elements predicate returns truthy for. Play: https://go.dev/play/p/Apjg3WeSi7K

func FilterMap added in v1.12.0 

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

FilterMap returns a slice which 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.

Play: https://go.dev/play/p/-AuYXfy7opz

func FilterReject added in v1.41.0 

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

FilterReject mixes Filter and Reject, this method returns two slices, one for the elements of collection that predicate returns truthy for and one for the elements that predicate does not return truthy for.

func Find 

func Find[T any](collection []T, predicate func(item T) bool) (T, bool)

Find search an element in a slice based on a predicate. It returns element and true if element was found.

func FindDuplicates added in v1.25.0 

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

FindDuplicates returns a slice with the first occurrence of each duplicated elements of the collection. The order of result values is determined by the order they occur in the collection.

func FindDuplicatesBy added in v1.25.0 

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

FindDuplicatesBy returns a slice with the first occurrence of each duplicated elements of the collection. The order of result values is determined by the order they occur in the array. It accepts `iteratee` which is invoked for each element in array to generate the criterion by which uniqueness is computed.

func FindIndexOf added in v1.12.0 

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

FindIndexOf searches an element in a slice based on a predicate and returns the index and true. It returns -1 and false if the element is not found.

func FindKey added in v1.23.0 

func FindKey[K comparable, V comparable](object map[K]V, value V) (K, bool)

FindKey returns the key of the first value matching.

func FindKeyBy added in v1.23.0 

func FindKeyBy[K comparable, V any](object map[K]V, predicate func(key K, value V) bool) (K, bool)

FindKeyBy returns the key of the first element predicate returns truthy for.

func FindLastIndexOf added in v1.12.0 

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

FindLastIndexOf searches last element in a slice based on a predicate and returns the index and true. It returns -1 and false if the element is not found.

func FindOrElse added in v1.12.0 

func FindOrElse[T any](collection []T, fallback T, predicate func(item T) bool) T

FindOrElse search an element in a slice based on a predicate. It returns the element if found or a given fallback value otherwise.

func FindUniques added in v1.25.0 

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

FindUniques returns a slice with all the unique elements of the collection. The order of result values is determined by the order they occur in the collection.

func FindUniquesBy added in v1.25.0 

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

FindUniquesBy returns a slice with all the unique elements of the collection. The order of result values is determined by the order they occur in the array. It accepts `iteratee` which is invoked for each element in array to generate the criterion by which uniqueness is computed.

func First added in v1.42.0 

func First[T any](collection []T) (T, bool)

First returns the first element of a collection and check for availability of the first element.

func FirstOr added in v1.42.0 

func FirstOr[T any](collection []T, fallback T) T

FirstOr returns the first element of a collection or the fallback value if empty.

func FirstOrEmpty added in v1.42.0 

func FirstOrEmpty[T any](collection []T) T

FirstOrEmpty returns the first element of a collection or zero value if empty.

func FlatMap added in v1.7.0 

func FlatMap[T any, R any](collection []T, iteratee func(item T, index int) []R) []R

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. Play: https://go.dev/play/p/YSoYmQTA8-U

func Flatten 

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

Flatten returns an array a single level deep. Play: https://go.dev/play/p/rbp9ORaMpjw

func ForEach 

func ForEach[T any](collection []T, iteratee func(item T, index int))

ForEach iterates over elements of collection and invokes iteratee for each element. Play: https://go.dev/play/p/oofyiUPRf8t

func ForEachWhile added in v1.46.0 

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

ForEachWhile iterates over elements of collection and invokes iteratee for each element collection return value decide to continue or break, like do while(). Play: https://go.dev/play/p/QnLGt35tnow

func FromAnySlice added in v1.21.0 

func FromAnySlice[T any](in []any) (out []T, ok bool)

FromAnySlice returns an `any` slice with all elements mapped to a type. Returns false in case of type conversion failure.

func FromEntries 

func FromEntries[K comparable, V any](entries []Entry[K, V]) map[K]V

FromEntries transforms an array of key/value pairs into a map. Play: https://go.dev/play/p/oIr5KHFGCEN

func FromPairs added in v1.22.0 

func FromPairs[K comparable, V any](entries []Entry[K, V]) map[K]V

FromPairs transforms an array of key/value pairs into a map. Alias of FromEntries(). Play: https://go.dev/play/p/oIr5KHFGCEN

func FromPtr added in v1.22.0 

func FromPtr[T any](x *T) T

FromPtr returns the pointer value or empty.

func FromPtrOr added in v1.26.0 

func FromPtrOr[T any](x *T, fallback T) T

FromPtrOr returns the pointer value or the fallback value.

func FromSlicePtr added in v1.47.0 

func FromSlicePtr[T any](collection []*T) []T

FromSlicePtr returns a slice with the pointer values. Returns a zero value in case of a nil pointer element.

func FromSlicePtrOr added in v1.47.0 

func FromSlicePtrOr[T any](collection []*T, fallback T) []T

FromSlicePtr returns a slice with the pointer values or the fallback value.

func Generator added in v1.31.0 

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

Generator implements the generator design pattern.

func GroupBy 

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

GroupBy returns an object composed of keys generated from the results of running each element of collection through iteratee. Play: https://go.dev/play/p/XnQBd_v6brd

func HasKey added in v1.43.0 

func HasKey[K comparable, V any](in map[K]V, key K) bool

HasKey returns whether the given key exists. Play: https://go.dev/play/p/aVwubIvECqS

func If 

func If[T any](condition bool, result T) *ifElse[T]

If. Play: https://go.dev/play/p/WSw3ApMxhyW

func IfF added in v1.13.0 

func IfF[T any](condition bool, resultF func() T) *ifElse[T]

IfF. Play: https://go.dev/play/p/WSw3ApMxhyW

func IndexOf 

func IndexOf[T comparable](collection []T, element T) int

IndexOf returns the index at which the first occurrence of a value is found in an array or return -1 if the value cannot be found.

func Interleave added in v1.32.0 

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

Interleave round-robin alternating input slices and sequentially appending value at index into result Play: https://go.dev/play/p/-RJkTLQEDVt

func Intersect 

func Intersect[T comparable, Slice ~[]T](list1 Slice, list2 Slice) Slice

Intersect returns the intersection between two collections.

func Invert added in v1.13.0 

func Invert[K comparable, V comparable](in map[K]V) map[V]K

Invert creates a map composed of the inverted keys and values. If map contains duplicate values, subsequent values overwrite property assignments of previous values. Play: https://go.dev/play/p/rFQ4rak6iA1

func IsEmpty added in v1.22.0 

func IsEmpty[T comparable](v T) bool

IsEmpty returns true if argument is a zero value.

func IsNil added in v1.39.0 

func IsNil(x any) bool

IsNil checks if a value is nil or if it's a reference type with a nil underlying value.

func IsNotEmpty added in v1.25.0 

func IsNotEmpty[T comparable](v T) bool

IsNotEmpty returns true if argument is not a zero value.

func IsSorted added in v1.26.0 

func IsSorted[T constraints.Ordered](collection []T) bool

IsSorted checks if a slice is sorted. Play: https://go.dev/play/p/mc3qR-t4mcx

func IsSortedByKey added in v1.26.0 

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

IsSortedByKey checks if a slice is sorted by iteratee. Play: https://go.dev/play/p/wiG6XyBBu49

func KebabCase added in v1.40.0 

func KebabCase(str string) string

KebabCase converts string to kebab case.

func KeyBy added in v1.10.1 

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

KeyBy transforms a slice or an array of structs to a map based on a pivot callback. Play: https://go.dev/play/p/mdaClUAT-zZ

func Keys 

func Keys[K comparable, V any](in ...map[K]V) []K

Keys creates an array of the map keys. Play: https://go.dev/play/p/Uu11fHASqrU

func Last 

func Last[T any](collection []T) (T, bool)

Last returns the last element of a collection or error if empty.

func LastIndexOf 

func LastIndexOf[T comparable](collection []T, element T) int

LastIndexOf returns the index at which the last occurrence of a value is found in an array or return -1 if the value cannot be found.

func LastOr added in v1.42.0 

func LastOr[T any](collection []T, fallback T) T

LastOr returns the last element of a collection or the fallback value if empty.

func LastOrEmpty added in v1.42.0 

func LastOrEmpty[T any](collection []T) T

Returns the last element of a collection or zero value if empty.

func Latest added in v1.41.0 

func Latest(times ...time.Time) time.Time

Latest search the maximum time.Time of a collection. Returns zero value when the collection is empty.

func LatestBy added in v1.45.0 

func LatestBy[T any](collection []T, iteratee func(item T) time.Time) T

LatestBy search the maximum time.Time of a collection using the given iteratee function. Returns zero value when the collection is empty.

func Map 

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

Map manipulates a slice and transforms it to a slice of another type. Play: https://go.dev/play/p/OkPcYAhBo0D

func MapEntries added in v1.32.0 

func MapEntries[K1 comparable, V1 any, K2 comparable, V2 any](in map[K1]V1, iteratee func(key K1, value V1) (K2, V2)) map[K2]V2

MapEntries manipulates a map entries and transforms it to a map of another type. Play: https://go.dev/play/p/VuvNQzxKimT

func MapKeys added in v1.13.0 

func MapKeys[K comparable, V any, R comparable](in map[K]V, iteratee func(value V, key K) R) map[R]V

MapKeys manipulates a map keys and transforms it to a map of another type. Play: https://go.dev/play/p/9_4WPIqOetJ

func MapToSlice added in v1.26.0 

func MapToSlice[K comparable, V any, R any](in map[K]V, iteratee func(key K, value V) R) []R

MapToSlice transforms a map into a slice based on specific iteratee Play: https://go.dev/play/p/ZuiCZpDt6LD

func MapValues added in v1.7.0 

func MapValues[K comparable, V any, R any](in map[K]V, iteratee func(value V, key K) R) map[K]R

MapValues manipulates a map values and transforms it to a map of another type. Play: https://go.dev/play/p/T_8xAfvcf0W

func Max 

func Max[T constraints.Ordered](collection []T) T

Max searches the maximum value of a collection. Returns zero value when the collection is empty.

func MaxBy added in v1.12.0 

func MaxBy[T any](collection []T, comparison func(a T, b T) bool) T

MaxBy search the maximum value of a collection using the given comparison function. If several values of the collection are equal to the greatest value, returns the first such value. Returns zero value when the collection is empty.

func Mean added in v1.40.0 

func Mean[T constraints.Float | constraints.Integer](collection []T) T

Mean calculates the mean of a collection of numbers.

func MeanBy added in v1.40.0 

func MeanBy[T any, R constraints.Float | constraints.Integer](collection []T, iteratee func(item T) R) R

MeanBy calculates the mean of a collection of numbers using the given return value from the iteration function.

func Min 

func Min[T constraints.Ordered](collection []T) T

Min search the minimum value of a collection. Returns zero value when the collection is empty.

func MinBy added in v1.12.0 

func MinBy[T any](collection []T, comparison func(a T, b T) bool) T

MinBy search the minimum value of a collection using the given comparison function. If several values of the collection are equal to the smallest value, returns the first such value. Returns zero value when the collection is empty.

func Must added in v1.12.0 

func Must[T any](val T, err any, messageArgs ...any) T

Must is a helper that wraps a call to a function returning a value and an error and panics if err is error or false. Play: https://go.dev/play/p/TMoWrRp3DyC

func Must0 added in v1.12.0 

func Must0(err any, messageArgs ...any)

Must0 has the same behavior as Must, but callback returns no variable. Play: https://go.dev/play/p/TMoWrRp3DyC

func Must1 added in v1.12.0 

func Must1[T any](val T, err any, messageArgs ...any) T

Must1 is an alias to Must Play: https://go.dev/play/p/TMoWrRp3DyC

func Must2 added in v1.12.0 

func Must2[T1, T2 any](val1 T1, val2 T2, err any, messageArgs ...any) (T1, T2)

Must2 has the same behavior as Must, but callback returns 2 variables. Play: https://go.dev/play/p/TMoWrRp3DyC

func Must3 added in v1.12.0 

func Must3[T1, T2, T3 any](val1 T1, val2 T2, val3 T3, err any, messageArgs ...any) (T1, T2, T3)

Must3 has the same behavior as Must, but callback returns 3 variables. Play: https://go.dev/play/p/TMoWrRp3DyC

func Must4 added in v1.12.0 

func Must4[T1, T2, T3, T4 any](val1 T1, val2 T2, val3 T3, val4 T4, err any, messageArgs ...any) (T1, T2, T3, T4)

Must4 has the same behavior as Must, but callback returns 4 variables. Play: https://go.dev/play/p/TMoWrRp3DyC

func Must5 added in v1.12.0 

func Must5[T1, T2, T3, T4, T5 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, err any, messageArgs ...any) (T1, T2, T3, T4, T5)

Must5 has the same behavior as Must, but callback returns 5 variables. Play: https://go.dev/play/p/TMoWrRp3DyC

func Must6 added in v1.12.0 

func Must6[T1, T2, T3, T4, T5, T6 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, val6 T6, err any, messageArgs ...any) (T1, T2, T3, T4, T5, T6)

Must6 has the same behavior as Must, but callback returns 6 variables. Play: https://go.dev/play/p/TMoWrRp3DyC

func NewDebounce added in v1.11.0 

func NewDebounce(duration time.Duration, f ...func()) (func(), func())

NewDebounce creates a debounced instance that delays invoking functions given until after wait milliseconds have elapsed. Play: https://go.dev/play/p/mz32VMK2nqe

func NewDebounceBy added in v1.38.0 

func NewDebounceBy[T comparable](duration time.Duration, f ...func(key T, count int)) (func(key T), func(key T))

NewDebounceBy creates a debounced instance for each distinct key, that delays invoking functions given until after wait milliseconds have elapsed. Play: https://go.dev/play/p/d3Vpt6pxhY8

func Nil added in v1.42.0 

func Nil[T any]() *T

Nil returns a nil pointer of type.

func None added in v1.18.0 

func None[T comparable](collection []T, subset []T) bool

None returns true if no element of a subset are contained into a collection or if the subset is empty.

func NoneBy added in v1.18.0 

func NoneBy[T any](collection []T, predicate func(item T) bool) bool

NoneBy returns true if the predicate returns true for none of the elements in the collection or if the collection is empty.

func Nth 

func Nth[T any, N constraints.Integer](collection []T, nth N) (T, error)

Nth returns the element at index `nth` of collection. If `nth` is negative, the nth element from the end is returned. An error is returned when nth is out of slice bounds.

func OmitBy added in v1.13.0 

func OmitBy[K comparable, V any, Map ~map[K]V](in Map, predicate func(key K, value V) bool) Map

OmitBy returns same map type filtered by given predicate. Play: https://go.dev/play/p/EtBsR43bdsd

func OmitByKeys added in v1.13.0 

func OmitByKeys[K comparable, V any, Map ~map[K]V](in Map, keys []K) Map

OmitByKeys returns same map type filtered by given keys. Play: https://go.dev/play/p/t1QjCrs-ysk

func OmitByValues added in v1.13.0 

func OmitByValues[K comparable, V comparable, Map ~map[K]V](in Map, values []V) Map

OmitByValues returns same map type filtered by given values. Play: https://go.dev/play/p/9UYZi-hrs8j

func Partial added in v1.22.0 

func Partial[T1, T2, R any](f func(a T1, b T2) R, arg1 T1) func(T2) R

Partial returns new function that, when called, has its first argument set to the provided value.

func Partial1 added in v1.37.0 

func Partial1[T1, T2, R any](f func(T1, T2) R, arg1 T1) func(T2) R

Partial1 returns new function that, when called, has its first argument set to the provided value.

func Partial2 added in v1.37.0 

func Partial2[T1, T2, T3, R any](f func(T1, T2, T3) R, arg1 T1) func(T2, T3) R

Partial2 returns new function that, when called, has its first argument set to the provided value.

func Partial3 added in v1.37.0 

func Partial3[T1, T2, T3, T4, R any](f func(T1, T2, T3, T4) R, arg1 T1) func(T2, T3, T4) R

Partial3 returns new function that, when called, has its first argument set to the provided value.

func Partial4 added in v1.37.0 

func Partial4[T1, T2, T3, T4, T5, R any](f func(T1, T2, T3, T4, T5) R, arg1 T1) func(T2, T3, T4, T5) R

Partial4 returns new function that, when called, has its first argument set to the provided value.

func Partial5 added in v1.37.0 

func Partial5[T1, T2, T3, T4, T5, T6, R any](f func(T1, T2, T3, T4, T5, T6) R, arg1 T1) func(T2, T3, T4, T5, T6) R

Partial5 returns new function that, when called, has its first argument set to the provided value

func PartitionBy added in v1.4.0 

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

PartitionBy returns an array of elements split into groups. The order of grouped values is determined by the order they occur in collection. The grouping is generated from the results of running each element of collection through iteratee. Play: https://go.dev/play/p/NfQ_nGjkgXW

func PascalCase added in v1.40.0 

func PascalCase(str string) string

PascalCase converts string to pascal case.

func PickBy added in v1.13.0 

func PickBy[K comparable, V any, Map ~map[K]V](in Map, predicate func(key K, value V) bool) Map

PickBy returns same map type filtered by given predicate. Play: https://go.dev/play/p/kdg8GR_QMmf

func PickByKeys added in v1.13.0 

func PickByKeys[K comparable, V any, Map ~map[K]V](in Map, keys []K) Map

PickByKeys returns same map type filtered by given keys. Play: https://go.dev/play/p/R1imbuci9qU

func PickByValues added in v1.13.0 

func PickByValues[K comparable, V comparable, Map ~map[K]V](in Map, values []V) Map

PickByValues returns same map type filtered by given values. Play: https://go.dev/play/p/1zdzSvbfsJc

func RandomString added in v1.35.0 

func RandomString(size int, charset []rune) string

RandomString return a random string. Play: https://go.dev/play/p/rRseOQVVum4

func Range added in v1.10.0 

func Range(elementNum int) []int

Range creates an array of numbers (positive and/or negative) with given length. Play: https://go.dev/play/p/0r6VimXAi9H

func RangeFrom added in v1.10.0 

func RangeFrom[T constraints.Integer | constraints.Float](start T, elementNum int) []T

RangeFrom creates an array of numbers from start with specified length. Play: https://go.dev/play/p/0r6VimXAi9H

func RangeWithSteps added in v1.10.0 

func RangeWithSteps[T constraints.Integer | constraints.Float](start, end, step T) []T

RangeWithSteps creates an array of numbers (positive and/or negative) progressing from start up to, but not including end. step set to zero will return empty array. Play: https://go.dev/play/p/0r6VimXAi9H

func Reduce 

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

Reduce reduces collection to a value which is the accumulated result of running each element in collection through accumulator, where each successive invocation is supplied the return value of the previous. Play: https://go.dev/play/p/R4UHXZNaaUG

func ReduceRight added in v1.26.0 

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

ReduceRight helper is like Reduce except that it iterates over elements of collection from right to left. Play: https://go.dev/play/p/Fq3W70l7wXF

func Reject added in v1.11.0 

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

Reject is the opposite of Filter, this method returns the elements of collection that predicate does not return truthy for. Play: https://go.dev/play/p/YkLMODy1WEL

func RejectMap added in v1.41.0 

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

RejectMap is the opposite of FilterMap, this method returns a slice which 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.

func Repeat added in v1.5.0 

func Repeat[T Clonable[T]](count int, initial T) []T

Repeat builds a slice with N copies of initial value. Play: https://go.dev/play/p/g3uHXbmc3b6

func RepeatBy added in v1.19.0 

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

RepeatBy builds a slice with values returned by N calls of callback. Play: https://go.dev/play/p/ozZLCtX_hNU

func Replace added in v1.19.0 

func Replace[T comparable, Slice ~[]T](collection Slice, old T, new T, n int) Slice

Replace returns a copy of the slice with the first n non-overlapping instances of old replaced by new. Play: https://go.dev/play/p/XfPzmf9gql6

func ReplaceAll added in v1.19.0 

func ReplaceAll[T comparable, Slice ~[]T](collection Slice, old T, new T) Slice

ReplaceAll returns a copy of the slice with all non-overlapping instances of old replaced by new. Play: https://go.dev/play/p/a9xZFUHfYcV

func Reverse 

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

Reverse reverses array 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/fhUMLvZ7vS6

func RuneLength added in v1.19.0 

func RuneLength(str string) int

RuneLength is an alias to utf8.RuneCountInString which returns the number of runes in string. Play: https://go.dev/play/p/tuhgW_lWY8l

func Sample added in v1.6.0 

func Sample[T any](collection []T) T

Sample returns a random item from collection.

func Samples added in v1.6.0 

func Samples[T any, Slice ~[]T](collection Slice, count int) Slice

Samples returns N random unique items from collection.

func Shuffle 

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

Shuffle returns an array of shuffled values. Uses the Fisher-Yates shuffle algorithm. Play: https://go.dev/play/p/Qp73bnTDnc7

func Slice added in v1.22.0 

func Slice[T any, Slice ~[]T](collection Slice, start int, end int) Slice

Slice returns a copy of a slice from `start` up to, but not including `end`. Like `slice[start:end]`, but does not panic on overflow. Play: https://go.dev/play/p/8XWYhfMMA1h

func SliceToChannel added in v1.31.0 

func SliceToChannel[T any](bufferSize int, collection []T) <-chan T

SliceToChannel returns a read-only channels of collection elements.

func SliceToMap added in v1.27.0 

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

SliceToMap returns a map containing key-value pairs provided by transform function applied to elements of the given slice. If any of two pairs would have the same key the last one gets added to the map. The order of keys in returned map is not specified and is not guaranteed to be the same from the original array. Alias of Associate(). Play: https://go.dev/play/p/WHa2CfMO3Lr

func SnakeCase added in v1.40.0 

func SnakeCase(str string) string

SnakeCase converts string to snake case.

func Some 

func Some[T comparable](collection []T, subset []T) bool

Some returns true if at least 1 element of a subset is contained into a collection. If the subset is empty Some returns false.

func SomeBy added in v1.18.0 

func SomeBy[T any](collection []T, predicate func(item T) bool) bool

SomeBy returns true if the predicate returns true for any of the elements in the collection. If the collection is empty SomeBy returns false.

func Splice added in v1.44.0 

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

Splice inserts multiple elements at index i. A negative index counts back from the end of the slice. The helper is protected against overflow errors. Play: https://go.dev/play/p/G5_GhkeSUBA

func Subset added in v1.19.0 

func Subset[T any, Slice ~[]T](collection Slice, offset int, length uint) Slice

Subset returns a copy of a slice from `offset` up to `length` elements. Like `slice[start:start+length]`, but does not panic on overflow. Play: https://go.dev/play/p/tOQu1GhFcog

func Substring added in v1.19.0 

func Substring[T ~string](str T, offset int, length uint) T

Substring return part of a string. Play: https://go.dev/play/p/TQlxQi82Lu1

func Sum added in v1.32.0 

func Sum[T constraints.Float | constraints.Integer | constraints.Complex](collection []T) T

Sum sums the values in a collection. If collection is empty 0 is returned. Play: https://go.dev/play/p/upfeJVqs4Bt

func SumBy added in v1.20.0 

func SumBy[T any, R constraints.Float | constraints.Integer | constraints.Complex](collection []T, iteratee func(item T) R) R

SumBy summarizes the values in a collection using the given return value from the iteration function. If collection is empty 0 is returned. Play: https://go.dev/play/p/Dz_a_7jN_ca

func Switch 

func Switch[T comparable, R any](predicate T) *switchCase[T, R]

Switch is a pure functional switch/case/default statement. Play: https://go.dev/play/p/TGbKUMAeRUd

func Synchronize added in v1.20.0 

func Synchronize(opt ...sync.Locker) *synchronize

Synchronize wraps the underlying callback in a mutex. It receives an optional mutex.

func Ternary 

func Ternary[T any](condition bool, ifOutput T, elseOutput T) T

Ternary is a 1 line if/else statement. Play: https://go.dev/play/p/t-D7WBL44h2

func TernaryF added in v1.30.0 

func TernaryF[T any](condition bool, ifFunc func() T, elseFunc func() T) T

TernaryF is a 1 line if/else statement whose options are functions Play: https://go.dev/play/p/AO4VW20JoqM

func Times added in v1.5.0 

func Times[T any](count int, iteratee func(index int) T) []T

Times invokes the iteratee n times, returning an array of the results of each invocation. The iteratee is invoked with index as argument. Play: https://go.dev/play/p/vgQj3Glr6lT

func ToAnySlice added in v1.21.0 

func ToAnySlice[T any](collection []T) []any

ToAnySlice returns a slice with all elements mapped to `any` type

func ToPtr 

func ToPtr[T any](x T) *T

ToPtr returns a pointer copy of value.

func ToSlicePtr 

func ToSlicePtr[T any](collection []T) []*T

ToSlicePtr returns a slice of pointer copy of value.

func Try added in v1.11.0 

func Try(callback func() error) (ok bool)

Try calls the function and return false in case of error.

func Try0 added in v1.11.0 

func Try0(callback func()) bool

Try0 has the same behavior as Try, but callback returns no variable. Play: https://go.dev/play/p/mTyyWUvn9u4

func Try1 added in v1.11.0 

func Try1(callback func() error) bool

Try1 is an alias to Try. Play: https://go.dev/play/p/mTyyWUvn9u4

func Try2 added in v1.11.0 

func Try2[T any](callback func() (T, error)) bool

Try2 has the same behavior as Try, but callback returns 2 variables. Play: https://go.dev/play/p/mTyyWUvn9u4

func Try3 added in v1.11.0 

func Try3[T, R any](callback func() (T, R, error)) bool

Try3 has the same behavior as Try, but callback returns 3 variables. Play: https://go.dev/play/p/mTyyWUvn9u4

func Try4 added in v1.11.0 

func Try4[T, R, S any](callback func() (T, R, S, error)) bool

Try4 has the same behavior as Try, but callback returns 4 variables. Play: https://go.dev/play/p/mTyyWUvn9u4

func Try5 added in v1.11.0 

func Try5[T, R, S, Q any](callback func() (T, R, S, Q, error)) bool

Try5 has the same behavior as Try, but callback returns 5 variables. Play: https://go.dev/play/p/mTyyWUvn9u4

func Try6 added in v1.11.0 

func Try6[T, R, S, Q, U any](callback func() (T, R, S, Q, U, error)) bool

Try6 has the same behavior as Try, but callback returns 6 variables. Play: https://go.dev/play/p/mTyyWUvn9u4

func TryCatch added in v1.11.0 

func TryCatch(callback func() error, catch func())

TryCatch has the same behavior as Try, but calls the catch function in case of error. Play: https://go.dev/play/p/PnOON-EqBiU

func TryCatchWithErrorValue added in v1.11.0 

func TryCatchWithErrorValue(callback func() error, catch func(any))

TryCatchWithErrorValue has the same behavior as TryWithErrorValue, but calls the catch function in case of error. Play: https://go.dev/play/p/8Pc9gwX_GZO

func TryOr added in v1.29.0 

func TryOr[A any](callback func() (A, error), fallbackA A) (A, bool)

TryOr has the same behavior as Must, but returns a default value in case of error. Play: https://go.dev/play/p/B4F7Wg2Zh9X

func TryOr1 added in v1.29.0 

func TryOr1[A any](callback func() (A, error), fallbackA A) (A, bool)

TryOr1 has the same behavior as Must, but returns a default value in case of error. Play: https://go.dev/play/p/B4F7Wg2Zh9X

func TryOr2 added in v1.29.0 

func TryOr2[A, B any](callback func() (A, B, error), fallbackA A, fallbackB B) (A, B, bool)

TryOr2 has the same behavior as Must, but returns a default value in case of error. Play: https://go.dev/play/p/B4F7Wg2Zh9X

func TryOr3 added in v1.29.0 

func TryOr3[A, B, C any](callback func() (A, B, C, error), fallbackA A, fallbackB B, fallbackC C) (A, B, C, bool)

TryOr3 has the same behavior as Must, but returns a default value in case of error. Play: https://go.dev/play/p/B4F7Wg2Zh9X

func TryOr4 added in v1.29.0 

func TryOr4[A, B, C, D any](callback func() (A, B, C, D, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D) (A, B, C, D, bool)

TryOr4 has the same behavior as Must, but returns a default value in case of error. Play: https://go.dev/play/p/B4F7Wg2Zh9X

func TryOr5 added in v1.29.0 

func TryOr5[A, B, C, D, E any](callback func() (A, B, C, D, E, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D, fallbackE E) (A, B, C, D, E, bool)

TryOr5 has the same behavior as Must, but returns a default value in case of error. Play: https://go.dev/play/p/B4F7Wg2Zh9X

func TryOr6 added in v1.29.0 

func TryOr6[A, B, C, D, E, F any](callback func() (A, B, C, D, E, F, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D, fallbackE E, fallbackF F) (A, B, C, D, E, F, bool)

TryOr6 has the same behavior as Must, but returns a default value in case of error. Play: https://go.dev/play/p/B4F7Wg2Zh9X

func TryWithErrorValue added in v1.11.0 

func TryWithErrorValue(callback func() error) (errorValue any, ok bool)

TryWithErrorValue has the same behavior as Try, but also returns value passed to panic. Play: https://go.dev/play/p/Kc7afQIT2Fs

func Union added in v1.8.0 

func Union[T comparable, Slice ~[]T](lists ...Slice) Slice

Union returns all distinct elements from given collections. result returns will not change the order of elements relatively.

func Uniq 

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

Uniq returns a duplicate-free version of an array, in which only the first occurrence of each element is kept. The order of result values is determined by the order they occur in the array. Play: https://go.dev/play/p/DTzbeXZ6iEN

func UniqBy 

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

UniqBy returns a duplicate-free version of an array, in which only the first occurrence of each element is kept. The order of result values is determined by the order they occur in the array. It accepts `iteratee` which is invoked for each element in array to generate the criterion by which uniqueness is computed. Play: https://go.dev/play/p/g42Z3QSb53u

func UniqKeys added in v1.47.0 

func UniqKeys[K comparable, V any](in ...map[K]V) []K

UniqKeys creates an array of unique keys in the map. Play: https://go.dev/play/p/TPKAb6ILdHk

func UniqValues added in v1.47.0 

func UniqValues[K comparable, V comparable](in ...map[K]V) []V

UniqValues creates an array of unique values in the map. Play: https://go.dev/play/p/nf6bXMh7rM3

func Unpack2 added in v1.17.0 

func Unpack2[A, B any](tuple Tuple2[A, B]) (A, B)

Unpack2 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W

func Unpack3 added in v1.17.0 

func Unpack3[A, B, C any](tuple Tuple3[A, B, C]) (A, B, C)

Unpack3 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W

func Unpack4 added in v1.17.0 

func Unpack4[A, B, C, D any](tuple Tuple4[A, B, C, D]) (A, B, C, D)

Unpack4 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W

func Unpack5 added in v1.17.0 

func Unpack5[A, B, C, D, E any](tuple Tuple5[A, B, C, D, E]) (A, B, C, D, E)

Unpack5 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W

func Unpack6 added in v1.17.0 

func Unpack6[A, B, C, D, E, F any](tuple Tuple6[A, B, C, D, E, F]) (A, B, C, D, E, F)

Unpack6 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W

func Unpack7 added in v1.17.0 

func Unpack7[A, B, C, D, E, F, G any](tuple Tuple7[A, B, C, D, E, F, G]) (A, B, C, D, E, F, G)

Unpack7 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W

func Unpack8 added in v1.17.0 

func Unpack8[A, B, C, D, E, F, G, H any](tuple Tuple8[A, B, C, D, E, F, G, H]) (A, B, C, D, E, F, G, H)

Unpack8 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W

func Unpack9 added in v1.17.0 

func Unpack9[A, B, C, D, E, F, G, H, I any](tuple Tuple9[A, B, C, D, E, F, G, H, I]) (A, B, C, D, E, F, G, H, I)

Unpack9 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W

func Unzip2 added in v1.4.0 

func Unzip2[A, B any](tuples []Tuple2[A, B]) ([]A, []B)

Unzip2 accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration. Play: https://go.dev/play/p/ciHugugvaAW

func Unzip3 added in v1.4.0 

func Unzip3[A, B, C any](tuples []Tuple3[A, B, C]) ([]A, []B, []C)

Unzip3 accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration. Play: https://go.dev/play/p/ciHugugvaAW

func Unzip4 added in v1.4.0 

func Unzip4[A, B, C, D any](tuples []Tuple4[A, B, C, D]) ([]A, []B, []C, []D)

Unzip4 accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration. Play: https://go.dev/play/p/ciHugugvaAW

func Unzip5 added in v1.4.0 

func Unzip5[A, B, C, D, E any](tuples []Tuple5[A, B, C, D, E]) ([]A, []B, []C, []D, []E)

Unzip5 accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration. Play: https://go.dev/play/p/ciHugugvaAW

func Unzip6 added in v1.4.0 

func Unzip6[A, B, C, D, E, F any](tuples []Tuple6[A, B, C, D, E, F]) ([]A, []B, []C, []D, []E, []F)

Unzip6 accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration. Play: https://go.dev/play/p/ciHugugvaAW

func Unzip7 added in v1.4.0 

func Unzip7[A, B, C, D, E, F, G any](tuples []Tuple7[A, B, C, D, E, F, G]) ([]A, []B, []C, []D, []E, []F, []G)

Unzip7 accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration. Play: https://go.dev/play/p/ciHugugvaAW

func Unzip8 added in v1.4.0 

func Unzip8[A, B, C, D, E, F, G, H any](tuples []Tuple8[A, B, C, D, E, F, G, H]) ([]A, []B, []C, []D, []E, []F, []G, []H)

Unzip8 accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration. Play: https://go.dev/play/p/ciHugugvaAW

func Unzip9 added in v1.4.0 

func Unzip9[A, B, C, D, E, F, G, H, I any](tuples []Tuple9[A, B, C, D, E, F, G, H, I]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I)

Unzip9 accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration. Play: https://go.dev/play/p/ciHugugvaAW

func UnzipBy2 added in v1.40.0 

func UnzipBy2[In any, A any, B any](items []In, iteratee func(In) (a A, b B)) ([]A, []B)

UnzipBy2 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.

func UnzipBy3 added in v1.40.0 

func UnzipBy3[In any, A any, B any, C any](items []In, iteratee func(In) (a A, b B, c C)) ([]A, []B, []C)

UnzipBy3 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.

func UnzipBy4 added in v1.40.0 

func UnzipBy4[In any, A any, B any, C any, D any](items []In, iteratee func(In) (a A, b B, c C, d D)) ([]A, []B, []C, []D)

UnzipBy4 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.

func UnzipBy5 added in v1.40.0 

func UnzipBy5[In any, A any, B any, C any, D any, E any](items []In, iteratee func(In) (a A, b B, c C, d D, e E)) ([]A, []B, []C, []D, []E)

UnzipBy5 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.

func UnzipBy6 added in v1.40.0 

func UnzipBy6[In any, A any, B any, C any, D any, E any, F any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F)) ([]A, []B, []C, []D, []E, []F)

UnzipBy6 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.

func UnzipBy7 added in v1.40.0 

func UnzipBy7[In any, A any, B any, C any, D any, E any, F any, G any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, g G)) ([]A, []B, []C, []D, []E, []F, []G)

UnzipBy7 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.

func UnzipBy8 added in v1.40.0 

func UnzipBy8[In any, A any, B any, C any, D any, E any, F any, G any, H any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, g G, h H)) ([]A, []B, []C, []D, []E, []F, []G, []H)

UnzipBy8 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.

func UnzipBy9 added in v1.40.0 

func UnzipBy9[In any, A any, B any, C any, D any, E any, F any, G any, H any, I any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, g G, h H, i I)) ([]A, []B, []C, []D, []E, []F, []G, []H, []I)

UnzipBy9 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.

func Validate added in v1.30.0 

func Validate(ok bool, format string, args ...any) error

Validate is a helper that creates an error when a condition is not met. Play: https://go.dev/play/p/vPyh51XpCBt

func ValueOr added in v1.38.0 

func ValueOr[K comparable, V any](in map[K]V, key K, fallback V) V

ValueOr returns the value of the given key or the fallback value if the key is not present. Play: https://go.dev/play/p/bAq9mHErB4V

func Values 

func Values[K comparable, V any](in ...map[K]V) []V

Values creates an array of the map values. Play: https://go.dev/play/p/nnRTQkzQfF6

func WaitFor added in v1.43.0 

func WaitFor(condition func(i int) bool, timeout time.Duration, heartbeatDelay time.Duration) (totalIterations int, elapsed time.Duration, conditionFound bool)

WaitFor runs periodically until a condition is validated.

func WaitForWithContext added in v1.46.0 

func WaitForWithContext(ctx context.Context, condition func(ctx context.Context, currentIteration int) bool, timeout time.Duration, heartbeatDelay time.Duration) (totalIterations int, elapsed time.Duration, conditionFound bool)

WaitForWithContext runs periodically until a condition is validated or context is canceled.

func Without added in v1.24.0 

func Without[T comparable, Slice ~[]T](collection Slice, exclude ...T) Slice

Without returns slice excluding all given values.

func WithoutEmpty deprecated added in v1.24.0 

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

WithoutEmpty returns slice excluding empty values.

Deprecated: Use lo.Compact instead.

func Words added in v1.40.0 

func Words(str string) []string

Words splits string into an array of its words.

func ZipBy2 added in v1.40.0 

func ZipBy2[A any, B any, Out any](a []A, b []B, iteratee func(a A, b B) Out) []Out

ZipBy2 creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value.

func ZipBy3 added in v1.40.0 

func ZipBy3[A any, B any, C any, Out any](a []A, b []B, c []C, iteratee func(a A, b B, c C) Out) []Out

ZipBy3 creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value.

func ZipBy4 added in v1.40.0 

func ZipBy4[A any, B any, C any, D any, Out any](a []A, b []B, c []C, d []D, iteratee func(a A, b B, c C, d D) Out) []Out

ZipBy4 creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value.

func ZipBy5 added in v1.40.0 

func ZipBy5[A any, B any, C any, D any, E any, Out any](a []A, b []B, c []C, d []D, e []E, iteratee func(a A, b B, c C, d D, e E) Out) []Out

ZipBy5 creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value.

func ZipBy6 added in v1.40.0 

func ZipBy6[A any, B any, C any, D any, E any, F any, Out any](a []A, b []B, c []C, d []D, e []E, f []F, iteratee func(a A, b B, c C, d D, e E, f F) Out) []Out

ZipBy6 creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value.

func ZipBy7 added in v1.40.0 

func ZipBy7[A any, B any, C any, D any, E any, F any, G any, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, iteratee func(a A, b B, c C, d D, e E, f F, g G) Out) []Out

ZipBy7 creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value.

func ZipBy8 added in v1.40.0 

func ZipBy8[A any, B any, C any, D any, E any, F any, G any, H any, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, iteratee func(a A, b B, c C, d D, e E, f F, g G, h H) Out) []Out

ZipBy8 creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value.

func ZipBy9 added in v1.40.0 

func ZipBy9[A any, B any, C any, D any, E any, F any, G any, H any, I any, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I, iteratee func(a A, b B, c C, d D, e E, f F, g G, h H, i I) Out) []Out

ZipBy9 creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value.

Types

type Clonable 

type Clonable[T any] interface {
	Clone() T
}

Clonable defines a constraint of types having Clone() T method.

type DispatchingStrategy added in v1.28.0 

type DispatchingStrategy[T any] func(msg T, index uint64, channels []<-chan T) int

func DispatchingStrategyWeightedRandom added in v1.28.0 

func DispatchingStrategyWeightedRandom[T any](weights []int) DispatchingStrategy[T]

DispatchingStrategyWeightedRandom distributes messages in a weighted manner. If the channel capacity is exceeded, another random channel will be selected and so on.

type Entry 

type Entry[K comparable, V any] struct {
	Key   K
	Value V
}

Entry defines a key/value pairs.

func Entries 

func Entries[K comparable, V any](in map[K]V) []Entry[K, V]

Entries transforms a map into array of key/value pairs. Play:

func ToPairs added in v1.22.0 

func ToPairs[K comparable, V any](in map[K]V) []Entry[K, V]

ToPairs transforms a map into array of key/value pairs. Alias of Entries(). Play: https://go.dev/play/p/3Dhgx46gawJ

type Transaction added in v1.37.0 

type Transaction[T any] struct {
	// contains filtered or unexported fields
}

Transaction implements a Saga pattern

func NewTransaction added in v1.37.0 

func NewTransaction[T any]() *Transaction[T]

NewTransaction instantiate a new transaction.

func (*Transaction[T]) Process added in v1.37.0 

func (t *Transaction[T]) Process(state T) (T, error)

Process runs the Transaction steps and rollbacks in case of errors.

func (*Transaction[T]) Then added in v1.37.0 

func (t *Transaction[T]) Then(exec func(T) (T, error), onRollback func(T) T) *Transaction[T]

Then adds a step to the chain of callbacks. It returns the same Transaction.

type Tuple2 added in v1.4.0 

type Tuple2[A, B any] struct {
	A A
	B B
}

Tuple2 is a group of 2 elements (pair).

func T2 added in v1.13.0 

func T2[A, B any](a A, b B) Tuple2[A, B]

T2 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm

func Zip2 added in v1.4.0 

func Zip2[A, B any](a []A, b []B) []Tuple2[A, B]

Zip2 creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value. Play: https://go.dev/play/p/jujaA6GaJTp

func (Tuple2[A, B]) Unpack added in v1.32.0 

func (t Tuple2[A, B]) Unpack() (A, B)

Unpack returns values contained in tuple.

type Tuple3 added in v1.4.0 

type Tuple3[A, B, C any] struct {
	A A
	B B
	C C
}

Tuple3 is a group of 3 elements.

func T3 added in v1.13.0 

func T3[A, B, C any](a A, b B, c C) Tuple3[A, B, C]

T3 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm

func Zip3 added in v1.4.0 

func Zip3[A, B, C any](a []A, b []B, c []C) []Tuple3[A, B, C]

Zip3 creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value. Play: https://go.dev/play/p/jujaA6GaJTp

func (Tuple3[A, B, C]) Unpack added in v1.32.0 

func (t Tuple3[A, B, C]) Unpack() (A, B, C)

Unpack returns values contained in tuple.

type Tuple4 added in v1.4.0 

type Tuple4[A, B, C, D any] struct {
	A A
	B B
	C C
	D D
}

Tuple4 is a group of 4 elements.

func T4 added in v1.13.0 

func T4[A, B, C, D any](a A, b B, c C, d D) Tuple4[A, B, C, D]

T4 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm

func Zip4 added in v1.4.0 

func Zip4[A, B, C, D any](a []A, b []B, c []C, d []D) []Tuple4[A, B, C, D]

Zip4 creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value. Play: https://go.dev/play/p/jujaA6GaJTp

func (Tuple4[A, B, C, D]) Unpack added in v1.32.0 

func (t Tuple4[A, B, C, D]) Unpack() (A, B, C, D)

Unpack returns values contained in tuple.

type Tuple5 added in v1.4.0 

type Tuple5[A, B, C, D, E any] struct {
	A A
	B B
	C C
	D D
	E E
}

Tuple5 is a group of 5 elements.

func T5 added in v1.13.0 

func T5[A, B, C, D, E any](a A, b B, c C, d D, e E) Tuple5[A, B, C, D, E]

T5 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm

func Zip5 added in v1.4.0 

func Zip5[A, B, C, D, E any](a []A, b []B, c []C, d []D, e []E) []Tuple5[A, B, C, D, E]

Zip5 creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value. Play: https://go.dev/play/p/jujaA6GaJTp

func (Tuple5[A, B, C, D, E]) Unpack added in v1.32.0 

func (t Tuple5[A, B, C, D, E]) Unpack() (A, B, C, D, E)

Unpack returns values contained in tuple.

type Tuple6 added in v1.4.0 

type Tuple6[A, B, C, D, E, F any] struct {
	A A
	B B
	C C
	D D
	E E
	F F
}

Tuple6 is a group of 6 elements.

func T6 added in v1.13.0 

func T6[A, B, C, D, E, F any](a A, b B, c C, d D, e E, f F) Tuple6[A, B, C, D, E, F]

T6 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm

func Zip6 added in v1.4.0 

func Zip6[A, B, C, D, E, F any](a []A, b []B, c []C, d []D, e []E, f []F) []Tuple6[A, B, C, D, E, F]

Zip6 creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value. Play: https://go.dev/play/p/jujaA6GaJTp

func (Tuple6[A, B, C, D, E, F]) Unpack added in v1.32.0 

func (t Tuple6[A, B, C, D, E, F]) Unpack() (A, B, C, D, E, F)

Unpack returns values contained in tuple.

type Tuple7 added in v1.4.0 

type Tuple7[A, B, C, D, E, F, G any] struct {
	A A
	B B
	C C
	D D
	E E
	F F
	G G
}

Tuple7 is a group of 7 elements.

func T7 added in v1.13.0 

func T7[A, B, C, D, E, F, G any](a A, b B, c C, d D, e E, f F, g G) Tuple7[A, B, C, D, E, F, G]

T7 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm

func Zip7 added in v1.4.0 

func Zip7[A, B, C, D, E, F, G any](a []A, b []B, c []C, d []D, e []E, f []F, g []G) []Tuple7[A, B, C, D, E, F, G]

Zip7 creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value. Play: https://go.dev/play/p/jujaA6GaJTp

func (Tuple7[A, B, C, D, E, F, G]) Unpack added in v1.32.0 

func (t Tuple7[A, B, C, D, E, F, G]) Unpack() (A, B, C, D, E, F, G)

Unpack returns values contained in tuple.

type Tuple8 added in v1.4.0 

type Tuple8[A, B, C, D, E, F, G, H any] struct {
	A A
	B B
	C C
	D D
	E E
	F F
	G G
	H H
}

Tuple8 is a group of 8 elements.

func T8 added in v1.13.0 

func T8[A, B, C, D, E, F, G, H any](a A, b B, c C, d D, e E, f F, g G, h H) Tuple8[A, B, C, D, E, F, G, H]

T8 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm

func Zip8 added in v1.4.0 

func Zip8[A, B, C, D, E, F, G, H any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H) []Tuple8[A, B, C, D, E, F, G, H]

Zip8 creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value. Play: https://go.dev/play/p/jujaA6GaJTp

func (Tuple8[A, B, C, D, E, F, G, H]) Unpack added in v1.32.0 

func (t Tuple8[A, B, C, D, E, F, G, H]) Unpack() (A, B, C, D, E, F, G, H)

Unpack returns values contained in tuple.

type Tuple9 added in v1.4.0 

type Tuple9[A, B, C, D, E, F, G, H, I any] struct {
	A A
	B B
	C C
	D D
	E E
	F F
	G G
	H H
	I I
}

Tuple9 is a group of 9 elements.

func T9 added in v1.13.0 

func T9[A, B, C, D, E, F, G, H, I any](a A, b B, c C, d D, e E, f F, g G, h H, i I) Tuple9[A, B, C, D, E, F, G, H, I]

T9 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm

func Zip9 added in v1.4.0 

func Zip9[A, B, C, D, E, F, G, H, I any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I) []Tuple9[A, B, C, D, E, F, G, H, I]

Zip9 creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value. Play: https://go.dev/play/p/jujaA6GaJTp

func (Tuple9[A, B, C, D, E, F, G, H, I]) Unpack added in v1.32.0 

func (t Tuple9[A, B, C, D, E, F, G, H, I]) Unpack() (A, B, C, D, E, F, G, H, I)

Unpack returns values contained in tuple.

Source Files

View all Source files

Directories

Path Synopsis
internal
constraints
Package constraints defines a set of useful constraints to be used with type parameters.
 Package constraints defines a set of useful constraints to be used with type parameters.
rand

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.