README
¶
自述文件
¶
lo - Iterate over slices, maps, channels...
lo - 迭代切片、地圖、通道...
✨ samber/lo
is a Lodash-style Go library based on Go 1.18+ Generics.
✨ samber/lo
是基於 Go 1.18+ 泛型的 Lodash 風格的 Go 函式庫。
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.
這個計畫最初是作為新泛型實施的實驗而開始的。它在某些方面可能看起來像Lodash 。我曾經使用出色的“go-funk”套件進行編碼,但是“go-funk”使用反射,因此不是類型安全的。
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.
如預期的那樣,基準測試表明泛型比基於「reflect」套件的實作快得多。與純for
迴圈相比,基準測試也顯示出類似的效能提升。見下文。
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.
將來,5 到 10 個助手將與 Go 標準庫中的助手重疊(在套件名稱slices
和maps
下)。我覺得這個函式庫是合法的,並且提供了許多更有價值的抽象。
See also: 參見:
- samber/do: A dependency injection toolkit based on Go 1.18+ Generics
samber/do :基於 Go 1.18+ Generics 的依賴注入工具包 - samber/mo: Monads based on Go 1.18+ Generics (Option, Result, Either...)
samber/mo :基於 Go 1.18+ 泛型的 Monad(Option、Result、Either...)
Why this name? 為什麼叫這個名字?
I wanted a short name, similar to "Lodash" and no Go package currently uses this name.
我想要一個簡短的名稱,類似於“Lodash”,目前沒有 Go 套件使用這個名稱。
🚀 Install 🚀 安裝
go get github.com/samber/lo@v1
This library is v1 and follows SemVer strictly.
該庫是 v1 版並嚴格遵循 SemVer。
No breaking changes will be made to exported APIs before v2.0.0.
v2.0.0 之前匯出的 API 不會發生重大變更。
This library has no dependencies outside the Go standard library.
該庫沒有 Go 標準庫之外的依賴項。
💡 Usage 💡用法
You can import lo
using:
您可以使用以下方式匯入lo
:
import (
"github.com/samber/lo"
lop "github.com/samber/lo/parallel"
)
Then use one of the helpers below:
然後使用以下助手之一:
names := lo.Uniq[string]([]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{...})
.
大多數時候,編譯器將能夠推斷類型,以便您可以呼叫: 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.
我不能推薦它,但以防萬一你懶得重複了lo.
在任何地方,您都可以將整個庫匯入到命名空間中。
import (
. "github.com/samber/lo"
)
I take no responsibility on this junk. 😁 💩
我對這些垃圾不負任何責任。 😁💩
🤠 Spec 🤠 規格
GoDoc: https://godoc.org/github.com/samber/lo
GoDoc: https://godoc.org/github.com/samber/lo
Supported helpers for slices:
支持的切片助手:
- Filter 篩選
- Map 地圖
- FilterMap 過濾映射
- FlatMap 平面地圖
- Reduce 減少
- ReduceRight 減少右
- ForEach 對於每個
- Times 時代
- Uniq 優尼克
- UniqBy 優衣庫
- GroupBy 分組依據
- Chunk 區塊
- PartitionBy 分區依據
- Flatten 展平
- Interleave 交錯
- Shuffle 隨機播放
- Reverse 反向
- Fill 充滿
- Repeat 重複
- RepeatBy 重複者
- KeyBy 按鍵
- Associate / SliceToMap 關聯/切片到映射
- Drop 降低
- DropRight 右下角
- DropWhile 掉落時
- DropRightWhile 向右下降
- Reject 拒絕
- Count 數數
- CountBy 計數依據
- CountValues 計數值
- CountValuesBy 計數值依據
- Subset 子集
- Slice 片
- Replace 代替
- ReplaceAll 全部替換
- Compact 袖珍的
- IsSorted 已排序
- IsSortedByKey 按鍵排序
Supported helpers for maps:
支援的地圖助理:
- Keys 按鍵
- ValueOr 價值或
- Values 價值觀
- PickBy 提貨人
- PickByKeys 按鍵挑選
- PickByValues 按值挑選
- OmitBy 省略者
- OmitByKeys 按鍵省略
- OmitByValues 按值省略
- Entries / ToPairs 條目/ToPairs
- FromEntries / FromPairs 來自條目/來自對
- Invert 倒置
- Assign (merge of maps) 分配(地圖合併)
- MapKeys 地圖鍵
- MapValues 地圖值
- MapEntries 地圖條目
- MapToSlice 映射到切片
Supported math helpers: 支援的數學助理:
Supported helpers for strings:
支援的字串助手:
Supported helpers for tuples:
支援的元組助手:
Supported helpers for channels:
支援的頻道助手:
- ChannelDispatcher 通道調度器
- SliceToChannel 切片到通道
- Generator 發電機
- Buffer 緩衝
- BufferWithTimeout 超時緩衝區
- FanIn 扇入
- FanOut 扇出
Supported intersection helpers:
支持的交叉路口助手:
- Contains 包含
- ContainsBy 包含者
- Every 每一個
- EveryBy 每個人
- Some 一些
- SomeBy 一些作者
- None 沒有任何
- NoneBy 無作者
- Intersect 相交
- Difference 不同之處
- Union 聯盟
- Without 沒有
- WithoutEmpty 無空
Supported search helpers:
支援的搜尋助手:
- IndexOf 索引
- LastIndexOf 最後索引
- Find 尋找
- FindIndexOf 尋找索引
- FindLastIndexOf 尋找最後一個索引
- FindOrElse 尋找或其他
- FindKey 尋找鑰匙
- FindKeyBy 尋找關鍵字依據
- FindUniques 尋找獨特的
- FindUniquesBy 尋找唯一依據
- FindDuplicates 尋找重複項
- FindDuplicatesBy 尋找重複項
- Min 最小
- MinBy 最小比
- Max 最大限度
- MaxBy 最大比
- Last 最後的
- Nth 第N次
- Sample 樣本
- Samples 樣品
Conditional helpers: 有條件的幫手:
Type manipulation helpers:
類型操作助手:
- IsNil 為無
- ToPtr 托普特
- EmptyableToPtr 空指針
- FromPtr 來自指針
- FromPtrOr 來自指針
- ToSlicePtr 切片指針
- ToAnySlice 到任意切片
- FromAnySlice 來自任意切片
- Empty 空的
- IsEmpty 為空
- IsNotEmpty 不為空
- Coalesce 合併
Function helpers: 函數助手:
Concurrency helpers: 並發助手:
- Attempt 試圖
- AttemptWhile 嘗試同時
- AttemptWithDelay 延遲嘗試
- AttemptWhileWithDelay 延遲時嘗試
- Debounce 去抖動
- DebounceBy 反跳通過
- Synchronize 同步
- Async 非同步
- Transaction 交易
Error handling: 錯誤處理:
- Validate 證實
- Must 必須
- Try 嘗試
- Try1 -> Try6 嘗試1 -> 嘗試6
- TryOr 嘗試或
- TryOr1 -> TryOr6
- TryCatch 嘗試捕獲
- TryWithErrorValue 嘗試錯誤值
- TryCatchWithErrorValue 嘗試捕獲錯誤值
- ErrorsAs 錯誤為
Constraints: 限制條件:
- Clonable 可複製
Filter 篩選
Iterates over a collection and returns an array of all the elements the predicate function returns true
for.
迭代集合並傳回謂詞函數傳回true
的所有元素的陣列。
even := lo.Filter([]int{1, 2, 3, 4}, func(x int, index int) bool {
return x%2 == 0
})
// []int{2, 4}
Map 地圖
Manipulates a slice of one type and transforms it into a slice of another type:
操作一種類型的切片並將其轉換為另一種類型的切片:
import "github.com/samber/lo"
lo.Map([]int64{1, 2, 3, 4}, func(x int64, index int) string {
return strconv.FormatInt(x, 10)
})
// []string{"1", "2", "3", "4"}
Parallel processing: like lo.Map()
, but the mapper function is called in a goroutine. Results are returned in the same order.
平行處理:類似於lo.Map()
,但映射器函數是在 goroutine 中呼叫的。結果以相同的順序傳回。
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"}
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.
操作切片並將其轉換並展平為另一種類型的切片。變換函數可以傳回切片或nil
,並且在nil
情況下,不會向最終切片添加任何值。
lo.FlatMap([]int{0, 1, 2}, func(x int, _ int) []string {
return []string{
strconv.FormatInt(x, 10),
strconv.FormatInt(x, 10),
}
})
// []string{"0", "0", "1", "1", "2", "2"}
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
ReduceRight 減少右
Like lo.Reduce
except that it iterates over elements of collection from right to left.
與lo.Reduce
類似,只不過它從右到左迭代集合的元素。
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}
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"
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]
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]
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[string](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]
Keys
Creates an array of the map keys.
keys := lo.Keys[string, int](map[string]int{"foo": 1, "bar": 2})
// []string{"foo", "bar"}
[play]
Values
Creates an array of the map values.
values := lo.Values[string, int](map[string]int{"foo": 1, "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[string, int](map[string]int{"foo": 1, "bar": 2}, "foo", 42)
// 1
value := lo.ValueOr[string, int](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[string, int](
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]
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]
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]
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]
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:
- lo.DispatchingStrategyRoundRobin: Distributes messages in a rotating sequential manner.
- lo.DispatchingStrategyRandom: Distributes messages in a random manner.
- lo.DispatchingStrategyWeightedRandom: Distributes messages in a weighted manner.
- lo.DispatchingStrategyFirst: Distributes messages in the first non-full channel.
- lo.DispatchingStrategyLeast: Distributes messages in the emptiest channel.
- lo.DispatchingStrategyMost: Distributes to the fullest channel.
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 element and true if element was found.
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 collection is empty.
min := lo.Min([]int{1, 2, 3})
// 1
min := lo.Min([]int{})
// 0
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 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)
})
// ""
Max
Search the maximum value of a collection.
Returns zero value when collection is empty.
max := lo.Max([]int{1, 2, 3})
// 3
max := lo.Max([]int{})
// 0
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 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)
})
// ""
Last
Returns the last element of a collection or error if empty.
last, err := lo.Last([]int{1, 2, 3})
// 3
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 intializations, 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"}
EmptyableToPtr
Returns a pointer copy of value if it's nonzero. Otherwise, returns nil pointer.
ptr := lo.EmptyableToPtr[[]int](nil)
// nil
ptr := lo.EmptyableToPtr[string]("")
// nil
ptr := lo.EmptyableToPtr[[]int]([]int{})
// *[]int{}
ptr := lo.EmptyableToPtr[string]("hello world")
// *string{"hello world"}
FromPtr
Returns the pointer value or empty.
str := "hello world"
value := lo.FromPtr(&str)
// "hello world"
value := lo.FromPtr[string](nil)
// ""
FromPtrOr
Returns the pointer value or the fallback value.
str := "hello world"
value := lo.FromPtrOr(&str, "empty")
// "hello world"
value := lo.FromPtrOr[string](nil, "empty")
// "empty"
ToSlicePtr
Returns a slice of pointer copy of value.
ptr := lo.ToSlicePtr([]string{"hello", "world"})
// []*string{"hello", "world"}
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[*string](nil, nilStr, &str)
// &"foobar" true
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[int]().
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
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[int](list, item), "'%s' must always contain '%s'", list, item)
...
[play]
Try
Calls the function and return false in case of error and on 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 than Try
, but 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 than TryOr
, but 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 than Try
, but also returns value passed to panic.
err, ok := lo.TryWithErrorValue(func() error {
panic("error")
return nil
})
// "error", false
[play]
TryCatch
The same behavior than 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 than 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 the 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) thango-funk
, a reflection-based Map implementation.lo.Map
have the same allocation profile thanfor
.lo.Map
is 4% slower thanfor
.lop.Map
is slower thanlo.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
- Ping me on twitter @samuelberthe (DMs, mentions, whatever :))
- Fork the project
- Fix open issues or request new features
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
💫 Show your support
Give a ⭐️ if this project helped you!
📝 License
Copyright © 2022 Samuel Berthe.
This project is MIT licensed.
Documentation ¶
Index ¶
- Variables
- func Assign[K comparable, V any](maps ...map[K]V) map[K]V
- func Associate[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K]V
- func Async[A any](f func() A) <-chan A
- func Async0(f func()) <-chan struct{}
- func Async1[A any](f func() A) <-chan A
- func Async2[A any, B any](f func() (A, B)) <-chan Tuple2[A, B]
- func Async3[A any, B any, C any](f func() (A, B, C)) <-chan Tuple3[A, B, C]
- func Async4[A any, B any, C any, D any](f func() (A, B, C, D)) <-chan Tuple4[A, B, C, D]
- func Async5[A any, B any, C any, D any, E any](f func() (A, B, C, D, E)) <-chan Tuple5[A, B, C, D, E]
- func Async6[A any, B any, C any, D any, E any, F any](f func() (A, B, C, D, E, F)) <-chan Tuple6[A, B, C, D, E, F]
- func Attempt(maxIteration int, f func(index int) error) (int, error)
- func AttemptWhile(maxIteration int, f func(int) (error, bool)) (int, error)
- func AttemptWhileWithDelay(maxIteration int, delay time.Duration, ...) (int, time.Duration, error)
- func AttemptWithDelay(maxIteration int, delay time.Duration, ...) (int, time.Duration, error)
- func Batch[T any](ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool)deprecated
- func BatchWithTimeout[T any](ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool)deprecated
- func Buffer[T any](ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool)
- func BufferWithTimeout[T any](ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool)
- func ChannelDispatcher[T any](stream <-chan T, count int, channelBufferCap int, ...) []<-chan T
- func ChannelMerge[T any](channelBufferCap int, upstreams ...<-chan T) <-chan Tdeprecated
- func ChannelToSlice[T any](ch <-chan T) []T
- func Chunk[T any](collection []T, size int) [][]T
- func ChunkString[T ~string](str T, size int) []T
- func Clamp[T constraints.Ordered](value T, min T, max T) T
- func Coalesce[T comparable](v ...T) (result T, ok bool)
- func Compact[T comparable](collection []T) []T
- func Contains[T comparable](collection []T, element T) bool
- func ContainsBy[T any](collection []T, predicate func(item T) bool) bool
- func Count[T comparable](collection []T, value T) (count int)
- func CountBy[T any](collection []T, predicate func(item T) bool) (count int)
- func CountValues[T comparable](collection []T) map[T]int
- func CountValuesBy[T any, U comparable](collection []T, mapper func(item T) U) map[U]int
- func Difference[T comparable](list1 []T, list2 []T) ([]T, []T)
- func DispatchingStrategyFirst[T any](msg T, index uint64, channels []<-chan T) int
- func DispatchingStrategyLeast[T any](msg T, index uint64, channels []<-chan T) int
- func DispatchingStrategyMost[T any](msg T, index uint64, channels []<-chan T) int
- func DispatchingStrategyRandom[T any](msg T, index uint64, channels []<-chan T) int
- func DispatchingStrategyRoundRobin[T any](msg T, index uint64, channels []<-chan T) int
- func Drop[T any](collection []T, n int) []T
- func DropRight[T any](collection []T, n int) []T
- func DropRightWhile[T any](collection []T, predicate func(item T) bool) []T
- func DropWhile[T any](collection []T, predicate func(item T) bool) []T
- func Empty[T any]() T
- func EmptyableToPtr[T any](x T) *T
- func ErrorsAs[T error](err error) (T, bool)
- func Every[T comparable](collection []T, subset []T) bool
- func EveryBy[T any](collection []T, predicate func(item T) bool) bool
- func FanIn[T any](channelBufferCap int, upstreams ...<-chan T) <-chan T
- func FanOut[T any](count int, channelsBufferCap int, upstream <-chan T) []<-chan T
- func Fill[T Clonable[T]](collection []T, initial T) []T
- func Filter[V any](collection []V, predicate func(item V, index int) bool) []V
- func FilterMap[T any, R any](collection []T, callback func(item T, index int) (R, bool)) []R
- func Find[T any](collection []T, predicate func(item T) bool) (T, bool)
- func FindDuplicates[T comparable](collection []T) []T
- func FindDuplicatesBy[T any, U comparable](collection []T, iteratee func(item T) U) []T
- func FindIndexOf[T any](collection []T, predicate func(item T) bool) (T, int, bool)
- func FindKey[K comparable, V comparable](object map[K]V, value V) (K, bool)
- func FindKeyBy[K comparable, V any](object map[K]V, predicate func(key K, value V) bool) (K, bool)
- func FindLastIndexOf[T any](collection []T, predicate func(item T) bool) (T, int, bool)
- func FindOrElse[T any](collection []T, fallback T, predicate func(item T) bool) T
- func FindUniques[T comparable](collection []T) []T
- func FindUniquesBy[T any, U comparable](collection []T, iteratee func(item T) U) []T
- func FlatMap[T any, R any](collection []T, iteratee func(item T, index int) []R) []R
- func Flatten[T any](collection [][]T) []T
- func ForEach[T any](collection []T, iteratee func(item T, index int))
- func FromAnySlice[T any](in []any) (out []T, ok bool)
- func FromEntries[K comparable, V any](entries []Entry[K, V]) map[K]V
- func FromPairs[K comparable, V any](entries []Entry[K, V]) map[K]V
- func FromPtr[T any](x *T) T
- func FromPtrOr[T any](x *T, fallback T) T
- func Generator[T any](bufferSize int, generator func(yield func(T))) <-chan T
- func GroupBy[T any, U comparable](collection []T, iteratee func(item T) U) map[U][]T
- func If[T any](condition bool, result T) *ifElse[T]
- func IfF[T any](condition bool, resultF func() T) *ifElse[T]
- func IndexOf[T comparable](collection []T, element T) int
- func Interleave[T any](collections ...[]T) []T
- func Intersect[T comparable](list1 []T, list2 []T) []T
- func Invert[K comparable, V comparable](in map[K]V) map[V]K
- func IsEmpty[T comparable](v T) bool
- func IsNil(x any) bool
- func IsNotEmpty[T comparable](v T) bool
- func IsSorted[T constraints.Ordered](collection []T) bool
- func IsSortedByKey[T any, K constraints.Ordered](collection []T, iteratee func(item T) K) bool
- func KeyBy[K comparable, V any](collection []V, iteratee func(item V) K) map[K]V
- func Keys[K comparable, V any](in map[K]V) []K
- func Last[T any](collection []T) (T, error)
- func LastIndexOf[T comparable](collection []T, element T) int
- func Map[T any, R any](collection []T, iteratee func(item T, index int) R) []R
- 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
- func MapKeys[K comparable, V any, R comparable](in map[K]V, iteratee func(value V, key K) R) map[R]V
- func MapToSlice[K comparable, V any, R any](in map[K]V, iteratee func(key K, value V) R) []R
- func MapValues[K comparable, V any, R any](in map[K]V, iteratee func(value V, key K) R) map[K]R
- func Max[T constraints.Ordered](collection []T) T
- func MaxBy[T any](collection []T, comparison func(a T, b T) bool) T
- func Min[T constraints.Ordered](collection []T) T
- func MinBy[T any](collection []T, comparison func(a T, b T) bool) T
- func Must[T any](val T, err any, messageArgs ...interface{}) T
- func Must0(err any, messageArgs ...interface{})
- func Must1[T any](val T, err any, messageArgs ...interface{}) T
- func Must2[T1 any, T2 any](val1 T1, val2 T2, err any, messageArgs ...interface{}) (T1, T2)
- func Must3[T1 any, T2 any, T3 any](val1 T1, val2 T2, val3 T3, err any, messageArgs ...interface{}) (T1, T2, T3)
- func Must4[T1 any, T2 any, T3 any, T4 any](val1 T1, val2 T2, val3 T3, val4 T4, err any, messageArgs ...interface{}) (T1, T2, T3, T4)
- func Must5[T1 any, T2 any, T3 any, T4 any, T5 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, err any, ...) (T1, T2, T3, T4, T5)
- func Must6[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, val6 T6, err any, ...) (T1, T2, T3, T4, T5, T6)
- func NewDebounce(duration time.Duration, f ...func()) (func(), func())
- func NewDebounceBy[T comparable](duration time.Duration, f ...func(key T, count int)) (func(key T), func(key T))
- func None[T comparable](collection []T, subset []T) bool
- func NoneBy[T any](collection []T, predicate func(item T) bool) bool
- func Nth[T any, N constraints.Integer](collection []T, nth N) (T, error)
- func OmitBy[K comparable, V any](in map[K]V, predicate func(key K, value V) bool) map[K]V
- func OmitByKeys[K comparable, V any](in map[K]V, keys []K) map[K]V
- func OmitByValues[K comparable, V comparable](in map[K]V, values []V) map[K]V
- func Partial[T1, T2, R any](f func(a T1, b T2) R, arg1 T1) func(T2) R
- func Partial1[T1, T2, R any](f func(T1, T2) R, arg1 T1) func(T2) R
- func Partial2[T1, T2, T3, R any](f func(T1, T2, T3) R, arg1 T1) func(T2, T3) R
- func Partial3[T1, T2, T3, T4, R any](f func(T1, T2, T3, T4) R, arg1 T1) func(T2, T3, T4) R
- 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
- 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
- func PartitionBy[T any, K comparable](collection []T, iteratee func(item T) K) [][]T
- func PickBy[K comparable, V any](in map[K]V, predicate func(key K, value V) bool) map[K]V
- func PickByKeys[K comparable, V any](in map[K]V, keys []K) map[K]V
- func PickByValues[K comparable, V comparable](in map[K]V, values []V) map[K]V
- func RandomString(size int, charset []rune) string
- func Range(elementNum int) []int
- func RangeFrom[T constraints.Integer | constraints.Float](start T, elementNum int) []T
- func RangeWithSteps[T constraints.Integer | constraints.Float](start, end, step T) []T
- func Reduce[T any, R any](collection []T, accumulator func(agg R, item T, index int) R, initial R) R
- func ReduceRight[T any, R any](collection []T, accumulator func(agg R, item T, index int) R, initial R) R
- func Reject[V any](collection []V, predicate func(item V, index int) bool) []V
- func Repeat[T Clonable[T]](count int, initial T) []T
- func RepeatBy[T any](count int, predicate func(index int) T) []T
- func Replace[T comparable](collection []T, old T, new T, n int) []T
- func ReplaceAll[T comparable](collection []T, old T, new T) []T
- func Reverse[T any](collection []T) []T
- func RuneLength(str string) int
- func Sample[T any](collection []T) T
- func Samples[T any](collection []T, count int) []T
- func Shuffle[T any](collection []T) []T
- func Slice[T any](collection []T, start int, end int) []T
- func SliceToChannel[T any](bufferSize int, collection []T) <-chan T
- func SliceToMap[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K]V
- func Some[T comparable](collection []T, subset []T) bool
- func SomeBy[T any](collection []T, predicate func(item T) bool) bool
- func Subset[T any](collection []T, offset int, length uint) []T
- func Substring[T ~string](str T, offset int, length uint) T
- func Sum[T constraints.Float | constraints.Integer | constraints.Complex](collection []T) T
- func SumBy[T any, R constraints.Float | constraints.Integer | constraints.Complex](collection []T, iteratee func(item T) R) R
- func Switch[T comparable, R any](predicate T) *switchCase[T, R]
- func Synchronize(opt ...sync.Locker) *synchronize
- func Ternary[T any](condition bool, ifOutput T, elseOutput T) T
- func TernaryF[T any](condition bool, ifFunc func() T, elseFunc func() T) T
- func Times[T any](count int, iteratee func(index int) T) []T
- func ToAnySlice[T any](collection []T) []any
- func ToPtr[T any](x T) *T
- func ToSlicePtr[T any](collection []T) []*T
- func Try(callback func() error) (ok bool)
- func Try0(callback func()) bool
- func Try1(callback func() error) bool
- func Try2[T any](callback func() (T, error)) bool
- func Try3[T, R any](callback func() (T, R, error)) bool
- func Try4[T, R, S any](callback func() (T, R, S, error)) bool
- func Try5[T, R, S, Q any](callback func() (T, R, S, Q, error)) bool
- func Try6[T, R, S, Q, U any](callback func() (T, R, S, Q, U, error)) bool
- func TryCatch(callback func() error, catch func())
- func TryCatchWithErrorValue(callback func() error, catch func(any))
- func TryOr[A any](callback func() (A, error), fallbackA A) (A, bool)
- func TryOr1[A any](callback func() (A, error), fallbackA A) (A, bool)
- func TryOr2[A any, B any](callback func() (A, B, error), fallbackA A, fallbackB B) (A, B, bool)
- func TryOr3[A any, B any, C any](callback func() (A, B, C, error), fallbackA A, fallbackB B, fallbackC C) (A, B, C, bool)
- func TryOr4[A any, B any, C any, D any](callback func() (A, B, C, D, error), fallbackA A, fallbackB B, fallbackC C, ...) (A, B, C, D, bool)
- func TryOr5[A any, B any, C any, D any, E any](callback func() (A, B, C, D, E, error), fallbackA A, fallbackB B, fallbackC C, ...) (A, B, C, D, E, bool)
- func TryOr6[A any, B any, C any, D any, E any, F any](callback func() (A, B, C, D, E, F, error), fallbackA A, fallbackB B, ...) (A, B, C, D, E, F, bool)
- func TryWithErrorValue(callback func() error) (errorValue any, ok bool)
- func Union[T comparable](lists ...[]T) []T
- func Uniq[T comparable](collection []T) []T
- func UniqBy[T any, U comparable](collection []T, iteratee func(item T) U) []T
- func Unpack2[A any, B any](tuple Tuple2[A, B]) (A, B)
- func Unpack3[A any, B any, C any](tuple Tuple3[A, B, C]) (A, B, C)
- func Unpack4[A any, B any, C any, D any](tuple Tuple4[A, B, C, D]) (A, B, C, D)
- func Unpack5[A any, B any, C any, D any, E any](tuple Tuple5[A, B, C, D, E]) (A, B, C, D, E)
- func Unpack6[A any, B any, C any, D any, E any, F any](tuple Tuple6[A, B, C, D, E, F]) (A, B, C, D, E, F)
- func Unpack7[A any, B any, C any, D any, E any, F any, G any](tuple Tuple7[A, B, C, D, E, F, G]) (A, B, C, D, E, F, G)
- func Unpack8[A any, B any, C any, D any, E any, F any, G any, H any](tuple Tuple8[A, B, C, D, E, F, G, H]) (A, B, C, D, E, F, G, H)
- func Unpack9[A any, B any, C any, D any, E any, F any, G any, H any, I any](tuple Tuple9[A, B, C, D, E, F, G, H, I]) (A, B, C, D, E, F, G, H, I)
- func Unzip2[A any, B any](tuples []Tuple2[A, B]) ([]A, []B)
- func Unzip3[A any, B any, C any](tuples []Tuple3[A, B, C]) ([]A, []B, []C)
- func Unzip4[A any, B any, C any, D any](tuples []Tuple4[A, B, C, D]) ([]A, []B, []C, []D)
- func Unzip5[A any, B any, C any, D any, E any](tuples []Tuple5[A, B, C, D, E]) ([]A, []B, []C, []D, []E)
- func Unzip6[A any, B any, C any, D any, E any, F any](tuples []Tuple6[A, B, C, D, E, F]) ([]A, []B, []C, []D, []E, []F)
- func Unzip7[A any, B any, C any, D any, E any, F any, G any](tuples []Tuple7[A, B, C, D, E, F, G]) ([]A, []B, []C, []D, []E, []F, []G)
- func Unzip8[A any, B any, C any, D any, E any, F any, G any, H any](tuples []Tuple8[A, B, C, D, E, F, G, H]) ([]A, []B, []C, []D, []E, []F, []G, []H)
- func Unzip9[A any, B any, C any, D any, E any, F any, G any, H any, I any](tuples []Tuple9[A, B, C, D, E, F, G, H, I]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I)
- func Validate(ok bool, format string, args ...any) error
- func ValueOr[K comparable, V any](in map[K]V, key K, fallback V) V
- func Values[K comparable, V any](in map[K]V) []V
- func Without[T comparable](collection []T, exclude ...T) []T
- func WithoutEmpty[T comparable](collection []T) []T
- type Clonable
- type DispatchingStrategy
- type Entry
- type Transaction
- type Tuple2
- type Tuple3
- type Tuple4
- type Tuple5
- type Tuple6
- type Tuple7
- type Tuple8
- type Tuple9
- func T9[A any, B any, C any, D any, E any, F any, G any, H any, 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]
- func Zip9[A any, B any, C any, D any, E any, F any, G any, H any, 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]
Constants ¶
This section is empty.
Variables ¶
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](maps ...map[K]V) map[K]V
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
Associate 傳回一個映射,其中包含由應用於給定切片元素的變換函數提供的鍵值對。如果兩對中的任何一對具有相同的密鑰,則最後一對將添加到地圖中。傳回映射中鍵的順序未指定,且不保證與原始數組相同。播放: https ://go.dev/play/p/WHa2CfMO3Lr
func Async ¶
非同步函數¶
added in
v1.12.0
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.
非同步在 goroutine 中執行函數並在通道中傳回結果。
func Async0 ¶
函數異步0 ¶
added in
v1.17.0
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.
Async0 在 goroutine 中執行一個函數,並在函數完成後傳回一個通道集。
func Async1 ¶
函數異步1 ¶
added in
v1.17.0
v1.17.0中添加
func Async1[A any](f func() A) <-chan A
Async1 is an alias to Async.
Async1 是 Async 的別名。
func Async2 ¶
函數異步2 ¶
added in
v1.17.0
v1.17.0中添加
Async2 has the same behavior as Async, but returns the 2 results as a tuple inside the channel.
Async2 與 Async 具有相同的行為,但將 2 個結果作為通道內的元組傳回。
func Async3 ¶
函數異步3 ¶
added in
v1.17.0
v1.17.0中添加
Async3 has the same behavior as Async, but returns the 3 results as a tuple inside the channel.
Async3 與 Async 具有相同的行為,但將 3 個結果作為通道內的元組傳回。
func Async4 ¶
函數異步4 ¶
added in
v1.17.0
v1.17.0中添加
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 any, B any, C any, D any, 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 any, B any, C any, D any, E any, 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
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
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 BatchWithTimeout
deprecated
added in
v1.31.0
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 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 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 ¶
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
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](v ...T) (result T, ok bool)
Coalesce returns the first non-empty arguments. Arguments must be comparable.
func Compact ¶ added in v1.22.0
func Compact[T comparable](collection []T) []T
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
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
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](list1 []T, list2 []T) ([]T, []T)
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
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
DispatchingStrategyLeast distributes messages in the emptiest channel.
func DispatchingStrategyMost ¶ added in v1.28.0
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
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
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
Drop drops n elements from the beginning of a slice or array. Play: https://go.dev/play/p/JswS7vXRJP2
func DropRight ¶ added in v1.9.0
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
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
DropWhile drops elements from the beginning of a slice or array while the predicate returns true. Play: https://go.dev/play/p/7gBPYw2IK16
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
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
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
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
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 ¶
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
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.
func Find ¶
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](collection []T) []T
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](collection []T, iteratee func(item T) U) []T
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
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
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
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](collection []T) []T
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](collection []T, iteratee func(item T) U) []T
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 FlatMap ¶ added in v1.7.0
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](collection [][]T) []T
Flatten returns an array a single level deep. Play: https://go.dev/play/p/rbp9ORaMpjw
func ForEach ¶
ForEach iterates over elements of collection and invokes iteratee for each element. Play: https://go.dev/play/p/oofyiUPRf8t
func FromAnySlice ¶ added in v1.21.0
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 GroupBy ¶
func GroupBy[T any, U comparable](collection []T, iteratee func(item T) U) map[U][]T
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 If ¶
If. Play: https://go.dev/play/p/WSw3ApMxhyW
func IfF ¶ added in v1.13.0
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](collections ...[]T) []T
Interleave round-robin alternating input slices and sequentially appending value at index into result Play: https://go.dev/play/p/DDhlwrShbwe
func Intersect ¶
func Intersect[T comparable](list1 []T, list2 []T) []T
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
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 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 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 Map ¶
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 collection is empty.
func MaxBy ¶ added in v1.12.0
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 collection is empty.
func Min ¶
func Min[T constraints.Ordered](collection []T) T
Min search the minimum value of a collection. Returns zero value when collection is empty.
func MinBy ¶ added in v1.12.0
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 collection is empty.
func Must ¶ added in v1.12.0
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 ...interface{})
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
Must1 is an alias to Must Play: https://go.dev/play/p/TMoWrRp3DyC
func Must2 ¶ added in v1.12.0
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 any, T2 any, T3 any](val1 T1, val2 T2, val3 T3, err any, messageArgs ...interface{}) (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 any, T2 any, T3 any, T4 any](val1 T1, val2 T2, val3 T3, val4 T4, err any, messageArgs ...interface{}) (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 any, T2 any, T3 any, T4 any, T5 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, err any, messageArgs ...interface{}) (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 any, T2 any, T3 any, T4 any, T5 any, T6 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, val6 T6, err any, messageArgs ...interface{}) (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
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 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
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](in map[K]V, predicate func(key K, value V) bool) map[K]V
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](in map[K]V, keys []K) map[K]V
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](in map[K]V, values []V) map[K]V
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](collection []T, iteratee func(item T) K) [][]T
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 PickBy ¶ added in v1.13.0
func PickBy[K comparable, V any](in map[K]V, predicate func(key K, value V) bool) map[K]V
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](in map[K]V, keys []K) map[K]V
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](in map[K]V, values []V) map[K]V
PickByValues returns same map type filtered by given values. Play: https://go.dev/play/p/1zdzSvbfsJc
func RandomString ¶ added in v1.35.0
RandomString return a random string. Play: https://go.dev/play/p/rRseOQVVum4
func Range ¶ added in v1.10.0
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
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 Repeat ¶ added in v1.5.0
Repeat builds a slice with N copies of initial value. Play: https://go.dev/play/p/g3uHXbmc3b6
func RepeatBy ¶ added in v1.19.0
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](collection []T, old T, new T, n int) []T
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](collection []T, old T, new T) []T
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](collection []T) []T
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
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 Shuffle ¶
func Shuffle[T any](collection []T) []T
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
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
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 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
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 Subset ¶ added in v1.19.0
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
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
Synchronize wraps the underlying callback in a mutex. It receives an optional mutex.
func Ternary ¶
Ternary is a 1 line if/else statement. Play: https://go.dev/play/p/t-D7WBL44h2
func TernaryF ¶ added in v1.30.0
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
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
ToAnySlice returns a slice with all elements mapped to `any` type
func ToSlicePtr ¶
func ToSlicePtr[T any](collection []T) []*T
ToSlicePtr returns a slice of pointer copy of value.
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
Try1 is an alias to Try. Play: https://go.dev/play/p/mTyyWUvn9u4
func Try2 ¶ added in v1.11.0
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
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
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
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
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
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
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
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
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 any, B any, 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 any, B any, C any, 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 any, B any, C any, D any, 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 any, B any, C any, D any, E any, 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
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](lists ...[]T) []T
Union returns all distinct elements from given collections. result returns will not change the order of elements relatively.
func Uniq ¶
func Uniq[T comparable](collection []T) []T
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](collection []T, iteratee func(item T) U) []T
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 Unpack2 ¶ added in v1.17.0
Unpack2 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W
func Unpack3 ¶ added in v1.17.0
Unpack3 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W
func Unpack4 ¶ added in v1.17.0
Unpack4 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W
func Unpack5 ¶ added in v1.17.0
Unpack5 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W
func Unpack6 ¶ added in v1.17.0
func Unpack6[A any, B any, C any, D any, E any, 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 any, B any, C any, D any, E any, F any, 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 any, B any, C any, D any, E any, F any, G any, 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 any, B any, C any, D any, E any, F any, G any, H any, 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
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
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
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 any, B any, C any, D any, 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 any, B any, C any, D any, E any, 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 any, B any, C any, D any, E any, F any, 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 any, B any, C any, D any, E any, F any, G any, 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 any, B any, C any, D any, E any, F any, G any, H any, 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 Validate ¶ added in v1.30.0
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 Without ¶ added in v1.24.0
func Without[T comparable](collection []T, exclude ...T) []T
Without returns slice excluding all given values.
func WithoutEmpty ¶ added in v1.24.0
func WithoutEmpty[T comparable](collection []T) []T
WithoutEmpty returns slice excluding empty values.
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
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 instanciate 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
Tuple2 is a group of 2 elements (pair).
func T2 ¶ added in v1.13.0
T2 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm
func Zip2 ¶ added in v1.4.0
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
type Tuple3 ¶ added in v1.4.0
Tuple3 is a group of 3 elements.
func T3 ¶ added in v1.13.0
T3 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm
func Zip3 ¶ added in v1.4.0
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
type Tuple4 ¶ added in v1.4.0
Tuple4 is a group of 4 elements.
func T4 ¶ added in v1.13.0
T4 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm
func Zip4 ¶ added in v1.4.0
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
type Tuple5 ¶ added in v1.4.0
Tuple5 is a group of 5 elements.
func T5 ¶ added in v1.13.0
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 any, B any, C any, D any, 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
type Tuple6 ¶ added in v1.4.0
Tuple6 is a group of 6 elements.
func T6 ¶ added in v1.13.0
func T6[A any, B any, C any, D any, E any, 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 any, B any, C any, D any, E any, 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
type Tuple7 ¶ added in v1.4.0
Tuple7 is a group of 7 elements.
func T7 ¶ added in v1.13.0
func T7[A any, B any, C any, D any, E any, F any, 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 any, B any, C any, D any, E any, F any, 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
type Tuple8 ¶ added in v1.4.0
type Tuple8[A any, B any, C any, D any, E any, F any, G any, 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 any, B any, C any, D any, E any, F any, G any, 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 any, B any, C any, D any, E any, F any, G any, 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
type Tuple9 ¶ added in v1.4.0
type Tuple9[A any, B any, C any, D any, E any, F any, G any, H any, 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 any, B any, C any, D any, E any, F any, G any, H any, 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 any, B any, C any, D any, E any, F any, G any, H any, 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