fix: test failed

fix: test failed in promise test
release v2.1.17
2026-02-15 02:02:27 +08:00 · 2023-03-20 16:39:56 +08:00 · 2023-03-20 16:26:21 +08:00 · 2023-03-20 16:17:52 +08:00 · 2023-03-20 16:12:58 +08:00 · 2023-03-20 11:10:35 +08:00
18 changed files with 1569 additions and 472 deletions
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
 <br/>

 ![Go version](https://img.shields.io/badge/go-%3E%3Dv1.18-9cf)
-[![Release](https://img.shields.io/badge/release-2.1.16-green.svg)](https://github.com/duke-git/lancet/releases)
+[![Release](https://img.shields.io/badge/release-2.1.17-green.svg)](https://github.com/duke-git/lancet/releases)
 [![GoDoc](https://godoc.org/github.com/duke-git/lancet/v2?status.svg)](https://pkg.go.dev/github.com/duke-git/lancet/v2)
 [![Go Report Card](https://goreportcard.com/badge/github.com/duke-git/lancet/v2)](https://goreportcard.com/report/github.com/duke-git/lancet/v2)
 [![test](https://github.com/duke-git/lancet/actions/workflows/codecov.yml/badge.svg?branch=main&event=push)](https://github.com/duke-git/lancet/actions/workflows/codecov.yml)
@@ -703,6 +703,10 @@ import "github.com/duke-git/lancet/v2/mathutil"
 -   **<big>TruncRound</big>** : round off n decimal places for int64.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#TruncRound)]
    [[play](https://go.dev/play/p/aumarSHIGzP)]
+-   **<big>Range</big>** : Creates a slice of numbers from start with specified count, element step is 1.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#Range)]
+-   **<big>RangeWithStep</big>** : Creates a slice of numbers from start to end with specified step.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#Range)]

 ### 13. Netutil package contains functions to get net information and send http request.

@@ -916,6 +920,8 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>ForEach</big>** : iterates over elements of slice and invokes function for each element.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#ForEach)]
    [[play](https://go.dev/play/p/DrPaa4YsHRF)]
+-   **<big>ForEachWithBreak</big>** : iterates over elements of slice and invokes function for each element, when iteratee return false, will break the for each loop.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#ForEach)]
 -   **<big>GroupBy</big>** : iterate over elements of the slice, each element will be group by criteria, returns two slices.
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#GroupBy)]
    [[play](https://go.dev/play/p/QVkPxzPR0iA)]
@@ -1022,7 +1028,41 @@ import "github.com/duke-git/lancet/v2/slice"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice.md#KeyBy)]
    [[play](https://go.dev/play/p/uXod2LWD1Kg)]

-### 17. Strutil package contains some functions to manipulate string.
+
+### 17. Structs package provides several high level functions to manipulate struct, tag, and field.
+
+```go
+import "github.com/duke-git/lancet/v2/structs"
+```
+
+#### Function list:
+
+-   **<big>New</big>** : creates a `Struct` instance.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct.md#New)]
+-   **<big>ToMap</big>** : converts a valid struct to a map.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct.md#ToMap)]
+-   **<big>Fields</big>** : get all fields of a given struct, that the fields are abstract struct field.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct.md#Fields)]
+-   **<big>IsStruct</big>** : check if the struct is valid.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct.md#IsStruct)]
+-   **<big>Tag</big>** : get a `Tag` of the `Field`, `Tag` is a abstract struct field tag
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field.md#Tag)]
+-   **<big>Name</big>** : get the field name.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field.md#Name)]
+-   **<big>Value</big>** : get the `Field` underlying value.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field.md#Value)]
+-   **<big>Kind</big>** : get the field's kind
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field.md#Kind)]
+-   **<big>IsEmbedded</big>** : check if the field is an embedded field.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field.md#IsEmbedded)]
+-   **<big>IsExported</big>** : check if the field is exporte
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field.md#IsExported)]
+-   **<big>IsZero</big>** : check if the field is zero value
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field.md#IsZero)]
+-   **<big>IsSlice</big>** : check if the field is a slice
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field.md#IsSlice)]
+
+### 18. Strutil package contains some functions to manipulate string.

 ```go
 import "github.com/duke-git/lancet/v2/strutil"
@@ -1135,7 +1175,7 @@ import "github.com/duke-git/lancet/v2/system"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/system.md#GetOsBits)]
    [[play](https://go.dev/play/p/ml-_XH3gJbW)]

-### 19. Validator package contains some functions for data validation.
+### 20. Validator package contains some functions for data validation.

 ```go
 import "github.com/duke-git/lancet/v2/validator"
@@ -1228,7 +1268,7 @@ import "github.com/duke-git/lancet/v2/validator"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/validator.md#IsGBK)]
    [[play](https://go.dev/play/p/E2nt3unlmzP)]

-### 20. xerror package implements helpers for errors.
+### 21. xerror package implements helpers for errors.

 ```go
 import "github.com/duke-git/lancet/v2/xerror"
--- a/README_zh-CN.md
+++ b/README_zh-CN.md
@@ -4,7 +4,7 @@
 <br/>

 ![Go version](https://img.shields.io/badge/go-%3E%3Dv1.18-9cf)
-[![Release](https://img.shields.io/badge/release-2.1.16-green.svg)](https://github.com/duke-git/lancet/releases)
+[![Release](https://img.shields.io/badge/release-2.1.17-green.svg)](https://github.com/duke-git/lancet/releases)
 [![GoDoc](https://godoc.org/github.com/duke-git/lancet/v2?status.svg)](https://pkg.go.dev/github.com/duke-git/lancet/v2)
 [![Go Report Card](https://goreportcard.com/badge/github.com/duke-git/lancet/v2)](https://goreportcard.com/report/github.com/duke-git/lancet/v2)
 [![test](https://github.com/duke-git/lancet/actions/workflows/codecov.yml/badge.svg?branch=main&event=push)](https://github.com/duke-git/lancet/actions/workflows/codecov.yml)
@@ -72,7 +72,7 @@ func main() {

 ## 文档

-### 1. algorithm 包实现一些基本查找和排序算法。
+### 1. algorithm包实现一些基本查找和排序算法。

 ```go
 import "github.com/duke-git/lancet/v2/algorithm"
@@ -117,7 +117,7 @@ import "github.com/duke-git/lancet/v2/algorithm"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/algorithm_zh-CN.md#LRUCache)]
    [[play](https://go.dev/play/p/-EZjgOURufP)]

-### 2. concurrency 包含一些支持并发编程的功能。例如：goroutine, channel, async 等。
+### 2. concurrency包含一些支持并发编程的功能。例如：goroutine, channel, async 等。

 ```go
 import "github.com/duke-git/lancet/v2/concurrency"
@@ -156,7 +156,7 @@ import "github.com/duke-git/lancet/v2/concurrency"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/concurrency_zh-CN.md#Tee)]
    [[play](https://go.dev/play/p/3TQPKnCirrP)]

-### 3. condition 包含一些用于条件判断的函数。
+### 3. condition包含一些用于条件判断的函数。

 ```go
 import "github.com/duke-git/lancet/v2/condition"
@@ -189,7 +189,7 @@ import "github.com/duke-git/lancet/v2/condition"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/condition_zh-CN.md#TernaryOperator)]
    [[play](https://go.dev/play/p/ElllPZY0guT)]

-### 4. convertor 转换器包支持一些常见的数据类型转换。
+### 4. convertor转换器包支持一些常见的数据类型转换。

 ```go
 import "github.com/duke-git/lancet/v2/convertor"
@@ -252,7 +252,7 @@ import "github.com/duke-git/lancet/v2/convertor"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#CopyProperties)]
    [[play](https://go.dev/play/p/FOVY3XJL-6B)]

-### 5. cryptor 加密包支持数据加密和解密，获取 md5，hash 值。支持 base64, md5, hmac, aes, des, rsa。
+### 5. cryptor加密包支持数据加密和解密，获取 md5，hash 值。支持 base64, md5, hmac, aes, des, rsa。

 ```go
 import "github.com/duke-git/lancet/v2/cryptor"
@@ -356,7 +356,7 @@ import "github.com/duke-git/lancet/v2/cryptor"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/cryptor_zh-CN.md#RsaDecrypt)]
    [[play](https://go.dev/play/p/uef0q1fz53I)]

-### 6. datetime 日期时间处理包，格式化日期，比较日期。
+### 6. datetime日期时间处理包，格式化日期，比较日期。

 ```go
 import "github.com/duke-git/lancet/v2/datetime"
@@ -455,7 +455,7 @@ import "github.com/duke-git/lancet/v2/datetime"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/datetime_zh-CN.md#ToIso8601)]
    [[play](https://go.dev/play/p/mkhOHQkdeA2)]

-### 7. datastructure 包含一些普通的数据结构实现。例如：list, linklist, stack, queue, set, tree, graph.
+### 7. datastructure包含一些普通的数据结构实现。例如：list, linklist, stack, queue, set, tree, graph.

 ```go
 import list "github.com/duke-git/lancet/v2/datastructure/list"
@@ -487,7 +487,7 @@ import hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
 -   **<big>Hashmap</big>** : 哈希映射。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/datastructure/hashmap_zh-CN.md)]

-### 8. fileutil 包含文件基本操作。
+### 8. fileutil包含文件基本操作。

 ```go
 import "github.com/duke-git/lancet/v2/fileutil"
@@ -541,7 +541,7 @@ import "github.com/duke-git/lancet/v2/fileutil"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/fileutil_zh-CN.md#UnZip)]
    [[play](https://go.dev/play/p/g0w34kS7B8m)]

-### 9. formatter 格式化器包含一些数据格式化处理方法。
+### 9. formatter格式化器包含一些数据格式化处理方法。

 ```go
 import "github.com/duke-git/lancet/v2/formatter"
@@ -553,7 +553,7 @@ import "github.com/duke-git/lancet/v2/formatter"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/formatter_zh-CN.md#Comma)]
    [[play](https://go.dev/play/p/eRD5k2vzUVX)]

-### 10. function 函数包控制函数执行流程，包含部分函数式编程。
+### 10. function函数包控制函数执行流程，包含部分函数式编程。

 ```go
 import "github.com/duke-git/lancet/v2/function"
@@ -589,7 +589,7 @@ import "github.com/duke-git/lancet/v2/function"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/function_zh-CN.md#Watcher)]
    [[play](https://go.dev/play/p/l2yrOpCLd1I)]

-### 11. maputil 包括一些操作 map 的函数.
+### 11. maputil包括一些操作 map 的函数.

 ```go
 import "github.com/duke-git/lancet/v2/maputil"
@@ -658,7 +658,7 @@ import "github.com/duke-git/lancet/v2/maputil"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#IsDisjoint)]
    [[play](https://go.dev/play/p/N9qgYg_Ho6f)]

-### 12. mathutil 包实现了一些数学计算的函数。
+### 12. mathutil包实现了一些数学计算的函数。

 ```go
 import "github.com/duke-git/lancet/v2/mathutil"
@@ -702,8 +702,12 @@ import "github.com/duke-git/lancet/v2/mathutil"
 -   **<big>TruncRound</big>** : 截短 n 位小数（不进行四舍五入）。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#TruncRound)]
    [[play](https://go.dev/play/p/aumarSHIGzP)]
+-   **<big>Range</big>** : 根据指定的起始值和数量，创建一个数字切片。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#Range)]
+-   **<big>RangeWithStep</big>** : 根据指定的起始值，结束值，步长，创建一个数字切片。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#RangeWithStep)]

-### 13. netutil 网络包支持获取 ip 地址，发送 http 请求。
+### 13. netutil网络包支持获取 ip 地址，发送 http 请求。

 ```go
 import "github.com/duke-git/lancet/v2/netutil"
@@ -766,7 +770,7 @@ import "github.com/duke-git/lancet/v2/netutil"
 -   **<big>ParseHttpResponse</big>** : 解析 http 响应体到目标结构体。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#ParseHttpResponse)]

-### 14. random 随机数生成器包，可以生成随机[]bytes, int, string。
+### 14. random随机数生成器包，可以生成随机[]bytes, int, string。

 ```go
 import "github.com/duke-git/lancet/v2/random"
@@ -799,7 +803,7 @@ import "github.com/duke-git/lancet/v2/random"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/random_zh-CN.md#UUIdV4)]
    [[play](https://go.dev/play/p/_Z9SFmr28ft)]

-### 15. retry 重试执行函数直到函数运行成功或被 context cancel。
+### 15. retry重试执行函数直到函数运行成功或被 context cancel。

 ```go
 import "github.com/duke-git/lancet/v2/retry"
@@ -823,7 +827,7 @@ import "github.com/duke-git/lancet/v2/retry"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/retry_zh-CN.md#RetryTimes)]
    [[play](https://go.dev/play/p/ssfVeU2SwLO)]

-### 16. slice 包含操作切片的方法集合。
+### 16. slice包含操作切片的方法集合。

 ```go
 import "github.com/duke-git/lancet/v2/slice"
@@ -915,6 +919,8 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>ForEach</big>** : 遍历切片的元素并为每个元素调用 iteratee 函数。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#ForEach)]
    [[play](https://go.dev/play/p/DrPaa4YsHRF)]
+-   **<big>ForEachWithBreak</big>** : 遍历切片的元素并为每个元素调用iteratee函数，当iteratee函数返回false时，终止遍历。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#ForEachWithBreak)]
 -   **<big>GroupBy</big>** : 迭代切片的元素，每个元素将按条件分组，返回两个切片。
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#GroupBy)]
    [[play](https://go.dev/play/p/QVkPxzPR0iA)]
@@ -1021,7 +1027,42 @@ import "github.com/duke-git/lancet/v2/slice"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#KeyBy)]
    [[play](https://go.dev/play/p/uXod2LWD1Kg)]

-### 17. strutil 包含字符串处理的相关函数。
+### 17. structs提供操作struct, tag, field的相关函数。
+
+```go
+import "github.com/duke-git/lancet/v2/structs"
+```
+
+#### Function list:
+
+-   **<big>New</big>** : `Struct`结构体的构造函数。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#New)]
+-   **<big>ToMap</big>** : 将一个合法的struct对象转换为map[string]any。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#ToMap)]
+-   **<big>Fields</big>** : 获取一个struct对象的属性列表。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#Fields)]
+-   **<big>Field</big>** : 根据属性名获取一个struct对象的属性。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#Fields)]
+-   **<big>IsStruct</big>** : 判断是否为一个合法的struct对象。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#IsStruct)]
+-   **<big>Tag</big>** : 获取`Field`的`Tag`，默认的tag key是json。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field_zh-CN.md#Tag)]
+-   **<big>Name</big>** : 获取属性名。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field_zh-CN.md#Name)]
+-   **<big>Value</big>** : 获取`Field`属性的值。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field_zh-CN.md#Value)]
+-   **<big>Kind</big>** : 获取属性Kind。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field_zh-CN.md#Kind)]
+-   **<big>IsEmbedded</big>** : 判断属性是否为嵌入。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field_zh-CN.md#IsEmbedded)]
+-   **<big>IsExported</big>** : 判断属性是否导出。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field_zh-CN.md#IsExported)]
+-   **<big>IsZero</big>** : 判断属性是否为零值。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field_zh-CN.md#IsZero)]
+-   **<big>IsSlice</big>** : 判断属性是否是切片。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/structs/field_zh-CN.md#IsSlice)]
+
+### 18. strutil包含字符串处理的相关函数。

 ```go
 import "github.com/duke-git/lancet/v2/strutil"
@@ -1100,7 +1141,7 @@ import "github.com/duke-git/lancet/v2/strutil"
    [[play](https://go.dev/play/p/bj7_odx3vRf)]


-### 18. system 包含 os, runtime, shell command 的相关函数。
+### 19. system包含 os, runtime, shell command 的相关函数。

 ```go
 import "github.com/duke-git/lancet/v2/system"
@@ -1136,7 +1177,7 @@ import "github.com/duke-git/lancet/v2/system"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/system_zh-CN#GetOsBits)]
    [[play](https://go.dev/play/p/ml-_XH3gJbW)]

-### 19. validator 验证器包，包含常用字符串格式验证函数。
+### 20. validator验证器包，包含常用字符串格式验证函数。

 ```go
 import "github.com/duke-git/lancet/v2/validator"
@@ -1229,7 +1270,7 @@ import "github.com/duke-git/lancet/v2/validator"
    [[doc](https://github.com/duke-git/lancet/blob/main/docs/validator_zh-CN.md#IsGBK)]
    [[play](https://go.dev/play/p/E2nt3unlmzP)]

-### 20. xerror 包实现一些错误处理函数
+### 21. xerror包实现一些错误处理函数

 ```go
 import "github.com/duke-git/lancet/v2/xerror"
--- a/async/promise.go
+++ b/async/promise.go
@@ -0,0 +1,279 @@
+// Copyright 2023 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package async contain some featurese to support async programming. eg, promise, asycn/await, eventbus.
+package async
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+// Promise represents the eventual completion (or failure) of an asynchronous operation and its resulting value.
+// ref : chebyrash/promise (https://github.com/chebyrash/promise)
+// see js promise: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
+type Promise[T any] struct {
+	runnable func(resolve func(T), reject func(error))
+	result   T
+	err      error
+
+	pending bool
+
+	mu *sync.Mutex
+	wg *sync.WaitGroup
+}
+
+// New create a new promise instance.
+func New[T any](runnable func(resolve func(T), reject func(error))) *Promise[T] {
+	if runnable == nil {
+		panic("runnable function should not be nil")
+	}
+
+	p := &Promise[T]{
+		runnable: runnable,
+		pending:  true,
+		mu:       &sync.Mutex{},
+		wg:       &sync.WaitGroup{},
+	}
+
+	defer p.run()
+
+	return p
+}
+
+func (p *Promise[T]) run() {
+	p.wg.Add(1)
+
+	go func() {
+		defer func() {
+			if !p.pending {
+				return
+			}
+
+			if err := recover(); err != nil {
+				p.reject(errors.New(fmt.Sprint(err)))
+			}
+		}()
+
+		p.runnable(p.resolve, p.reject)
+	}()
+}
+
+// Resolve returns a Promise that has been resolved with a given value.
+func Resolve[T any](resolution T) *Promise[T] {
+	return &Promise[T]{
+		result:  resolution,
+		pending: false,
+		mu:      &sync.Mutex{},
+		wg:      &sync.WaitGroup{},
+	}
+}
+
+func (p *Promise[T]) resolve(value T) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if !p.pending {
+		return
+	}
+
+	p.result = value
+	p.pending = false
+
+	p.wg.Done()
+}
+
+// Reject returns a Promise that has been rejected with a given error.
+func Reject[T any](err error) *Promise[T] {
+	return &Promise[T]{
+		err:     err,
+		pending: false,
+		mu:      &sync.Mutex{},
+		wg:      &sync.WaitGroup{},
+	}
+}
+
+func (p *Promise[T]) reject(err error) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if !p.pending {
+		return
+	}
+
+	p.err = err
+	p.pending = false
+
+	p.wg.Done()
+}
+
+// Then allows chain calls to other promise methods.
+func Then[T1, T2 any](promise *Promise[T1], resolve1 func(value T1) T2) *Promise[T2] {
+	return New(func(resolve2 func(T2), reject func(error)) {
+		result, err := promise.Await()
+		if err != nil {
+			reject(err)
+			return
+		}
+		resolve2(resolve1(result))
+	})
+}
+
+// Then allows chain calls to other promise methods.
+func (p *Promise[T]) Then(resolve func(value T) T) *Promise[T] {
+	return New(func(_resolve func(T), reject func(error)) {
+		result, err := p.Await()
+		if err != nil {
+			reject(err)
+			return
+		}
+		_resolve(resolve(result))
+	})
+}
+
+// Catch allows to chain promises.
+func Catch[T any](promise *Promise[T], rejection func(err error) error) *Promise[T] {
+	return New(func(resolve func(T), reject func(error)) {
+		result, err := promise.Await()
+		if err != nil {
+			reject(rejection(err))
+			return
+		}
+		resolve(result)
+	})
+}
+
+// Catch chain an existing promise with an intermediate reject function.
+func (p *Promise[T]) Catch(reject func(error) error) *Promise[T] {
+	return New(func(resolve func(T), rej func(error)) {
+		resutl, err := p.Await()
+		if err != nil {
+			rej(reject(err))
+			return
+		}
+		resolve(resutl)
+	})
+}
+
+// Await blocks until the 'runable' to finish execution.
+func (p *Promise[T]) Await() (T, error) {
+	p.wg.Wait()
+	return p.result, p.err
+}
+
+type tuple[T1, T2 any] struct {
+	_1 T1
+	_2 T2
+}
+
+// All resolves when all of the promises have resolved, reject immediately upon any of the input promises rejecting.
+func All[T any](promises []*Promise[T]) *Promise[[]T] {
+	if len(promises) == 0 {
+		return nil
+	}
+
+	return New(func(resolve func([]T), reject func(error)) {
+		valsChan := make(chan tuple[T, int], len(promises))
+		errsChan := make(chan error, 1)
+
+		for idx, p := range promises {
+			idx := idx
+			_ = Then(p, func(data T) T {
+				valsChan <- tuple[T, int]{_1: data, _2: idx}
+				return data
+			})
+			_ = Catch(p, func(err error) error {
+				errsChan <- err
+				return err
+			})
+		}
+
+		resolutions := make([]T, len(promises))
+		for idx := 0; idx < len(promises); idx++ {
+			select {
+			case val := <-valsChan:
+				resolutions[val._2] = val._1
+			case err := <-errsChan:
+				reject(err)
+				return
+			}
+		}
+		resolve(resolutions)
+	})
+}
+
+// Race will settle the first fullfiled promise among muti promises.
+func Race[T any](promises []*Promise[T]) *Promise[T] {
+	if len(promises) == 0 {
+		return nil
+	}
+
+	return New(func(resolve func(T), reject func(error)) {
+		valsChan := make(chan T, 1)
+		errsChan := make(chan error, 1)
+
+		for _, p := range promises {
+			_ = Then(p, func(data T) T {
+				valsChan <- data
+				return data
+			})
+			_ = Catch(p, func(err error) error {
+				errsChan <- err
+				return err
+			})
+		}
+
+		select {
+		case val := <-valsChan:
+			resolve(val)
+		case err := <-errsChan:
+			reject(err)
+		}
+	})
+}
+
+// Any resolves as soon as any of the input's Promises resolve, with the value of the resolved Promise.
+// Any rejects if all of the given Promises are rejected with a combination of all errors.
+func Any[T any](promises []*Promise[T]) *Promise[T] {
+	if len(promises) == 0 {
+		return nil
+	}
+
+	return New(func(resolve func(T), reject func(error)) {
+		valsChan := make(chan T, 1)
+		errsChan := make(chan tuple[error, int], len(promises))
+
+		for idx, p := range promises {
+			idx := idx
+			_ = Then(p, func(data T) T {
+				valsChan <- data
+				return data
+			})
+			_ = Catch(p, func(err error) error {
+				errsChan <- tuple[error, int]{_1: err, _2: idx}
+				return err
+			})
+		}
+
+		errs := make([]error, len(promises))
+		for idx := 0; idx < len(promises); idx++ {
+			select {
+			case val := <-valsChan:
+				resolve(val)
+				return
+			case err := <-errsChan:
+				errs[err._2] = err._1
+			}
+		}
+
+		errCombo := errs[0]
+		for _, err := range errs[1:] {
+			errCombo = internal.JoinError(err)
+		}
+
+		reject(errCombo)
+	})
+}
--- a/async/promise_example_test.go
+++ b/async/promise_example_test.go
@@ -0,0 +1,195 @@
+package async
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func ExampleNew() {
+	p := New(func(resolve func(string), reject func(error)) {
+		resolve("hello")
+	})
+
+	val, err := p.Await()
+	if err != nil {
+		return
+	}
+
+	fmt.Println(val)
+
+	// Output:
+	// hello
+}
+
+func ExampleThen() {
+	p1 := New(func(resolve func(string), reject func(error)) {
+		resolve("hello ")
+	})
+
+	p2 := Then(p1, func(s string) string {
+		return s + "world"
+	})
+
+	result, err := p2.Await()
+	if err != nil {
+		return
+	}
+
+	fmt.Println(result)
+
+	// Output:
+	// hello world
+}
+
+func ExamplePromise_Then() {
+	p1 := New(func(resolve func(string), reject func(error)) {
+		resolve("hello ")
+	})
+
+	p2 := p1.Then(func(s string) string {
+		return s + "world"
+	})
+
+	result, err := p2.Await()
+	if err != nil {
+		return
+	}
+
+	fmt.Println(result)
+
+	// Output:
+	// hello world
+}
+
+func ExampleCatch() {
+	p1 := New(func(resolve func(string), reject func(error)) {
+		err := errors.New("error1")
+		reject(err)
+	})
+
+	p2 := Catch(p1, func(err error) error {
+		e := errors.New("error2")
+		return internal.JoinError(err, e)
+	})
+
+	_, err := p1.Await()
+
+	fmt.Println(err.Error())
+
+	result2, err := p2.Await()
+
+	fmt.Println(result2)
+	fmt.Println(err.Error())
+
+	// Output:
+	// error1
+	//
+	// error1
+	// error2
+}
+
+func ExamplePromise_Catch() {
+	p1 := New(func(resolve func(string), reject func(error)) {
+		err := errors.New("error1")
+		reject(err)
+	})
+
+	p2 := p1.Catch(func(err error) error {
+		e := errors.New("error2")
+		return internal.JoinError(err, e)
+	})
+
+	_, err := p1.Await()
+
+	fmt.Println(err.Error())
+
+	result2, err := p2.Await()
+
+	fmt.Println(result2)
+	fmt.Println(err.Error())
+
+	// Output:
+	// error1
+	//
+	// error1
+	// error2
+}
+
+func ExampleAll() {
+	p1 := New(func(resolve func(string), reject func(error)) {
+		resolve("a")
+	})
+	p2 := New(func(resolve func(string), reject func(error)) {
+		resolve("b")
+	})
+	p3 := New(func(resolve func(string), reject func(error)) {
+		resolve("c")
+	})
+
+	pms := []*Promise[string]{p1, p2, p3}
+	p := All(pms)
+
+	result, err := p.Await()
+	if err != nil {
+		return
+	}
+
+	fmt.Println(result)
+
+	// Output:
+	// [a b c]
+}
+
+func ExampleAny() {
+	p1 := New(func(resolve func(string), reject func(error)) {
+		time.Sleep(time.Millisecond * 250)
+		resolve("fast")
+	})
+	p2 := New(func(resolve func(string), reject func(error)) {
+		time.Sleep(time.Millisecond * 500)
+		resolve("slow")
+	})
+	p3 := New(func(resolve func(string), reject func(error)) {
+		reject(errors.New("error"))
+	})
+
+	pms := []*Promise[string]{p1, p2, p3}
+	p := Any(pms)
+
+	result, err := p.Await()
+	if err != nil {
+		return
+	}
+
+	fmt.Println(result)
+
+	// Output:
+	// fast
+}
+
+func ExampleRace() {
+	p1 := New(func(resolve func(string), reject func(error)) {
+		time.Sleep(time.Millisecond * 100)
+		resolve("fast")
+	})
+	p2 := New(func(resolve func(string), reject func(error)) {
+		time.Sleep(time.Millisecond * 300)
+		resolve("slow")
+	})
+
+	pms := []*Promise[string]{p1, p2}
+	p := Race(pms)
+
+	result, err := p.Await()
+	if err != nil {
+		return
+	}
+
+	fmt.Println(result)
+
+	// Output:
+	// fast
+}
--- a/async/promise_test.go
+++ b/async/promise_test.go
@@ -0,0 +1,302 @@
+package async
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestResolve(t *testing.T) {
+	assert := internal.NewAssert(t, "TestResolve")
+
+	p := Resolve("abc")
+
+	assert.Equal("abc", p.result)
+	assert.Equal(false, p.pending)
+}
+
+func TestReject(t *testing.T) {
+	assert := internal.NewAssert(t, "TestReject")
+
+	err := errors.New("error")
+	p := Reject[string](err)
+
+	assert.Equal("error", p.err.Error())
+	assert.Equal(false, p.pending)
+}
+
+func TestThen(t *testing.T) {
+	assert := internal.NewAssert(t, "TestThen")
+
+	p1 := New(func(resolve func(string), reject func(error)) {
+		resolve("abc")
+	})
+
+	p2 := Then(p1, func(data string) string {
+		return data + "de"
+	})
+
+	val, err := p1.Await()
+	assert.IsNil(err)
+	assert.Equal("abc", val)
+
+	val, err = p2.Await()
+	assert.IsNil(err)
+	assert.Equal("abcde", val)
+}
+
+func TestPromise_Then(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPromise_Then")
+
+	p1 := New(func(resolve func(int), reject func(error)) {
+		resolve(1)
+	})
+
+	p2 := p1.Then(func(n int) int {
+		return n + 2
+	})
+
+	val, err := p1.Await()
+	assert.IsNil(err)
+	assert.Equal(1, val)
+
+	val, err = p2.Await()
+	assert.IsNil(err)
+	assert.Equal(3, val)
+}
+
+func TestCatch(t *testing.T) {
+	assert := internal.NewAssert(t, "TestCatch")
+
+	p1 := New(func(resolve func(string), reject func(error)) {
+		err := errors.New("error1")
+		reject(err)
+	})
+
+	p2 := Catch(p1, func(err error) error {
+		e := errors.New("error2")
+		return internal.JoinError(err, e)
+	})
+
+	val, err := p1.Await()
+	assert.Equal("", val)
+	assert.IsNotNil(err)
+	assert.Equal("error1", err.Error())
+
+	val, err = p2.Await()
+
+	assert.Equal("", val)
+	assert.IsNotNil(err)
+	assert.Equal("error1\nerror2", err.Error())
+}
+
+func TestPromise_Catch(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPromise_Catch")
+
+	p1 := New(func(resolve func(string), reject func(error)) {
+		err := errors.New("error1")
+		reject(err)
+	})
+
+	p2 := p1.Catch(func(err error) error {
+		e := errors.New("error2")
+		return internal.JoinError(err, e)
+	})
+
+	val, err := p1.Await()
+	assert.Equal("", val)
+	assert.IsNotNil(err)
+	assert.Equal("error1", err.Error())
+
+	val, err = p2.Await()
+
+	assert.Equal("", val)
+	assert.IsNotNil(err)
+	assert.Equal("error1\nerror2", err.Error())
+}
+
+func TestAll(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPromise_All")
+
+	t.Run("AllPromisesFullfilled", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			resolve("a")
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			resolve("b")
+		})
+		p3 := New(func(resolve func(string), reject func(error)) {
+			resolve("c")
+		})
+
+		p := All([]*Promise[string]{p1, p2, p3})
+
+		val, err := p.Await()
+		assert.Equal([]string{"a", "b", "c"}, val)
+		assert.IsNil(err)
+	})
+
+	t.Run("EmptyPromises", func(_ *testing.T) {
+		var empty = []*Promise[any]{}
+		p := All(empty)
+		assert.IsNil(p)
+	})
+
+	t.Run("PromisesContainRejected", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			resolve("a")
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error1"))
+		})
+		p3 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error2"))
+		})
+
+		p := All([]*Promise[string]{p1, p2, p3})
+
+		_, err := p.Await()
+
+		assert.IsNotNil(err)
+		// assert.Equal("error1", err.Error())
+	})
+
+	t.Run("PromisesOnlyRejected", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error1"))
+
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error2"))
+		})
+		p3 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error3"))
+		})
+
+		p := All([]*Promise[string]{p1, p2, p3})
+
+		_, err := p.Await()
+
+		assert.IsNotNil(err)
+		// assert.Equal("error1", err.Error())
+	})
+
+}
+
+func TestAny(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPromise_Any")
+
+	t.Run("AnyFullfilled", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			time.Sleep(time.Millisecond * 250)
+			resolve("fast")
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			time.Sleep(time.Millisecond * 500)
+			resolve("slow")
+		})
+		p3 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error"))
+		})
+
+		p := Any([]*Promise[string]{p1, p2, p3})
+
+		val, err := p.Await()
+		assert.Equal("fast", val)
+		assert.IsNil(err)
+	})
+
+	t.Run("EmptyPromises", func(_ *testing.T) {
+		var empty = []*Promise[any]{}
+		p := Any(empty)
+		assert.IsNil(p)
+	})
+
+	t.Run("OnlyRejected", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error1"))
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error2"))
+		})
+
+		p := Any([]*Promise[string]{p1, p2})
+
+		_, err := p.Await()
+
+		assert.IsNotNil(err)
+		// assert.Equal("error1", err.Error())
+	})
+
+}
+
+func TestRace(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPromise_Race")
+
+	t.Run("PromisesFullfilled", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			time.Sleep(time.Millisecond * 100)
+			resolve("a")
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			time.Sleep(time.Millisecond * 300)
+			resolve("b")
+		})
+
+		p := Race([]*Promise[string]{p1, p2})
+
+		val, err := p.Await()
+		assert.Equal("a", val)
+		assert.IsNil(err)
+	})
+
+	t.Run("EmptyPromises", func(_ *testing.T) {
+		var empty = []*Promise[any]{}
+		p := Race(empty)
+		assert.IsNil(p)
+	})
+
+	t.Run("PromisesContainRejected", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			time.Sleep(time.Millisecond * 100)
+			resolve("a")
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error1"))
+		})
+		p3 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error2"))
+		})
+
+		p := Race([]*Promise[string]{p1, p2, p3})
+
+		val, err := p.Await()
+
+		assert.IsNotNil(err)
+		// assert.Equal("error1", err.Error())
+		assert.Equal("", val)
+	})
+
+	t.Run("PromisesOnlyRejected", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error1"))
+
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error2"))
+		})
+		p3 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error3"))
+		})
+
+		p := Race([]*Promise[string]{p1, p2, p3})
+
+		_, err := p.Await()
+
+		assert.IsNotNil(err)
+		// assert.Equal("error1", err.Error())
+	})
+
+}
--- a/concurrency/channel.go
+++ b/concurrency/channel.go
@@ -1,7 +1,7 @@
 // Copyright 2021 dudaodong@gmail.com. All rights reserved.
 // Use of this source code is governed by MIT license

-// Package concurrency contain some functions to support concurrent programming. eg, goroutine, channel, async.
+// Package concurrency contain some functions to support concurrent programming. eg, goroutine, channel.
 package concurrency

 import (
--- a/datastructure/set/set.go
+++ b/datastructure/set/set.go
@@ -171,3 +171,25 @@ func (s Set[T]) Minus(comparedSet Set[T]) Set[T] {

 	return set
 }
+
+// EachWithBreak iterates over elements of a set and invokes function for each element,
+// when iteratee return false, will break the for each loop.
+func (s Set[T]) EachWithBreak(iteratee func(item T) bool) {
+	for v := range s {
+		if !iteratee(v) {
+			break
+		}
+	}
+}
+
+// Pop delete the top element of set then return it, if set is empty, return nil-value of T and false.
+func (s Set[T]) Pop() (v T, ok bool) {
+	if len(s) > 0 {
+		items := s.Values()
+		item := items[len(s)-1]
+		delete(s, item)
+		return item, true
+	}
+
+	return v, false
+}
--- a/datastructure/set/set_test.go
+++ b/datastructure/set/set_test.go
@@ -192,3 +192,40 @@ func TestSet_Minus(t *testing.T) {
 	assert.Equal(NewSet(1), set1.Minus(set2))
 	assert.Equal(NewSet(4, 5), set2.Minus(set3))
 }
+
+func TestEachWithBreak(t *testing.T) {
+	s := NewSet(1, 2, 3, 4, 5)
+
+	var sum int
+
+	s.EachWithBreak(func(n int) bool {
+		if n > 3 {
+			return false
+		}
+		sum += n
+		return true
+	})
+
+	assert := internal.NewAssert(t, "TestEachWithBreak")
+	assert.Equal(6, sum)
+}
+
+// func TestPop(t *testing.T) {
+// 	assert := internal.NewAssert(t, "TestPop")
+
+// 	s := NewSet[int]()
+
+// 	val, ok := s.Pop()
+// 	assert.Equal(0, val)
+// 	assert.Equal(false, ok)
+
+// 	s.Add(1)
+// 	s.Add(2)
+// 	s.Add(3)
+
+// 	// s = NewSet(1, 2, 3, 4, 5)
+
+// 	val, ok = s.Pop()
+// 	assert.Equal(3, val)
+// 	assert.Equal(true, ok)
+// }
--- a/docs/concurrency.md
+++ b/docs/concurrency.md
@@ -1,5 +1,5 @@
 # Concurrency
-Package concurrency contain some functions to support concurrent programming. eg, goroutine, channel, async.
+Package concurrency contain some functions to support concurrent programming. eg, goroutine, channel.

 <div STYLE="page-break-after: always;"></div>

--- a/docs/concurrency_zh-CN.md
+++ b/docs/concurrency_zh-CN.md
@@ -1,5 +1,5 @@
 # Concurrency
-并发包包含一些支持并发编程的功能。例如：goroutine, channel, async等。
+并发包包含一些支持并发编程的功能。例如：goroutine, channel等。

 <div STYLE="page-break-after: always;"></div>

--- a/docs/datastructure/set.md
+++ b/docs/datastructure/set.md
@@ -1,16 +1,17 @@
 # Set
+
 Set is a data container, like list, but elements of set is not duplicate.

 <div STYLE="page-break-after: always;"></div>

 ## Source

- [https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go](https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go)
-
+-   [https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go](https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go)

 <div STYLE="page-break-after: always;"></div>

 ## Usage
+
 ```go
 import (
    set "github.com/duke-git/lancet/v2/datastructure/set"
@@ -21,32 +22,32 @@ import (

 ## Index

- [NewSet](#NewSet)
- [NewSetFromSlice](#NewSetFromSlice)
- [Values](#Values)
- [Add](#Add)
- [AddIfNotExist](#AddIfNotExist)
- [AddIfNotExistBy](#AddIfNotExistBy)
- [Delete](#Delete)
- [Contain](#Contain)
- [ContainAll](#ContainAll)
- [Clone](#Clone)
- [Size](#Size)
- [Equal](#Equal)
- [Iterate](#Iterate)
- [IsEmpty](#IsEmpty)
- [Union](#Union)
- [Intersection](#Intersection)
- [SymmetricDifference](#SymmetricDifference)
- [Minus](#Minus)
-
-
+-   [NewSet](#NewSet)
+-   [NewSetFromSlice](#NewSetFromSlice)
+-   [Values](#Values)
+-   [Add](#Add)
+-   [AddIfNotExist](#AddIfNotExist)
+-   [AddIfNotExistBy](#AddIfNotExistBy)
+-   [Delete](#Delete)
+-   [Contain](#Contain)
+-   [ContainAll](#ContainAll)
+-   [Clone](#Clone)
+-   [Size](#Size)
+-   [Equal](#Equal)
+-   [Iterate](#Iterate)
+-   [EachWithBreak](#EachWithBreak)
+-   [IsEmpty](#IsEmpty)
+-   [Union](#Union)
+-   [Intersection](#Intersection)
+-   [SymmetricDifference](#SymmetricDifference)
+-   [Minus](#Minus)

 <div STYLE="page-break-after: always;"></div>

 ## Documentation

 ### <span id="NewSet">NewSet</span>
+
 <p>Create a set instance</p>

 <b>Signature:</b>
@@ -55,6 +56,7 @@ import (
 type Set[T comparable] map[T]bool
 func NewSet[T comparable](items ...T) Set[T]
 ```
+
 <b>Example:</b>

 ```go
@@ -71,8 +73,8 @@ func main() {
 }
 ```

-
 ### <span id="NewSetFromSlice">NewSetFromSlice</span>
+
 <p>Create a set from slice</p>

 <b>Signature:</b>
@@ -80,6 +82,7 @@ func main() {
 ```go
 func NewSetFromSlice[T comparable](items []T) Set[T]
 ```
+
 <b>Example:</b>

 ```go
@@ -96,9 +99,8 @@ func main() {
 }
 ```

-
-
 ### <span id="Values">Values</span>
+
 <p>Return slice of all set data</p>

 <b>Signature:</b>
@@ -106,6 +108,7 @@ func main() {
 ```go
 func (s Set[T]) Values() []T
 ```
+
 <b>Example:</b>

 ```go
@@ -122,10 +125,8 @@ func main() {
 }
 ```

-
-
-
 ### <span id="Add">Add</span>
+
 <p>Add items to set</p>

 <b>Signature:</b>
@@ -133,6 +134,7 @@ func main() {
 ```go
 func (s Set[T]) Add(items ...T)
 ```
+
 <b>Example:</b>

 ```go
@@ -151,8 +153,8 @@ func main() {
 }
 ```

-
 ### <span id="AddIfNotExist">AddIfNotExist</span>
+
 <p>AddIfNotExist checks if item exists in the set, it adds the item to set and returns true if it does not exist in the set, or else it does nothing and returns false.</p>

 <b>Signature:</b>
@@ -160,6 +162,7 @@ func main() {
 ```go
 func (s Set[T]) AddIfNotExist(item T) bool
 ```
+
 <b>Example:</b>

 ```go
@@ -175,7 +178,7 @@ func main() {
    st.Add(1, 2, 3)

    r1 := st.AddIfNotExist(1)
-	r2 := st.AddIfNotExist(4)
+    r2 := st.AddIfNotExist(4)

    fmt.Println(r1) // false
    fmt.Println(r2) // true
@@ -183,8 +186,8 @@ func main() {
 }
 ```

-
 ### <span id="AddIfNotExistBy">AddIfNotExistBy</span>
+
 <p>AddIfNotExistBy checks if item exists in the set and pass the `checker` function it adds the item to set and returns true if it does not exists in the set and function `checker` returns true, or else it does nothing and returns false.</p>

 <b>Signature:</b>
@@ -192,6 +195,7 @@ func main() {
 ```go
 func (s Set[T]) AddIfNotExistBy(item T, checker func(element T) bool) bool
 ```
+
 <b>Example:</b>

 ```go
@@ -206,23 +210,23 @@ func main() {
    st := set.NewSet[int]()
    st.Add(1, 2)

-	ok := st.AddIfNotExistBy(3, func(val int) bool {
-		return val%2 != 0
-	})
+    ok := st.AddIfNotExistBy(3, func(val int) bool {
+        return val%2 != 0
+    })
    fmt.Println(ok) // true


-	notOk := st.AddIfNotExistBy(4, func(val int) bool {
-		return val%2 != 0
-	})
+    notOk := st.AddIfNotExistBy(4, func(val int) bool {
+        return val%2 != 0
+    })
    fmt.Println(notOk) // false
-    
+
    fmt.Println(st.Values()) // 1, 2, 3
 }
 ```

-
 ### <span id="Delete">Delete</span>
+
 <p>Delete item in set</p>

 <b>Signature:</b>
@@ -230,6 +234,7 @@ func main() {
 ```go
 func (s Set[T]) Delete(items ...T)
 ```
+
 <b>Example:</b>

 ```go
@@ -249,9 +254,8 @@ func main() {
 }
 ```

-
-
 ### <span id="Contain">Contain</span>
+
 <p>Check if item is in set or not</p>

 <b>Signature:</b>
@@ -259,6 +263,7 @@ func main() {
 ```go
 func (s Set[T]) Contain(item T) bool
 ```
+
 <b>Example:</b>

 ```go
@@ -278,10 +283,8 @@ func main() {
 }
 ```

-
-
-
 ### <span id="ContainAll">ContainAll</span>
+
 <p>Checks if set contains another set</p>

 <b>Signature:</b>
@@ -289,6 +292,7 @@ func main() {
 ```go
 func (s Set[T]) ContainAll(other Set[T]) bool
 ```
+
 <b>Example:</b>

 ```go
@@ -301,17 +305,16 @@ import (

 func main() {
    set1 := set.NewSet(1, 2, 3)
-	set2 := set.NewSet(1, 2)
-	set3 := set.NewSet(1, 2, 3, 4)
+    set2 := set.NewSet(1, 2)
+    set3 := set.NewSet(1, 2, 3, 4)

    fmt.Println(set1.ContainAll(set2)) //true
    fmt.Println(set1.ContainAll(set3)) //false
 }
 ```

-
-
 ### <span id="Size">Size</span>
+
 <p>Get the number of elements in set</p>

 <b>Signature:</b>
@@ -319,6 +322,7 @@ func main() {
 ```go
 func (s Set[T]) Size() int
 ```
+
 <b>Example:</b>

 ```go
@@ -336,9 +340,8 @@ func main() {
 }
 ```

-
-
 ### <span id="Clone">Clone</span>
+
 <p>Make a copy of set</p>

 <b>Signature:</b>
@@ -346,6 +349,7 @@ func main() {
 ```go
 func (s Set[T]) Clone() Set[T]
 ```
+
 <b>Example:</b>

 ```go
@@ -365,10 +369,8 @@ func main() {
 }
 ```

-
-
-
 ### <span id="Equal">Equal</span>
+
 <p>Check if two sets has same elements or not</p>

 <b>Signature:</b>
@@ -376,6 +378,7 @@ func main() {
 ```go
 func (s Set[T]) Equal(other Set[T]) bool
 ```
+
 <b>Example:</b>

 ```go
@@ -396,9 +399,8 @@ func main() {
 }
 ```

-
-
 ### <span id="Iterate">Iterate</span>
+
 <p>Call function by every element of set</p>

 <b>Signature:</b>
@@ -406,6 +408,7 @@ func main() {
 ```go
 func (s Set[T]) Iterate(fn func(item T))
 ```
+
 <b>Example:</b>

 ```go
@@ -427,9 +430,45 @@ func main() {
 }
 ```

+### <span id="EachWithBreak">EachWithBreak</span>

+<p>Iterates over elements of a set and invokes function for each element, when iteratee return false, will break the for each loop.</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) EachWithBreak(iteratee func(item T) bool)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    s := set.NewSet(1, 2, 3, 4, 5)
+
+    var sum int
+
+    s.EachWithBreak(func(n int) bool {
+        if n > 3 {
+            return false
+        }
+        sum += n
+        return true
+    })
+
+    fmt.Println(sum) //6
+}
+```

 ### <span id="IsEmpty">IsEmpty</span>
+
 <p>Check if the set is empty or not</p>

 <b>Signature:</b>
@@ -437,6 +476,7 @@ func main() {
 ```go
 func (s Set[T]) IsEmpty() bool
 ```
+
 <b>Example:</b>

 ```go
@@ -456,9 +496,8 @@ func main() {
 }
 ```

-
-
 ### <span id="Union">Union</span>
+
 <p>Create a new set contain all element of set s and other</p>

 <b>Signature:</b>
@@ -466,6 +505,7 @@ func main() {
 ```go
 func (s Set[T]) Union(other Set[T]) Set[T]
 ```
+
 <b>Example:</b>

 ```go
@@ -485,9 +525,8 @@ func main() {
 }
 ```

-
-
 ### <span id="Intersection">Intersection</span>
+
 <p>Create a new set whose element both be contained in set s and other</p>

 <b>Signature:</b>
@@ -495,6 +534,7 @@ func main() {
 ```go
 func (s Set[T]) Intersection(other Set[T]) Set[T]
 ```
+
 <b>Example:</b>

 ```go
@@ -514,11 +554,8 @@ func main() {
 }
 ```

-
-
-
-
 ### <span id="SymmetricDifference">SymmetricDifference</span>
+
 <p>Create a new set whose element is in set1 or set2, but not in both set1 and set2</p>

 <b>Signature:</b>
@@ -526,6 +563,7 @@ func main() {
 ```go
 func (s Set[T]) SymmetricDifference(other Set[T]) Set[T]
 ```
+
 <b>Example:</b>

 ```go
@@ -538,18 +576,15 @@ import (

 func main() {
    set1 := set.NewSet(1, 2, 3)
-	set2 := set.NewSet(2, 3, 4, 5)
-	set3 := set1.SymmetricDifference(set2)
+    set2 := set.NewSet(2, 3, 4, 5)
+    set3 := set1.SymmetricDifference(set2)

    fmt.Println(set3.Values()) //1,4,5
 }
 ```

-
-
-
-
 ### <span id="Minus">Minus</span>
+
 <p>Create an set of whose element in origin set but not in compared set</p>

 <b>Signature:</b>
@@ -557,6 +592,7 @@ func main() {
 ```go
 func (s Set[T]) Minus(comparedSet Set[T]) Set[T]
 ```
+
 <b>Example:</b>

 ```go
@@ -569,8 +605,8 @@ import (

 func main() {
    set1 := set.NewSet(1, 2, 3)
-	set2 := set.NewSet(2, 3, 4, 5)
-	set3 := set.NewSet(2, 3)
+    set2 := set.NewSet(2, 3, 4, 5)
+    set3 := set.NewSet(2, 3)

    res1 := set1.Minus(set2)
    fmt.Println(res1.Values()) //1
@@ -580,5 +616,35 @@ func main() {
 }
 ```

+### <span id="Pop">Pop</span>

+<p>Delete the top element of set then return it, if set is empty, return nil-value of T and false.</p>

+<b>Signature:</b>
+
+```go
+func (s Set[T]) Pop() (v T, ok bool)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    s := set.NewSet[int]()
+    s.Add(1)
+    s.Add(2)
+    s.Add(3)
+
+    val, ok = s.Pop()
+
+    fmt.Println(val) // 3
+    fmt.Println(ok) // true
+}
+```
--- a/docs/datastructure/set_zh-CN.md
+++ b/docs/datastructure/set_zh-CN.md
@@ -1,16 +1,17 @@
 # Set
-Set集合数据结构，类似列表。Set中元素不重复。
+
+Set 集合数据结构，类似列表。Set 中元素不重复。

 <div STYLE="page-break-after: always;"></div>

 ## 源码

- [https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go](https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go)
-
+-   [https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go](https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go)

 <div STYLE="page-break-after: always;"></div>

 ## 用法
+
 ```go
 import (
    set "github.com/duke-git/lancet/v2/datastructure/set"
@@ -21,32 +22,31 @@ import (

 ## 目录

- [NewSet](#NewSet)
- [NewSetFromSlice](#NewSetFromSlice)
- [Values](#Values)
- [Add](#Add)
- [AddIfNotExist](#AddIfNotExist)
- [AddIfNotExistBy](#AddIfNotExistBy)
- [Delete](#Delete)
- [Contain](#Contain)
- [ContainAll](#ContainAll)
- [Clone](#Clone)
- [Size](#Size)
- [Equal](#Equal)
- [Iterate](#Iterate)
- [IsEmpty](#IsEmpty)
- [Union](#Union)
- [Intersection](#Intersection)
- [SymmetricDifference](#SymmetricDifference)
- [Minus](#Minus)
-
-
+-   [NewSet](#NewSet)
+-   [NewSetFromSlice](#NewSetFromSlice)
+-   [Values](#Values)
+-   [Add](#Add)
+-   [AddIfNotExist](#AddIfNotExist)
+-   [AddIfNotExistBy](#AddIfNotExistBy)
+-   [Delete](#Delete)
+-   [Contain](#Contain)
+-   [ContainAll](#ContainAll)
+-   [Clone](#Clone)
+-   [Size](#Size)
+-   [Equal](#Equal)
+-   [Iterate](#Iterate)
+-   [IsEmpty](#IsEmpty)
+-   [Union](#Union)
+-   [Intersection](#Intersection)
+-   [SymmetricDifference](#SymmetricDifference)
+-   [Minus](#Minus)

 <div STYLE="page-break-after: always;"></div>

 ## 文档

 ### <span id="NewSet">NewSet</span>
+
 <p>返回Set结构体对象</p>

 <b>函数签名:</b>
@@ -55,6 +55,7 @@ import (
 type Set[T comparable] map[T]bool
 func NewSet[T comparable](items ...T) Set[T]
 ```
+
 <b>示例:</b>

 ```go
@@ -71,9 +72,8 @@ func main() {
 }
 ```

-
-
 ### <span id="NewSetFromSlice">NewSetFromSlice</span>
+
 <p>基于切片创建集合</p>

 <b>函数签名:</b>
@@ -81,6 +81,7 @@ func main() {
 ```go
 func NewSetFromSlice[T comparable](items []T) Set[T]
 ```
+
 <b>示例:</b>

 ```go
@@ -97,9 +98,8 @@ func main() {
 }
 ```

-
-
 ### <span id="Values">Values</span>
+
 <p>获取集合中所有元素的切片</p>

 <b>函数签名:</b>
@@ -107,6 +107,7 @@ func main() {
 ```go
 func (s Set[T]) Values() []T
 ```
+
 <b>示例:</b>

 ```go
@@ -123,10 +124,8 @@ func main() {
 }
 ```

-
-
-
 ### <span id="Add">Add</span>
+
 <p>向集合中添加元素</p>

 <b>函数签名:</b>
@@ -134,6 +133,7 @@ func main() {
 ```go
 func (s Set[T]) Add(items ...T)
 ```
+
 <b>示例:</b>

 ```go
@@ -152,8 +152,8 @@ func main() {
 }
 ```

-
 ### <span id="AddIfNotExist">AddIfNotExist</span>
+
 <p>如果集合中不存在元素，则添加该元素返回true, 如果集合中存在元素, 不做任何操作，返回false</p>

 <b>函数签名:</b>
@@ -161,6 +161,7 @@ func main() {
 ```go
 func (s Set[T]) AddIfNotExist(item T) bool
 ```
+
 <b>示例:</b>

 ```go
@@ -176,7 +177,7 @@ func main() {
    st.Add(1, 2, 3)

    r1 := st.AddIfNotExist(1)
-	r2 := st.AddIfNotExist(4)
+    r2 := st.AddIfNotExist(4)

    fmt.Println(r1) // false
    fmt.Println(r2) // true
@@ -184,8 +185,8 @@ func main() {
 }
 ```

-
 ### <span id="AddIfNotExistBy">AddIfNotExistBy</span>
+
 <p>根据checker函数判断元素是否在集合中，如果集合中不存在元素且checker返回true，则添加该元素返回true, 否则不做任何操作，返回false</p>

 <b>函数签名:</b>
@@ -193,6 +194,7 @@ func main() {
 ```go
 func (s Set[T]) AddIfNotExistBy(item T, checker func(element T) bool) bool
 ```
+
 <b>示例:</b>

 ```go
@@ -207,24 +209,23 @@ func main() {
    st := set.NewSet[int]()
    st.Add(1, 2)

-	ok := st.AddIfNotExistBy(3, func(val int) bool {
-		return val%2 != 0
-	})
+    ok := st.AddIfNotExistBy(3, func(val int) bool {
+        return val%2 != 0
+    })
    fmt.Println(ok) // true


-	notOk := st.AddIfNotExistBy(4, func(val int) bool {
-		return val%2 != 0
-	})
+    notOk := st.AddIfNotExistBy(4, func(val int) bool {
+        return val%2 != 0
+    })
    fmt.Println(notOk) // false
-    
+
    fmt.Println(st.Values()) // 1, 2, 3
 }
 ```

-
-
 ### <span id="Delete">Delete</span>
+
 <p>删除集合中元素</p>

 <b>函数签名:</b>
@@ -232,6 +233,7 @@ func main() {
 ```go
 func (s Set[T]) Delete(items ...T)
 ```
+
 <b>示例:</b>

 ```go
@@ -251,9 +253,8 @@ func main() {
 }
 ```

-
-
 ### <span id="Contain">Contain</span>
+
 <p>判断集合是否包含某个值</p>

 <b>函数签名:</b>
@@ -261,6 +262,7 @@ func main() {
 ```go
 func (s Set[T]) Contain(item T) bool
 ```
+
 <b>示例:</b>

 ```go
@@ -280,10 +282,8 @@ func main() {
 }
 ```

-
-
-
 ### <span id="ContainAll">ContainAll</span>
+
 <p>判断集合是否包含另一个集合</p>

 <b>函数签名:</b>
@@ -291,6 +291,7 @@ func main() {
 ```go
 func (s Set[T]) ContainAll(other Set[T]) bool
 ```
+
 <b>示例:</b>

 ```go
@@ -303,17 +304,16 @@ import (

 func main() {
    set1 := set.NewSet(1, 2, 3)
-	set2 := set.NewSet(1, 2)
-	set3 := set.NewSet(1, 2, 3, 4)
+    set2 := set.NewSet(1, 2)
+    set3 := set.NewSet(1, 2, 3, 4)

    fmt.Println(set1.ContainAll(set2)) //true
    fmt.Println(set1.ContainAll(set3)) //false
 }
 ```

-
-
 ### <span id="Size">Size</span>
+
 <p>获取集合中元素的个数</p>

 <b>函数签名:</b>
@@ -321,6 +321,7 @@ func main() {
 ```go
 func (s Set[T]) Size() int
 ```
+
 <b>示例:</b>

 ```go
@@ -338,9 +339,8 @@ func main() {
 }
 ```

-
-
 ### <span id="Clone">Clone</span>
+
 <p>克隆一个集合</p>

 <b>函数签名:</b>
@@ -348,6 +348,7 @@ func main() {
 ```go
 func (s Set[T]) Clone() Set[T]
 ```
+
 <b>示例:</b>

 ```go
@@ -367,10 +368,8 @@ func main() {
 }
 ```

-
-
-
 ### <span id="Equal">Equal</span>
+
 <p>比较两个集合是否相等，包含相同元素为相等</p>

 <b>函数签名:</b>
@@ -378,6 +377,7 @@ func main() {
 ```go
 func (s Set[T]) Equal(other Set[T]) bool
 ```
+
 <b>示例:</b>

 ```go
@@ -398,9 +398,8 @@ func main() {
 }
 ```

-
-
 ### <span id="Iterate">Iterate</span>
+
 <p>迭代结合，在每个元素上调用函数</p>

 <b>函数签名:</b>
@@ -408,6 +407,7 @@ func main() {
 ```go
 func (s Set[T]) Iterate(fn func(item T))
 ```
+
 <b>示例:</b>

 ```go
@@ -429,9 +429,45 @@ func main() {
 }
 ```

+### <span id="EachWithBreak">EachWithBreak</span>

+<p>遍历集合的元素并为每个元素调用iteratee函数，当iteratee函数返回false时，终止遍历。</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) EachWithBreak(iteratee func(item T) bool)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    s := set.NewSet(1, 2, 3, 4, 5)
+
+    var sum int
+
+    s.EachWithBreak(func(n int) bool {
+        if n > 3 {
+            return false
+        }
+        sum += n
+        return true
+    })
+
+    fmt.Println(sum) //6
+}
+```

 ### <span id="IsEmpty">IsEmpty</span>
+
 <p>判断集合是否为空</p>

 <b>函数签名:</b>
@@ -439,6 +475,7 @@ func main() {
 ```go
 func (s Set[T]) IsEmpty() bool
 ```
+
 <b>示例:</b>

 ```go
@@ -458,9 +495,8 @@ func main() {
 }
 ```

-
-
 ### <span id="Union">Union</span>
+
 <p>求两个集合的并集</p>

 <b>函数签名:</b>
@@ -468,6 +504,7 @@ func main() {
 ```go
 func (s Set[T]) Union(other Set[T]) Set[T]
 ```
+
 <b>示例:</b>

 ```go
@@ -487,9 +524,8 @@ func main() {
 }
 ```

-
-
 ### <span id="Intersection">Intersection</span>
+
 <p>求两个集合的交集</p>

 <b>函数签名:</b>
@@ -497,6 +533,7 @@ func main() {
 ```go
 func (s Set[T]) Intersection(other Set[T]) Set[T]
 ```
+
 <b>示例:</b>

 ```go
@@ -516,8 +553,8 @@ func main() {
 }
 ```

-
 ### <span id="SymmetricDifference">SymmetricDifference</span>
+
 <p>返回一个集合，其中元素在第一个集合或第二个集合中，且不同时存在于两个集合中</p>

 <b>函数签名:</b>
@@ -525,6 +562,7 @@ func main() {
 ```go
 func (s Set[T]) SymmetricDifference(other Set[T]) Set[T]
 ```
+
 <b>示例:</b>

 ```go
@@ -537,18 +575,15 @@ import (

 func main() {
    set1 := set.NewSet(1, 2, 3)
-	set2 := set.NewSet(2, 3, 4, 5)
-	set3 := set1.SymmetricDifference(set2)
+    set2 := set.NewSet(2, 3, 4, 5)
+    set3 := set1.SymmetricDifference(set2)

    fmt.Println(set3.Values()) //1,4,5
 }
 ```

-
-
-
-
 ### <span id="Minus">Minus</span>
+
 <p>创建一个集合，其元素在原始集中但不在比较集中</p>

 <b>函数签名:</b>
@@ -556,6 +591,7 @@ func main() {
 ```go
 func (s Set[T]) Minus(comparedSet Set[T]) Set[T]
 ```
+
 <b>示例:</b>

 ```go
@@ -568,8 +604,8 @@ import (

 func main() {
    set1 := set.NewSet(1, 2, 3)
-	set2 := set.NewSet(2, 3, 4, 5)
-	set3 := set.NewSet(2, 3)
+    set2 := set.NewSet(2, 3, 4, 5)
+    set3 := set.NewSet(2, 3)

    res1 := set1.Minus(set2)
    fmt.Println(res1.Values()) //1
@@ -579,5 +615,35 @@ func main() {
 }
 ```

+### <span id="Pop">Pop</span>

+<p>删除并返回集合中的顶部元素</p>

+<b>函数签名:</b>
+
+```go
+func (s Set[T]) Pop() (v T, ok bool)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    s := set.NewSet[int]()
+    s.Add(1)
+    s.Add(2)
+    s.Add(3)
+
+    val, ok = s.Pop()
+
+    fmt.Println(val) // 3
+    fmt.Println(ok) // true
+}
+```
--- a/docs/slice.md
+++ b/docs/slice.md
@@ -173,28 +173,28 @@ import (

 func main() {
    type foo struct {
-		A string
-		B int
-	}
+        A string
+        B int
+    }

-	array1 := []foo{{A: "1", B: 1}, {A: "2", B: 2}}
-	result1 := slice.ContainBy(array1, func(f foo) bool { return f.A == "1" && f.B == 1 })
-	result2 := slice.ContainBy(array1, func(f foo) bool { return f.A == "2" && f.B == 1 })
+    array1 := []foo{{A: "1", B: 1}, {A: "2", B: 2}}
+    result1 := slice.ContainBy(array1, func(f foo) bool { return f.A == "1" && f.B == 1 })
+    result2 := slice.ContainBy(array1, func(f foo) bool { return f.A == "2" && f.B == 1 })

-	array2 := []string{"a", "b", "c"}
-	result3 := slice.ContainBy(array2, func(t string) bool { return t == "a" })
-	result4 := slice.ContainBy(array2, func(t string) bool { return t == "d" })
+    array2 := []string{"a", "b", "c"}
+    result3 := slice.ContainBy(array2, func(t string) bool { return t == "a" })
+    result4 := slice.ContainBy(array2, func(t string) bool { return t == "d" })

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)

-	// Output:
-	// true
-	// false
-	// true
-	// false
+    // Output:
+    // true
+    // false
+    // true
+    // false
 }
 ```

@@ -561,20 +561,20 @@ import (

 func main() {
    result1 := slice.Drop([]string{"a", "b", "c"}, 0)
-	result2 := slice.Drop([]string{"a", "b", "c"}, 1)
-	result3 := slice.Drop([]string{"a", "b", "c"}, -1)
-	result4 := slice.Drop([]string{"a", "b", "c"}, 4)
+    result2 := slice.Drop([]string{"a", "b", "c"}, 1)
+    result3 := slice.Drop([]string{"a", "b", "c"}, -1)
+    result4 := slice.Drop([]string{"a", "b", "c"}, 4)

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)

-	// Output:
-	// [a b c]
-	// [b c]
-	// [a b c]
-	// []
+    // Output:
+    // [a b c]
+    // [b c]
+    // [a b c]
+    // []
 }
 ```

@@ -598,20 +598,20 @@ import (

 func main() {
    result1 := slice.DropRight([]string{"a", "b", "c"}, 0)
-	result2 := slice.DropRight([]string{"a", "b", "c"}, 1)
-	result3 := slice.DropRight([]string{"a", "b", "c"}, -1)
-	result4 := slice.DropRight([]string{"a", "b", "c"}, 4)
+    result2 := slice.DropRight([]string{"a", "b", "c"}, 1)
+    result3 := slice.DropRight([]string{"a", "b", "c"}, -1)
+    result4 := slice.DropRight([]string{"a", "b", "c"}, 4)

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)

-	// Output:
-	// [a b c]
-	// [a b]
-	// [a b c]
-	// []
+    // Output:
+    // [a b c]
+    // [a b]
+    // [a b c]
+    // []
 }
 ```

@@ -635,23 +635,23 @@ import (

 func main() {
    result1 := slice.DropWhile(numbers, func(n int) bool {
-		return n != 2
-	})
-	result2 := slice.DropWhile(numbers, func(n int) bool {
-		return true
-	})
-	result3 := slice.DropWhile(numbers, func(n int) bool {
-		return n == 0
-	})
+        return n != 2
+    })
+    result2 := slice.DropWhile(numbers, func(n int) bool {
+        return true
+    })
+    result3 := slice.DropWhile(numbers, func(n int) bool {
+        return n == 0
+    })

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)

-	// Output:
-	// [2 3 4 5]
-	// []
-	// [1 2 3 4 5]
+    // Output:
+    // [2 3 4 5]
+    // []
+    // [1 2 3 4 5]
 }
 ```

@@ -676,24 +676,24 @@ import (
 func main() {
    numbers := []int{1, 2, 3, 4, 5}

-	result1 := slice.DropRightWhile(numbers, func(n int) bool {
-		return n != 2
-	})
-	result2 := slice.DropRightWhile(numbers, func(n int) bool {
-		return true
-	})
-	result3 := slice.DropRightWhile(numbers, func(n int) bool {
-		return n == 0
-	})
+    result1 := slice.DropRightWhile(numbers, func(n int) bool {
+        return n != 2
+    })
+    result2 := slice.DropRightWhile(numbers, func(n int) bool {
+        return true
+    })
+    result3 := slice.DropRightWhile(numbers, func(n int) bool {
+        return n == 0
+    })

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)

-	// Output:
-	// [1 2]
-	// []
-	// [1 2 3 4 5]
+    // Output:
+    // [1 2]
+    // []
+    // [1 2 3 4 5]
 }
 ```

@@ -1002,10 +1002,9 @@ func main() {
 }
 ```

-
 ### <span id="ForEachWithBreak">ForEachWithBreak</span>

-<p>Iterates over elements of slice and invokes function for each element, when iteratee return true, will break the for each loop.</p>
+<p>Iterates over elements of slice and invokes function for each element, when iteratee return false, will break the for each loop.</p>

 <b>Signature:</b>

@@ -1024,20 +1023,20 @@ import (
 func main() {
    numbers := []int{1, 2, 3, 4, 5}

-	var sum int
+    var sum int

-	slice.ForEachWithBreak(numbers, func(_, n int) bool {
-		if n > 3 {
-			return false
-		}
-		sum += n
-		return true
-	})
+    slice.ForEachWithBreak(numbers, func(_, n int) bool {
+        if n > 3 {
+            return false
+        }
+        sum += n
+        return true
+    })

-	fmt.Println(sum)
+    fmt.Println(sum)

-	// Output:
-	// 6
+    // Output:
+    // 6
 }
 ```

@@ -1361,19 +1360,19 @@ import (
 func main() {
    nums := []int{1, 2, 3, 4, 5}

-	getEvenNumStr := func(i, num int) (string, bool) {
-		if num%2 == 0 {
-			return strconv.FormatInt(int64(num), 10), true
-		}
-		return "", false
-	}
+    getEvenNumStr := func(i, num int) (string, bool) {
+        if num%2 == 0 {
+            return strconv.FormatInt(int64(num), 10), true
+        }
+        return "", false
+    }

-	result := slice.FilterMap(nums, getEvenNumStr)
+    result := slice.FilterMap(nums, getEvenNumStr)

-	fmt.Printf("%#v", result)
+    fmt.Printf("%#v", result)

-	// Output:
-	// []string{"2", "4"}
+    // Output:
+    // []string{"2", "4"}
 }
 ```

@@ -1398,15 +1397,15 @@ import (
 func main() {
    nums := []int{1, 2, 3, 4}

-	result := slice.FlatMap(nums, func(i int, num int) []string {
-		s := "hi-" + strconv.FormatInt(int64(num), 10)
-		return []string{s}
-	})
+    result := slice.FlatMap(nums, func(i int, num int) []string {
+        s := "hi-" + strconv.FormatInt(int64(num), 10)
+        return []string{s}
+    })

-	fmt.Printf("%#v", result)
+    fmt.Printf("%#v", result)

-	// Output:
-	// []string{"hi-1", "hi-2", "hi-3", "hi-4"}
+    // Output:
+    // []string{"hi-1", "hi-2", "hi-3", "hi-4"}
 }
 ```

@@ -1652,17 +1651,17 @@ import (

 func main() {
    result1 := slice.IsAscending([]int{1, 2, 3, 4, 5})
-	result2 := slice.IsAscending([]int{5, 4, 3, 2, 1})
-	result3 := slice.IsAscending([]int{2, 1, 3, 4, 5})
+    result2 := slice.IsAscending([]int{5, 4, 3, 2, 1})
+    result3 := slice.IsAscending([]int{2, 1, 3, 4, 5})

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)

-	// Output:
-	// true
-	// false
-	// false
+    // Output:
+    // true
+    // false
+    // false
 }
 ```

@@ -1686,17 +1685,17 @@ import (

 func main() {
    result1 := slice.IsDescending([]int{5, 4, 3, 2, 1})
-	result2 := slice.IsDescending([]int{1, 2, 3, 4, 5})
-	result3 := slice.IsDescending([]int{2, 1, 3, 4, 5})
+    result2 := slice.IsDescending([]int{1, 2, 3, 4, 5})
+    result3 := slice.IsDescending([]int{2, 1, 3, 4, 5})

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)

-	// Output:
-	// true
-	// false
-	// false
+    // Output:
+    // true
+    // false
+    // false
 }
 ```

@@ -1720,17 +1719,17 @@ import (

 func main() {
    result1 := slice.IsSorted([]int{5, 4, 3, 2, 1})
-	result2 := slice.IsSorted([]int{1, 2, 3, 4, 5})
-	result3 := slice.IsSorted([]int{2, 1, 3, 4, 5})
+    result2 := slice.IsSorted([]int{1, 2, 3, 4, 5})
+    result3 := slice.IsSorted([]int{2, 1, 3, 4, 5})

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)

-	// Output:
-	// true
-	// true
-	// false
+    // Output:
+    // true
+    // true
+    // false
 }
 ```

@@ -1754,23 +1753,23 @@ import (

 func main() {
    result1 := slice.IsSortedByKey([]string{"a", "ab", "abc"}, func(s string) int {
-		return len(s)
-	})
-	result2 := slice.IsSortedByKey([]string{"abc", "ab", "a"}, func(s string) int {
-		return len(s)
-	})
-	result3 := slice.IsSortedByKey([]string{"abc", "a", "ab"}, func(s string) int {
-		return len(s)
-	})
+        return len(s)
+    })
+    result2 := slice.IsSortedByKey([]string{"abc", "ab", "a"}, func(s string) int {
+        return len(s)
+    })
+    result3 := slice.IsSortedByKey([]string{"abc", "a", "ab"}, func(s string) int {
+        return len(s)
+    })

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)

-	// Output:
-	// true
-	// true
-	// false
+    // Output:
+    // true
+    // true
+    // false
 }
 ```

--- a/docs/slice_zh-CN.md
+++ b/docs/slice_zh-CN.md
@@ -173,28 +173,28 @@ import (

 func main() {
    type foo struct {
-		A string
-		B int
-	}
+        A string
+        B int
+    }

-	array1 := []foo{{A: "1", B: 1}, {A: "2", B: 2}}
-	result1 := slice.ContainBy(array1, func(f foo) bool { return f.A == "1" && f.B == 1 })
-	result2 := slice.ContainBy(array1, func(f foo) bool { return f.A == "2" && f.B == 1 })
+    array1 := []foo{{A: "1", B: 1}, {A: "2", B: 2}}
+    result1 := slice.ContainBy(array1, func(f foo) bool { return f.A == "1" && f.B == 1 })
+    result2 := slice.ContainBy(array1, func(f foo) bool { return f.A == "2" && f.B == 1 })

-	array2 := []string{"a", "b", "c"}
-	result3 := slice.ContainBy(array2, func(t string) bool { return t == "a" })
-	result4 := slice.ContainBy(array2, func(t string) bool { return t == "d" })
+    array2 := []string{"a", "b", "c"}
+    result3 := slice.ContainBy(array2, func(t string) bool { return t == "a" })
+    result4 := slice.ContainBy(array2, func(t string) bool { return t == "d" })

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)

-	// Output:
-	// true
-	// false
-	// true
-	// false
+    // Output:
+    // true
+    // false
+    // true
+    // false
 }
 ```

@@ -542,7 +542,6 @@ func main() {
 }
 ```

-
 ### <span id="Drop">Drop</span>

 <p>从切片的头部删除n个元素。</p>
@@ -563,20 +562,20 @@ import (

 func main() {
    result1 := slice.Drop([]string{"a", "b", "c"}, 0)
-	result2 := slice.Drop([]string{"a", "b", "c"}, 1)
-	result3 := slice.Drop([]string{"a", "b", "c"}, -1)
-	result4 := slice.Drop([]string{"a", "b", "c"}, 4)
+    result2 := slice.Drop([]string{"a", "b", "c"}, 1)
+    result3 := slice.Drop([]string{"a", "b", "c"}, -1)
+    result4 := slice.Drop([]string{"a", "b", "c"}, 4)

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)

-	// Output:
-	// [a b c]
-	// [b c]
-	// [a b c]
-	// []
+    // Output:
+    // [a b c]
+    // [b c]
+    // [a b c]
+    // []
 }
 ```

@@ -600,20 +599,20 @@ import (

 func main() {
    result1 := slice.DropRight([]string{"a", "b", "c"}, 0)
-	result2 := slice.DropRight([]string{"a", "b", "c"}, 1)
-	result3 := slice.DropRight([]string{"a", "b", "c"}, -1)
-	result4 := slice.DropRight([]string{"a", "b", "c"}, 4)
+    result2 := slice.DropRight([]string{"a", "b", "c"}, 1)
+    result3 := slice.DropRight([]string{"a", "b", "c"}, -1)
+    result4 := slice.DropRight([]string{"a", "b", "c"}, 4)

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)

-	// Output:
-	// [a b c]
-	// [a b]
-	// [a b c]
-	// []
+    // Output:
+    // [a b c]
+    // [a b]
+    // [a b c]
+    // []
 }
 ```

@@ -637,23 +636,23 @@ import (

 func main() {
    result1 := slice.DropWhile(numbers, func(n int) bool {
-		return n != 2
-	})
-	result2 := slice.DropWhile(numbers, func(n int) bool {
-		return true
-	})
-	result3 := slice.DropWhile(numbers, func(n int) bool {
-		return n == 0
-	})
+        return n != 2
+    })
+    result2 := slice.DropWhile(numbers, func(n int) bool {
+        return true
+    })
+    result3 := slice.DropWhile(numbers, func(n int) bool {
+        return n == 0
+    })

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)

-	// Output:
-	// [2 3 4 5]
-	// []
-	// [1 2 3 4 5]
+    // Output:
+    // [2 3 4 5]
+    // []
+    // [1 2 3 4 5]
 }
 ```

@@ -678,24 +677,24 @@ import (
 func main() {
    numbers := []int{1, 2, 3, 4, 5}

-	result1 := slice.DropRightWhile(numbers, func(n int) bool {
-		return n != 2
-	})
-	result2 := slice.DropRightWhile(numbers, func(n int) bool {
-		return true
-	})
-	result3 := slice.DropRightWhile(numbers, func(n int) bool {
-		return n == 0
-	})
+    result1 := slice.DropRightWhile(numbers, func(n int) bool {
+        return n != 2
+    })
+    result2 := slice.DropRightWhile(numbers, func(n int) bool {
+        return true
+    })
+    result3 := slice.DropRightWhile(numbers, func(n int) bool {
+        return n == 0
+    })

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)

-	// Output:
-	// [1 2]
-	// []
-	// [1 2 3 4 5]
+    // Output:
+    // [1 2]
+    // []
+    // [1 2 3 4 5]
 }
 ```

@@ -1004,7 +1003,6 @@ func main() {
 }
 ```

-
 ### <span id="ForEachWithBreak">ForEachWithBreak</span>

 <p>遍历切片的元素并为每个元素调用iteratee函数，当iteratee函数返回false时，终止遍历。</p>
@@ -1026,24 +1024,23 @@ import (
 func main() {
    numbers := []int{1, 2, 3, 4, 5}

-	var sum int
+    var sum int

-	slice.ForEachWithBreak(numbers, func(_, n int) bool {
-		if n > 3 {
-			return false
-		}
-		sum += n
-		return true
-	})
+    slice.ForEachWithBreak(numbers, func(_, n int) bool {
+        if n > 3 {
+            return false
+        }
+        sum += n
+        return true
+    })

-	fmt.Println(sum)
+    fmt.Println(sum)

-	// Output:
-	// 6
+    // Output:
+    // 6
 }
 ```

-
 ### <span id="GroupBy">GroupBy</span>

 <p>迭代切片的元素，每个元素将按条件分组，返回两个切片</p>
@@ -1364,19 +1361,19 @@ import (
 func main() {
    nums := []int{1, 2, 3, 4, 5}

-	getEvenNumStr := func(i, num int) (string, bool) {
-		if num%2 == 0 {
-			return strconv.FormatInt(int64(num), 10), true
-		}
-		return "", false
-	}
+    getEvenNumStr := func(i, num int) (string, bool) {
+        if num%2 == 0 {
+            return strconv.FormatInt(int64(num), 10), true
+        }
+        return "", false
+    }

-	result := slice.FilterMap(nums, getEvenNumStr)
+    result := slice.FilterMap(nums, getEvenNumStr)

-	fmt.Printf("%#v", result)
+    fmt.Printf("%#v", result)

-	// Output:
-	// []string{"2", "4"}
+    // Output:
+    // []string{"2", "4"}
 }
 ```

@@ -1401,15 +1398,15 @@ import (
 func main() {
    nums := []int{1, 2, 3, 4}

-	result := slice.FlatMap(nums, func(i int, num int) []string {
-		s := "hi-" + strconv.FormatInt(int64(num), 10)
-		return []string{s}
-	})
+    result := slice.FlatMap(nums, func(i int, num int) []string {
+        s := "hi-" + strconv.FormatInt(int64(num), 10)
+        return []string{s}
+    })

-	fmt.Printf("%#v", result)
+    fmt.Printf("%#v", result)

-	// Output:
-	// []string{"hi-1", "hi-2", "hi-3", "hi-4"}
+    // Output:
+    // []string{"hi-1", "hi-2", "hi-3", "hi-4"}
 }
 ```

@@ -1628,8 +1625,8 @@ func main() {
    nums := []int{1, 2, 3, 4, 5}
    result := slice.Shuffle(nums)

-    fmt.Println(res) 
-    
+    fmt.Println(res)
+
    // Output:
    // [3 1 5 4 2] (random order)
 }
@@ -1655,17 +1652,17 @@ import (

 func main() {
    result1 := slice.IsAscending([]int{1, 2, 3, 4, 5})
-	result2 := slice.IsAscending([]int{5, 4, 3, 2, 1})
-	result3 := slice.IsAscending([]int{2, 1, 3, 4, 5})
+    result2 := slice.IsAscending([]int{5, 4, 3, 2, 1})
+    result3 := slice.IsAscending([]int{2, 1, 3, 4, 5})

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)

-	// Output:
-	// true
-	// false
-	// false
+    // Output:
+    // true
+    // false
+    // false
 }
 ```

@@ -1689,17 +1686,17 @@ import (

 func main() {
    result1 := slice.IsDescending([]int{5, 4, 3, 2, 1})
-	result2 := slice.IsDescending([]int{1, 2, 3, 4, 5})
-	result3 := slice.IsDescending([]int{2, 1, 3, 4, 5})
+    result2 := slice.IsDescending([]int{1, 2, 3, 4, 5})
+    result3 := slice.IsDescending([]int{2, 1, 3, 4, 5})

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)

-	// Output:
-	// true
-	// false
-	// false
+    // Output:
+    // true
+    // false
+    // false
 }
 ```

@@ -1723,17 +1720,17 @@ import (

 func main() {
    result1 := slice.IsSorted([]int{5, 4, 3, 2, 1})
-	result2 := slice.IsSorted([]int{1, 2, 3, 4, 5})
-	result3 := slice.IsSorted([]int{2, 1, 3, 4, 5})
+    result2 := slice.IsSorted([]int{1, 2, 3, 4, 5})
+    result3 := slice.IsSorted([]int{2, 1, 3, 4, 5})

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)

-	// Output:
-	// true
-	// true
-	// false
+    // Output:
+    // true
+    // true
+    // false
 }
 ```

@@ -1757,23 +1754,23 @@ import (

 func main() {
    result1 := slice.IsSortedByKey([]string{"a", "ab", "abc"}, func(s string) int {
-		return len(s)
-	})
-	result2 := slice.IsSortedByKey([]string{"abc", "ab", "a"}, func(s string) int {
-		return len(s)
-	})
-	result3 := slice.IsSortedByKey([]string{"abc", "a", "ab"}, func(s string) int {
-		return len(s)
-	})
+        return len(s)
+    })
+    result2 := slice.IsSortedByKey([]string{"abc", "ab", "a"}, func(s string) int {
+        return len(s)
+    })
+    result3 := slice.IsSortedByKey([]string{"abc", "a", "ab"}, func(s string) int {
+        return len(s)
+    })

-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)

-	// Output:
-	// true
-	// true
-	// false
+    // Output:
+    // true
+    // true
+    // false
 }
 ```

--- a/internal/assert.go
+++ b/internal/assert.go
@@ -79,16 +79,18 @@ func (a *Assert) LessOrEqual(expected, actual any) {
 }

 // IsNil check if value is nil
-func (a *Assert) IsNil(value any) {
-	if value != nil {
-		makeTestFailed(a.T, a.CaseName, nil, value)
+func (a *Assert) IsNil(v any) {
+	if v == nil || (reflect.ValueOf(v).Kind() == reflect.Ptr && reflect.ValueOf(v).IsNil()) {
+		return
 	}
+
+	makeTestFailed(a.T, a.CaseName, nil, v)
 }

 // IsNotNil check if value is not nil
-func (a *Assert) IsNotNil(value any) {
-	if value == nil {
-		makeTestFailed(a.T, a.CaseName, "not nil", value)
+func (a *Assert) IsNotNil(v any) {
+	if v == nil || (reflect.ValueOf(v).Kind() == reflect.Ptr && reflect.ValueOf(v).IsNil()) {
+		makeTestFailed(a.T, a.CaseName, "not nil", v)
 	}
 }

--- a/internal/error_join.go
+++ b/internal/error_join.go
@@ -0,0 +1,51 @@
+package internal
+
+// Note: this file is copyed from the go standart repo (https://github.com/golang/go/blob/master/src/errors/join.go).
+// just in order to adapt under go1.9
+// do not use it outside lancet lib.
+
+// Join returns an error that wraps the given errors.
+// Any nil error values are discarded.
+// Join returns nil if errs contains no non-nil values.
+// The error formats as the concatenation of the strings obtained
+// by calling the Error method of each element of errs, with a newline
+// between each string.
+func JoinError(errs ...error) error {
+	n := 0
+	for _, err := range errs {
+		if err != nil {
+			n++
+		}
+	}
+	if n == 0 {
+		return nil
+	}
+	e := &joinError{
+		errs: make([]error, 0, n),
+	}
+	for _, err := range errs {
+		if err != nil {
+			e.errs = append(e.errs, err)
+		}
+	}
+	return e
+}
+
+type joinError struct {
+	errs []error
+}
+
+func (e *joinError) Error() string {
+	var b []byte
+	for i, err := range e.errs {
+		if i > 0 {
+			b = append(b, '\n')
+		}
+		b = append(b, err.Error()...)
+	}
+	return string(b)
+}
+
+func (e *joinError) Unwrap() []error {
+	return e.errs
+}
--- a/slice/slice.go
+++ b/slice/slice.go
@@ -422,12 +422,11 @@ func ForEach[T any](slice []T, iteratee func(index int, item T)) {
 }

 // ForEachWithBreak iterates over elements of slice and invokes function for each element,
-// when iteratee return true, will break the for each loop.
+// when iteratee return false, will break the for each loop.
 func ForEachWithBreak[T any](slice []T, iteratee func(index int, item T) bool) {
-loop:
 	for i, v := range slice {
 		if !iteratee(i, v) {
-			break loop
+			break
 		}
 	}
 }
--- a/structs/struct.go
+++ b/structs/struct.go
@@ -1,3 +1,4 @@
+// Package structs provide several high level functions to manipulate struct, tag, and field.
 package structs

 import (
Author	SHA1	Message	Date
dudaodong	0aa41f337d	fix: test failed	2023-03-20 16:39:56 +08:00
dudaodong	48814a720a	fix: test failed in promise test	2023-03-20 16:26:21 +08:00
dudaodong	04b79b3dfe	release v2.1.17	2023-03-20 16:17:52 +08:00
dudaodong	302007ebdf	doc: update readme file for new feature	2023-03-20 16:12:58 +08:00
dudaodong	965e5fbcda	feat: add Pop for set	2023-03-20 11:10:35 +08:00
dudaodong	70d0adde42	feat: add EachWithBreak for set	2023-03-20 10:49:14 +08:00
dudaodong	0b80074bb7	refactor: remove unused code	2023-03-20 10:35:37 +08:00
dudaodong	90945a0399	Merge branch 'main' into v2	2023-03-18 19:35:48 +08:00
dudaodong	4ae7e59829	feat: add example for promise	2023-03-17 16:03:35 +08:00
dudaodong	8f0c60cade	test: add unit test for promise Race and Any function	2023-03-17 13:59:18 +08:00
dudaodong	3f6aef1432	fix: fix bug of IsNotNil function	2023-03-16 19:15:36 +08:00
dudaodong	a714e04470	test: add unit test for promise.All function	2023-03-16 19:11:30 +08:00
dudaodong	7456621153	fix: fix bug of IsNil function	2023-03-16 17:01:28 +08:00
dudaodong	73ac9825e9	test: add unit test for Promise	2023-03-16 16:55:32 +08:00
dudaodong	930bb9c839	feat: complete promise Any function	2023-03-16 15:59:06 +08:00
dudaodong	3d8f1be212	feat: add error_join.go to support join error under go1.19, for internal use.	2023-03-16 15:56:54 +08:00
dudaodong	13a4ed59fa	doc: update comment for concurrency package	2023-03-16 15:35:26 +08:00
dudaodong	c799d10ce9	feat: add promise All, Race, Any methods	2023-03-16 15:34:28 +08:00
dudaodong	5ab322ade2	feat: add async package, promise implemention	2023-03-16 14:49:07 +08:00
dudaodong	d0ffc61842	doc: fix doc error	2023-03-16 10:36:06 +08:00