release v2.1.0

docs: add doc for UniqueBy function
test: add fuzz test for Equal function
2026-02-05 05:12:26 +08:00 · 2022-06-22 16:10:54 +08:00 · 2022-06-22 16:08:37 +08:00 · 2022-06-21 14:17:33 +08:00 · 2022-06-17 15:18:04 +08:00 · 2022-06-16 18:03:50 +08:00
125 changed files with 21128 additions and 1433 deletions
--- a/.github/workflows/codecov.yml
+++ b/.github/workflows/codecov.yml
@@ -17,7 +17,7 @@ jobs:
          fetch-depth: 2
      - uses: actions/setup-go@v2
        with:
-          go-version: "1.16"
+          go-version: "1.18"
      - name: Run coverage
        run: go test -v ./... -coverprofile=coverage.txt -covermode=atomic
      - name: Upload coverage to Codecov
--- a/.gitignore
+++ b/.gitignore
@@ -6,4 +6,5 @@ fileutil/*.txt
 fileutil/*.zip
 fileutil/*.link
 fileutil/unzip/*
+slice/testdata/*
 cryptor/*.pem
--- a/README.md
+++ b/README.md
@@ -4,13 +4,12 @@
 <br/>

 ![Go version](https://img.shields.io/badge/go-%3E%3D1.16<recommend>-9cf)
-[![Release](https://img.shields.io/badge/release-1.2.5-green.svg)](https://github.com/duke-git/lancet/releases)
-[![GoDoc](https://godoc.org/github.com//duke-git/lancet?status.svg)](https://pkg.go.dev/github.com/duke-git/lancet)
-[![Go Report Card](https://goreportcard.com/badge/github.com/duke-git/lancet)](https://goreportcard.com/report/github.com/duke-git/lancet)
+[![Release](https://img.shields.io/badge/release-2.1.0-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)
 [![codecov](https://codecov.io/gh/duke-git/lancet/branch/main/graph/badge.svg?token=FC48T1F078)](https://codecov.io/gh/duke-git/lancet)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/duke-git/lancet/blob/main/LICENSE)
-
 </div>

 <div STYLE="page-break-after: always;"></div>
@@ -24,14 +23,21 @@ English | [简体中文](./README_zh-CN.md)
 ## Feature

 - 👏 Comprehensive, efficient and reusable.
- 💪 180+ go util functions, support string, slice, datetime, net, crypt...
+- 💪 300+ go util functions, support string, slice, datetime, net, crypt...
 - 💅 Only depend on the go standard library.
 - 🌍 Unit test for every exported function.

 ## Installation
+### Note:

+1. <b>For users who use go1.18 and above, it is recommended to install lancet v2.x.x. Cause v2.x.x rewrite all functions with generics of go1.18.</b>
 ```go
-go get github.com/duke-git/lancet
+go get github.com/duke-git/lancet/v2 // will install latest version of v2.x.x
+```
+
+2. <b>For users who use version below go1.18, you should install v1.x.x. now latest v1 is v1.3.0. </b>
+```go
+go get github.com/duke-git/lancet@v1.3.0 // below go1.18, install latest version of v1.x.x
 ```

 ## Usage
@@ -39,7 +45,7 @@ go get github.com/duke-git/lancet
 Lancet organizes the code into package structure, and you need to import the corresponding package name when use it. For example, if you use string-related functions,import the strutil package like below:

 ```go
-import "github.com/duke-git/lancet/strutil"
+import "github.com/duke-git/lancet/v2/strutil"
 ```

 ## Example
@@ -51,7 +57,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/strutil"
+    "github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -62,10 +68,49 @@ func main() {
 ```

 ## API Documentation
-### Convertor package contains some functions for data convertion.
+
+### 1. Algorithm package implements some basic algorithm. eg. sort, search.

 ```go
-import "github.com/duke-git/lancet/convertor"
+import "github.com/duke-git/lancet/v2/algorithm"
+```
+#### Function list:
+- [BubbleSort](https://github.com/duke-git/lancet/blob/main/docs/algorithm.md#BubbleSort)
+- [CountSort](https://github.com/duke-git/lancet/blob/main/docs/algorithm.md#CountSort)
+- [HeapSort](https://github.com/duke-git/lancet/blob/main/docs/algorithm.md#HeapSort)
+- [InsertionSort](https://github.com/duke-git/lancet/blob/main/docs/algorithm.md#InsertionSort)
+- [MergeSort](https://github.com/duke-git/lancet/blob/main/docs/algorithm.md#MergeSort)
+- [QuickSort](https://github.com/duke-git/lancet/blob/main/docs/algorithm.md#QuickSort)
+- [SelectionSort](https://github.com/duke-git/lancet/blob/main/docs/algorithm.md#SelectionSort)
+- [ShellSort](https://github.com/duke-git/lancet/blob/main/docs/algorithm.md#ShellSort)
+- [BinarySearch](https://github.com/duke-git/lancet/blob/main/docs/algorithm.md#BinarySearch)
+- [BinaryIterativeSearch](https://github.com/duke-git/lancet/blob/main/docs/algorithm.md#BinaryIterativeSearch)
+- [LinearSearch](https://github.com/duke-git/lancet/blob/main/docs/algorithm.md#LinearSearch)
+- [LRUCache](https://github.com/duke-git/lancet/blob/main/docs/algorithm.md#LRUCache)
+
+
+
+### 2. Concurrency package contain some functions to support concurrent programming. eg, goroutine, channel, async.
+
+```go
+import "github.com/duke-git/lancet/v2/concurrency"
+```
+#### Function list:
+- [NewChannel](https://github.com/duke-git/lancet/blob/main/docs/concurrency.md#NewChannel)
+- [Bridge](https://github.com/duke-git/lancet/blob/main/docs/concurrency.md#Bridge)
+- [FanIn](https://github.com/duke-git/lancet/blob/main/docs/concurrency.md#FanIn)
+- [Generate](https://github.com/duke-git/lancet/blob/main/docs/concurrency.md#Generate)
+- [Or](https://github.com/duke-git/lancet/blob/main/docs/concurrency.md#Or)
+- [OrDone](https://github.com/duke-git/lancet/blob/main/docs/concurrency.md#OrDone)
+- [Repeat](https://github.com/duke-git/lancet/blob/main/docs/concurrency.md#Repeat)
+- [RepeatFn](https://github.com/duke-git/lancet/blob/main/docs/concurrency.md#RepeatFn)
+- [Take](https://github.com/duke-git/lancet/blob/main/docs/concurrency.md#Take)
+- [Tee](https://github.com/duke-git/lancet/blob/main/docs/concurrency.md#Tee)
+
+### 3. Convertor package contains some functions for data convertion.
+
+```go
+import "github.com/duke-git/lancet/v2/convertor"
 ```
 #### Function list:
 - [ColorHexToRGB](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ColorHexToRGB)
@@ -78,10 +123,10 @@ import "github.com/duke-git/lancet/convertor"
 - [ToString](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToString)
 - [StructToMap](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#StructToMap)
  
-### Cryptor package is for data encryption and decryption.
+### 4. Cryptor package is for data encryption and decryption.

 ```go
-import "github.com/duke-git/lancet/cryptor"
+import "github.com/duke-git/lancet/v2/cryptor"
 ```

 #### Function list:
@@ -118,11 +163,11 @@ import "github.com/duke-git/lancet/cryptor"
 - [RsaEncrypt](https://github.com/duke-git/lancet/blob/main/docs/cryptor.md#RsaEncrypt)
 - [RsaDecrypt](https://github.com/duke-git/lancet/blob/main/docs/cryptor.md#RsaDecrypt)

-### Datetime package supports date and time format and compare.
+### 5. Datetime package supports date and time format and compare.


 ```go
-import "github.com/duke-git/lancet/datetime"
+import "github.com/duke-git/lancet/v2/datetime"
 ```
 #### Function list:
 - [AddDay](https://github.com/duke-git/lancet/blob/main/docs/datetime.md#AddDay)
@@ -147,17 +192,48 @@ import "github.com/duke-git/lancet/datetime"
 - [GetNightTimestamp](https://github.com/duke-git/lancet/blob/main/docs/datetime.md#GetNightTimestamp)
 - [FormatTimeToStr](https://github.com/duke-git/lancet/blob/main/docs/datetime.md#FormatTimeToStr)
 - [FormatStrToTime](https://github.com/duke-git/lancet/blob/main/docs/datetime.md#FormatStrToTime)
+- [NewUnix](https://github.com/duke-git/lancet/blob/main/docs/datetime.md#NewUnix)
+- [NewUnixNow](https://github.com/duke-git/lancet/blob/main/docs/datetime.md#NewUnixNow)
+- [NewFormat](https://github.com/duke-git/lancet/blob/main/docs/datetime.md#NewFormat)
+- [NewISO8601](https://github.com/duke-git/lancet/blob/main/docs/datetime.md#NewISO8601)
+- [ToUnix](https://github.com/duke-git/lancet/blob/main/docs/datetime.md#ToUnix)
+- [ToFormat](https://github.com/duke-git/lancet/blob/main/docs/datetime.md#ToFormat)
+- [ToFormatForTpl](https://github.com/duke-git/lancet/blob/main/docs/datetime.md#ToFormatForTpl)
+- [ToIso8601](https://github.com/duke-git/lancet/blob/main/docs/datetime.md#ToIso8601)
+
+
+
+### 6. Datastructure package constains some common data structure. eg. list, linklist, stack, queue, set, tree, graph.

-### Fileutil package implements some basic functions for file operations.

 ```go
-import "github.com/duke-git/lancet/fileutil"
+import list "github.com/duke-git/lancet/v2/datastructure/list"
+import link "github.com/duke-git/lancet/v2/datastructure/link"
+import stack "github.com/duke-git/lancet/v2/datastructure/stack"
+import queue "github.com/duke-git/lancet/v2/datastructure/queue"
+import set "github.com/duke-git/lancet/v2/datastructure/set"
+import tree "github.com/duke-git/lancet/v2/datastructure/tree"
+```
+#### Function list:
+- [List](https://github.com/duke-git/lancet/blob/main/docs/datastructure/list.md)
+- [Linklist](https://github.com/duke-git/lancet/blob/main/docs/datastructure/linklist.md)
+- [Stack](https://github.com/duke-git/lancet/blob/main/docs/datastructure/stack.md)
+- [Queue](https://github.com/duke-git/lancet/blob/main/docs/datastructure/queue.md)
+- [Set](https://github.com/duke-git/lancet/blob/main/docs/datastructure/set.md)
+- [Tree](https://github.com/duke-git/lancet/blob/main/docs/datastructure/tree.md)
+
+
+### 7. Fileutil package implements some basic functions for file operations.
+
+```go
+import "github.com/duke-git/lancet/v2/fileutil"
 ```

 #### Function list：

 - [ClearFile](https://github.com/duke-git/lancet/blob/main/docs/fileutil.md#ClearFile)
 - [CreateFile](https://github.com/duke-git/lancet/blob/main/docs/fileutil.md#CreateFile)
+- [CreateDir](https://github.com/duke-git/lancet/blob/main/docs/fileutil.md#CreateDir)
 - [CopyFile](https://github.com/duke-git/lancet/blob/main/docs/fileutil.md#CopyFile)
 - [FileMode](https://github.com/duke-git/lancet/blob/main/docs/fileutil.md#FileMode)
 - [MiMeType](https://github.com/duke-git/lancet/blob/main/docs/fileutil.md#MiMeType)
@@ -171,18 +247,18 @@ import "github.com/duke-git/lancet/fileutil"
 - [Zip](https://github.com/duke-git/lancet/blob/main/docs/fileutil.md#Zip)
 - [UnZip](https://github.com/duke-git/lancet/blob/main/docs/fileutil.md#UnZip)

-### Formatter contains some functions for data formatting.
+### 8. Formatter contains some functions for data formatting.

 ```go
-import "github.com/duke-git/lancet/formatter"
+import "github.com/duke-git/lancet/v2/formatter"
 ```
 #### Function list:
 - [Comma](https://github.com/duke-git/lancet/blob/main/docs/formatter.md#Comma)

-### Function package can control the flow of function execution and support part of functional programming
+### 9. Function package can control the flow of function execution and support part of functional programming

 ```go
-import "github.com/duke-git/lancet/function"
+import "github.com/duke-git/lancet/v2/function"
 ```

 #### Function list:
@@ -192,13 +268,50 @@ import "github.com/duke-git/lancet/function"
 - [Compose](https://github.com/duke-git/lancet/blob/main/docs/function.md#Compose)
 - [Debounced](https://github.com/duke-git/lancet/blob/main/docs/function.md#Debounced)
 - [Delay](https://github.com/duke-git/lancet/blob/main/docs/function.md#Delay)
- [Delay](https://github.com/duke-git/lancet/blob/main/docs/function.md#Delay)
 - [Watcher](https://github.com/duke-git/lancet/blob/main/docs/function.md#Watcher)

-### Netutil package contains functions to get net information and send http request.
+
+### 10. Maputil package includes some functions to manipulate map.

 ```go
-import "github.com/duke-git/lancet/netutil"
+import "github.com/duke-git/lancet/v2/maputil"
+```
+
+#### Function list:
+- [ForEach](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#ForEach)
+- [Filter](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#Filter)
+- [Intersect](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#Intersect)
+- [Keys](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#Keys)
+- [Merge](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#Merge)
+- [Minus](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#Minus)
+- [Values](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#Values)
+
+
+### 11. Mathutil package implements some functions for math calculation.
+
+```go
+import "github.com/duke-git/lancet/v2/mathutil"
+```
+
+#### Function list:
+- [Average](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#Average)
+- [Exponent](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#Exponent)
+- [Fibonacci](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#Fibonacci)
+- [Factorial](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#Factorial)
+- [Max](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#Max)
+- [MaxBy](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#MaxBy)
+- [Min](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#Min)
+- [MinBy](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#MinBy)
+- [Percent](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#Percent)
+- [RoundToFloat](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#RoundToFloat)
+- [RoundToString](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#RoundToString)
+- [TruncRound](https://github.com/duke-git/lancet/blob/main/docs/mathutil.md#TruncRound)
+
+
+### 12. Netutil package contains functions to get net information and send http request.
+
+```go
+import "github.com/duke-git/lancet/v2/netutil"
 ```

 #### Function list:
@@ -215,21 +328,22 @@ import "github.com/duke-git/lancet/netutil"
 - [HttpPatch](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#HttpPatch)
 - [ParseHttpResponse](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#ParseHttpResponse)

-### Random package implements some basic functions to generate random int and string.
+### 13. Random package implements some basic functions to generate random int and string.

 ```go
-import "github.com/duke-git/lancet/random"
+import "github.com/duke-git/lancet/v2/random"
 ```

 #### Function list:
 - [RandBytes](https://github.com/duke-git/lancet/blob/main/docs/random.md#RandBytes)
 - [RandInt](https://github.com/duke-git/lancet/blob/main/docs/random.md#RandInt)
 - [RandString](https://github.com/duke-git/lancet/blob/main/docs/random.md#RandString)
+- [UUIdV4](https://github.com/duke-git/lancet/blob/main/docs/random.md#UUIdV4)

-### Retry package is for executing a function repeatedly until it was successful or canceled by the context.
+### 14. Retry package is for executing a function repeatedly until it was successful or canceled by the context.

 ```go
-import "github.com/duke-git/lancet/retry"
+import "github.com/duke-git/lancet/v2/retry"
 ```

 #### Function list:
@@ -239,10 +353,10 @@ import "github.com/duke-git/lancet/retry"
 - [RetryDuration](https://github.com/duke-git/lancet/blob/main/docs/retry.md#RetryDuration)
 - [RetryTimes](https://github.com/duke-git/lancet/blob/main/docs/retry.md#RetryTimes)

-### Slice contains some functions to manipulate slice.
+### 15. Slice contains some functions to manipulate slice.

 ```go
-import "github.com/duke-git/lancet/slice"
+import "github.com/duke-git/lancet/v2/slice"
 ```

 #### Function list:
@@ -254,8 +368,11 @@ import "github.com/duke-git/lancet/slice"
 - [Count](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Count)
 - [Difference](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Difference)
 - [DifferenceBy](https://github.com/duke-git/lancet/blob/main/docs/slice.md#DifferenceBy)
- [DeleteByIndex](https://github.com/duke-git/lancet/blob/main/docs/slice.md#DeleteByIndex)
+- [DifferenceWith](https://github.com/duke-git/lancet/blob/main/docs/slice.md#DifferenceWith)
+- [DeleteAt](https://github.com/duke-git/lancet/blob/main/docs/slice.md#DeleteAt)
 - [Drop](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Drop)
+- [Equal](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Equal)
+- [EqualWith](https://github.com/duke-git/lancet/blob/main/docs/slice.md#EqualWith)
 - [Every](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Every)
 - [Filter](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Filter)
 - [Find](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Find)
@@ -263,26 +380,30 @@ import "github.com/duke-git/lancet/slice"
 - [FlattenDeep](#FlattenDeep)
 - [ForEach](https://github.com/duke-git/lancet/blob/main/docs/slice.md#ForEach)
 - [GroupBy](https://github.com/duke-git/lancet/blob/main/docs/slice.md#GroupBy)
+- [GroupWith](https://github.com/duke-git/lancet/blob/main/docs/slice.md#GroupWith)
 - [IntSlice](https://github.com/duke-git/lancet/blob/main/docs/slice.md#IntSlice)
 - [InterfaceSlice](https://github.com/duke-git/lancet/blob/main/docs/slice.md#InterfaceSlice)
 - [Intersection](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Intersection)
- [InsertByIndex](https://github.com/duke-git/lancet/blob/main/docs/slice.md#InsertByIndex)
+- [InsertAt](https://github.com/duke-git/lancet/blob/main/docs/slice.md#InsertAt)
+- [IndexOf](https://github.com/duke-git/lancet/blob/main/docs/slice.md#IndexOf)
+- [LastIndexOf](https://github.com/duke-git/lancet/blob/main/docs/slice.md#LastIndexOf)
 - [Map](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Map)
- [ReverseSlice](https://github.com/duke-git/lancet/blob/main/docs/slice.md#ReverseSlice)
+- [Reverse](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Reverse)
 - [Reduce](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Reduce)
 - [Shuffle](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Shuffle)
 - [SortByField](https://github.com/duke-git/lancet/blob/main/docs/slice.md#SortByField)
 - [Some](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Some)
 - [StringSlice](https://github.com/duke-git/lancet/blob/main/docs/slice.md#StringSlice)
+- [SymmetricDifference](https://github.com/duke-git/lancet/blob/main/docs/slice.md#SymmetricDifference)
 - [Unique](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Unique)
+- [UniqueBy](https://github.com/duke-git/lancet/blob/main/docs/slice.md#UniqueBy)
 - [Union](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Union)
- [UpdateByIndex](https://github.com/duke-git/lancet/blob/main/docs/slice.md#UpdateByIndex)
+- [UpdateAt](https://github.com/duke-git/lancet/blob/main/docs/slice.md#UpdateAt)
 - [Without](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Without)

-### Strutil package contains some functions to manipulate string.
-
+### 16. Strutil package contains some functions to manipulate string.
 ```go
-import "github.com/duke-git/lancet/strutil"
+import "github.com/duke-git/lancet/v2/strutil"
 ```

 #### Function list:
@@ -301,15 +422,15 @@ import "github.com/duke-git/lancet/strutil"
 - [PadStart](https://github.com/duke-git/lancet/blob/main/docs/strutil.md#PadStart)
 - [ReverseStr](https://github.com/duke-git/lancet/blob/main/docs/strutil.md#ReverseStr)
 - [SnakeCase](https://github.com/duke-git/lancet/blob/main/docs/strutil.md#SnakeCase)
+- [SplitEx](https://github.com/duke-git/lancet/blob/main/docs/strutil.md#SplitEx)
 - [Wrap](https://github.com/duke-git/lancet/blob/main/docs/strutil.md#Wrap)
 - [Unwrap](https://github.com/duke-git/lancet/blob/main/docs/strutil.md#Unwrap)
  
-### System package contain some functions about os, runtime, shell command.
+### 17. System package contain some functions about os, runtime, shell command.

 ```go
-import "github.com/duke-git/lancet/system"
+import "github.com/duke-git/lancet/v2/system"
 ```
-
 #### Function list:
 - [IsWindows](https://github.com/duke-git/lancet/blob/main/docs/system.md#IsWindows)
 - [IsLinux](https://github.com/duke-git/lancet/blob/main/docs/system.md#IsLinux)
@@ -320,11 +441,12 @@ import "github.com/duke-git/lancet/system"
 - [CompareOsEnv](https://github.com/duke-git/lancet/blob/main/docs/system.md#CompareOsEnv)
 - [ExecCommand](https://github.com/duke-git/lancet/blob/main/docs/system.md#ExecCommand)

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

 ```go
-import "github.com/duke-git/lancet/validator"
+import "github.com/duke-git/lancet/v2/validator"
 ```
+
 #### Function list:

 - [ContainChinese](https://github.com/duke-git/lancet/blob/main/docs/validator.md#ContainChinese)
@@ -352,4 +474,22 @@ import "github.com/duke-git/lancet/validator"
 - [IsIpV6](https://github.com/duke-git/lancet/blob/main/docs/validator.md#IsIpV6)
 - [IsStrongPassword](https://github.com/duke-git/lancet/blob/main/docs/validator.md#IsStrongPassword)
 - [IsUrl](https://github.com/duke-git/lancet/blob/main/docs/validator.md#IsUrl)
- [IsWeakPassword](https://github.com/duke-git/lancet/blob/main/docs/validator.md#IsWeakPassword)
+- [IsWeakPassword](https://github.com/duke-git/lancet/blob/main/docs/validator.md#IsWeakPassword)
+### 19. xerror package implements helpers for errors.
+
+```go
+import "github.com/duke-git/lancet/v2/xerror"
+```
+#### Function list:
+- [Unwrap](https://github.com/duke-git/lancet/blob/main/docs/xerror.md#Unwrap)
+  
+
+## How to Contribute
+
+I really appreciate any code commits which make lancet lib powerful. Please follow the rules below to create your pull request.
+
+1. Fork the repository.
+2. Create your feature branch.
+3. Commit your changes.
+4. Push to the branch
+5. Create new pull request.
--- a/README_zh-CN.md
+++ b/README_zh-CN.md
@@ -4,13 +4,12 @@
 <br/>

 ![Go version](https://img.shields.io/badge/go-%3E%3D1.16<recommend>-9cf)
-[![Release](https://img.shields.io/badge/release-1.2.5-green.svg)](https://github.com/duke-git/lancet/releases)
-[![GoDoc](https://godoc.org/github.com//duke-git/lancet?status.svg)](https://pkg.go.dev/github.com/duke-git/lancet)
-[![Go Report Card](https://goreportcard.com/badge/github.com/duke-git/lancet)](https://goreportcard.com/report/github.com/duke-git/lancet)
+[![Release](https://img.shields.io/badge/release-2.1.0-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)
 [![codecov](https://codecov.io/gh/duke-git/lancet/branch/main/graph/badge.svg?token=FC48T1F078)](https://codecov.io/gh/duke-git/lancet)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/duke-git/lancet/blob/main/LICENSE)
-
 </div>

 <div STYLE="page-break-after: always;"></div>
@@ -24,14 +23,21 @@
 ## 特性

 - 👏 全面、高效、可复用
- 💪 180+常用go工具函数，支持string、slice、datetime、net、crypt...
+- 💪 300+常用go工具函数，支持string、slice、datetime、net、crypt...
 - 💅 只依赖go标准库
 - 🌍 所有导出函数单元测试覆盖率100%

 ## 安装
+### Note: 
+1. <b>对于使用go1.18及以上的用户，建议安装v2.x.x。 因为v2.x.x用go1.18的泛型重写了大部分函数。</b>

 ```go
-go get github.com/duke-git/lancet
+go get github.com/duke-git/lancet/v2 //安装v2最新版本v2.x.x
+```
+
+2. <b>使用go1.18以下版本的用户，必须安装v1.x.x。目前最新的v1版本是v1.3.0。</b>
+```go
+go get github.com/duke-git/lancet@v1.3.0 // 使用go1.18以下版本, 必须安装v1.x.x版本
 ```

 ## 用法
@@ -39,7 +45,7 @@ go get github.com/duke-git/lancet
 lancet是以包的结构组织代码的，使用时需要导入相应的包名。例如：如果使用字符串相关函数，需要导入strutil包:

 ```go
-import "github.com/duke-git/lancet/strutil"
+import "github.com/duke-git/lancet/v2/strutil"
 ```

 ## 例子
@@ -51,7 +57,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/strutil"
+    "github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -62,10 +68,48 @@ func main() {
 ```

 ## API文档
-### convertor转换器包支持一些常见的数据类型转换。
+
+### 1. algorithm算法包实现一些基本算法。eg. sort, search.

 ```go
-import "github.com/duke-git/lancet/convertor"
+import "github.com/duke-git/lancet/v2/algorithm"
+```
+#### Function list:
+- [BubbleSort](https://github.com/duke-git/lancet/blob/main/docs/algorithm_zh-CN.md#BubbleSort)
+- [CountSort](https://github.com/duke-git/lancet/blob/main/docs/algorithm_zh-CN.md#CountSort)
+- [HeapSort](https://github.com/duke-git/lancet/blob/main/docs/algorithm_zh-CN.md#HeapSort)
+- [InsertionSort](https://github.com/duke-git/lancet/blob/main/docs/algorithm_zh-CN.md#InsertionSort)
+- [MergeSort](https://github.com/duke-git/lancet/blob/main/docs/algorithm_zh-CN.md#MergeSort)
+- [QuickSort](https://github.com/duke-git/lancet/blob/main/docs/algorithm_zh-CN.md#QuickSort)
+- [SelectionSort](https://github.com/duke-git/lancet/blob/main/docs/algorithm_zh-CN.md#SelectionSort)
+- [ShellSort](https://github.com/duke-git/lancet/blob/main/docs/algorithm_zh-CN.md#ShellSort)
+- [BinarySearch](https://github.com/duke-git/lancet/blob/main/docs/algorithm_zh-CN.md#BinarySearch)
+- [BinaryIterativeSearch](https://github.com/duke-git/lancet/blob/main/docs/algorithm_zh-CN.md#BinaryIterativeSearch)
+- [LinearSearch](https://github.com/duke-git/lancet/blob/main/docs/algorithm_zh-CN.md#LinearSearch)
+- [LRUCache](https://github.com/duke-git/lancet/blob/main/docs/algorithm_zh-CN.md#LRUCache)
+
+
+### 2. 并发包包含一些支持并发编程的功能。例如：goroutine, channel, async等。
+
+```go
+import "github.com/duke-git/lancet/v2/concurrency"
+```
+#### Function list:
+- [NewChannel](https://github.com/duke-git/lancet/blob/main/docs/concurrency_zh-CN.md#NewChannel)
+- [Bridge](https://github.com/duke-git/lancet/blob/main/docs/concurrency_zh-CN.md#Bridge)
+- [FanIn](https://github.com/duke-git/lancet/blob/main/docs/concurrency_zh-CN.md#FanIn)
+- [Generate](https://github.com/duke-git/lancet/blob/main/docs/concurrency_zh-CN.md#Generate)
+- [Or](https://github.com/duke-git/lancet/blob/main/docs/concurrency_zh-CN.md#Or)
+- [OrDone](https://github.com/duke-git/lancet/blob/main/docs/concurrency_zh-CN.md#OrDone)
+- [Repeat](https://github.com/duke-git/lancet/blob/main/docs/concurrency_zh-CN.md#Repeat)
+- [RepeatFn](https://github.com/duke-git/lancet/blob/main/docs/concurrency_zh-CN.md#RepeatFn)
+- [Take](https://github.com/duke-git/lancet/blob/main/docs/concurrency_zh-CN.md#Take)
+- [Tee](https://github.com/duke-git/lancet/blob/main/docs/concurrency_zh-CN.md#Tee)
+  
+### 3. convertor转换器包支持一些常见的数据类型转换。
+
+```go
+import "github.com/duke-git/lancet/v2/convertor"
 ```
 #### 函数列表:
 - [ColorHexToRGB](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ColorHexToRGB)
@@ -78,10 +122,10 @@ import "github.com/duke-git/lancet/convertor"
 - [ToString](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToString)
 - [StructToMap](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#StructToMap)
  
-### cryptor加密包支持数据加密和解密，获取md5，hash值。支持base64, md5, hmac, aes, des, rsa。
+### 4. cryptor加密包支持数据加密和解密，获取md5，hash值。支持base64, md5, hmac, aes, des, rsa。

 ```go
-import "github.com/duke-git/lancet/cryptor"
+import "github.com/duke-git/lancet/v2/cryptor"
 ```

 #### 函数列表:
@@ -118,11 +162,11 @@ import "github.com/duke-git/lancet/cryptor"
 - [RsaEncrypt](https://github.com/duke-git/lancet/blob/main/docs/cryptor_zh-CN.md#RsaEncrypt)
 - [RsaDecrypt](https://github.com/duke-git/lancet/blob/main/docs/cryptor_zh-CN.md#RsaDecrypt)

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


 ```go
-import "github.com/duke-git/lancet/datetime"
+import "github.com/duke-git/lancet/v2/datetime"
 ```
 #### 函数列表:
 - [AddDay](https://github.com/duke-git/lancet/blob/main/docs/datetime_zh-CN.md#AddDay)
@@ -147,17 +191,47 @@ import "github.com/duke-git/lancet/datetime"
 - [GetNightTimestamp](https://github.com/duke-git/lancet/blob/main/docs/datetime_zh-CN.md#GetNightTimestamp)
 - [FormatTimeToStr](https://github.com/duke-git/lancet/blob/main/docs/datetime_zh-CN.md#FormatTimeToStr)
 - [FormatStrToTime](https://github.com/duke-git/lancet/blob/main/docs/datetime_zh-CN.md#FormatStrToTime)
+- [NewUnix](https://github.com/duke-git/lancet/blob/main/docs/datetime_zh-CN.md#NewUnix)
+- [NewUnixNow](https://github.com/duke-git/lancet/blob/main/docs/datetime_zh-CN.md#NewUnixNow)
+- [NewFormat](https://github.com/duke-git/lancet/blob/main/docs/datetime_zh-CN.md#NewFormat)
+- [NewISO8601](https://github.com/duke-git/lancet/blob/main/docs/datetime_zh-CN.md#NewISO8601)
+- [ToUnix](https://github.com/duke-git/lancet/blob/main/docs/datetime_zh-CN.md#ToUnix)
+- [ToFormat](https://github.com/duke-git/lancet/blob/main/docs/datetime_zh-CN.md#ToFormat)
+- [ToFormatForTpl](https://github.com/duke-git/lancet/blob/main/docs/datetime_zh-CN.md#ToFormatForTpl)
+- [ToIso8601](https://github.com/duke-git/lancet/blob/main/docs/datetime_zh-CN.md#ToIso8601)
+
+
+### 6. datastructure包含一些普通的数据结构实现。例如：list, linklist, stack, queue, set, tree, graph.

-### fileutil包支持文件基本操作。

 ```go
-import "github.com/duke-git/lancet/fileutil"
+import list "github.com/duke-git/lancet/v2/datastructure/list"
+import link "github.com/duke-git/lancet/v2/datastructure/link"
+import stack "github.com/duke-git/lancet/v2/datastructure/stack"
+import queue "github.com/duke-git/lancet/v2/datastructure/queue"
+import set "github.com/duke-git/lancet/v2/datastructure/set"
+import tree "github.com/duke-git/lancet/v2/datastructure/tree"
+```
+#### Function list:
+- [List](https://github.com/duke-git/lancet/blob/main/docs/datastructure/list_zh-CN.md)
+- [Linklist](https://github.com/duke-git/lancet/blob/main/docs/datastructure/linklist_zh-CN.md)
+- [Stack](https://github.com/duke-git/lancet/blob/main/docs/datastructure/stack_zh-CN.md)
+- [Queue](https://github.com/duke-git/lancet/blob/main/docs/datastructure/queue_zh-CN.md)
+- [Set](https://github.com/duke-git/lancet/blob/main/docs/datastructure/set_zh-CN.md)
+- [Tree](https://github.com/duke-git/lancet/blob/main/docs/datastructure/tree_zh-CN.md)
+
+
+### 7. fileutil包支持文件基本操作。
+
+```go
+import "github.com/duke-git/lancet/v2/fileutil"
 ```

 #### 函数列表：

 - [ClearFile](https://github.com/duke-git/lancet/blob/main/docs/fileutil_zh-CN.md#ClearFile)
 - [CreateFile](https://github.com/duke-git/lancet/blob/main/docs/fileutil_zh-CN.md#CreateFile)
+- [CreateDir](https://github.com/duke-git/lancet/blob/main/docs/fileutil_zh-CN.md#CreateDir)
 - [CopyFile](https://github.com/duke-git/lancet/blob/main/docs/fileutil_zh-CN.md#CopyFile)
 - [FileMode](https://github.com/duke-git/lancet/blob/main/docs/fileutil_zh-CN.md#FileMode)
 - [MiMeType](https://github.com/duke-git/lancet/blob/main/docs/fileutil_zh-CN.md#MiMeType)
@@ -171,19 +245,19 @@ import "github.com/duke-git/lancet/fileutil"
 - [Zip](https://github.com/duke-git/lancet/blob/main/docs/fileutil_zh-CN.md#Zip)
 - [UnZip](https://github.com/duke-git/lancet/blob/main/docs/fileutil_zh-CN.md#UnZip)

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

 ```go
-import "github.com/duke-git/lancet/formatter"
+import "github.com/duke-git/lancet/v2/formatter"
 ```
 #### 函数列表:
 - [Comma](https://github.com/duke-git/lancet/blob/main/docs/formatter_zh-CN.md#Comma)


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

 ```go
-import "github.com/duke-git/lancet/function"
+import "github.com/duke-git/lancet/v2/function"
 ```

 #### 函数列表:
@@ -193,14 +267,48 @@ import "github.com/duke-git/lancet/function"
 - [Compose](https://github.com/duke-git/lancet/blob/main/docs/function_zh-CN.md#Compose)
 - [Debounced](https://github.com/duke-git/lancet/blob/main/docs/function_zh-CN.md#Debounced)
 - [Delay](https://github.com/duke-git/lancet/blob/main/docs/function_zh-CN.md#Delay)
- [Delay](https://github.com/duke-git/lancet/blob/main/docs/function_zh-CN.md#Delay)
 - [Watcher](https://github.com/duke-git/lancet/blob/main/docs/function_zh-CN.md#Watcher)


-### netutil网络包支持获取ip地址，发送http请求。
+### 10. maputil包包括一些操作map的函数.

 ```go
-import "github.com/duke-git/lancet/netutil"
+import "github.com/duke-git/lancet/v2/maputil"
+```
+
+#### 函数列表:
+- [ForEach](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#ForEach)
+- [Filter](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#Filter)
+- [Intersect](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#Intersect)
+- [Keys](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#Keys)
+- [Merge](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#Merge)
+- [Minus](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#Minus)
+- [Values](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#Values)
+
+### 11. mathutil包实现了一些数学计算的函数。
+
+```go
+import "github.com/duke-git/lancet/v2/mathutil"
+```
+
+#### Function list:
+- [Average](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#Average)
+- [Exponent](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#Exponent)
+- [Fibonacci](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#Fibonacci)
+- [Factorial](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#Factorial)
+- [Max](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#Max)
+- [MaxBy](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#MaxBy)
+- [Min](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#Min)
+- [MinBy](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#MinBy)
+- [Percent](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#Percent)
+- [RoundToFloat](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#RoundToFloat)
+- [RoundToString](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#RoundToString)
+- [TruncRound](https://github.com/duke-git/lancet/blob/main/docs/mathutil_zh-CN.md#TruncRound)
+
+### 12. netutil网络包支持获取ip地址，发送http请求。
+
+```go
+import "github.com/duke-git/lancet/v2/netutil"
 ```

 #### 函数列表:
@@ -217,21 +325,21 @@ import "github.com/duke-git/lancet/netutil"
 - [HttpPatch](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#HttpPatch)
 - [ParseHttpResponse](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#ParseHttpResponse)

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

 ```go
-import "github.com/duke-git/lancet/random"
+import "github.com/duke-git/lancet/v2/random"
 ```

 #### 函数列表:
 - [RandBytes](https://github.com/duke-git/lancet/blob/main/docs/random_zh-CN.md#RandBytes)
 - [RandInt](https://github.com/duke-git/lancet/blob/main/docs/random_zh-CN.md#RandInt)
 - [RandString](https://github.com/duke-git/lancet/blob/main/docs/random_zh-CN.md#RandString)
-
-### retry重试执行函数直到函数运行成功或被context cancel。
+- [UUIdV4](https://github.com/duke-git/lancet/blob/main/docs/random.md#UUIdV4)
+### 14. retry重试执行函数直到函数运行成功或被context cancel。

 ```go
-import "github.com/duke-git/lancet/retry"
+import "github.com/duke-git/lancet/v2/retry"
 ```

 #### 函数列表:
@@ -242,10 +350,10 @@ import "github.com/duke-git/lancet/retry"
 - [RetryTimes](https://github.com/duke-git/lancet/blob/main/docs/retry_zh-CN.md#RetryTimes)


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

 ```go
-import "github.com/duke-git/lancet/slice"
+import "github.com/duke-git/lancet/v2/slice"
 ```

 #### 函数列表:
@@ -257,7 +365,8 @@ import "github.com/duke-git/lancet/slice"
 - [Count](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Count)
 - [Difference](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Difference)
 - [DifferenceBy](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#DifferenceBy)
- [DeleteByIndex](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#DeleteByIndex)
+- [DifferenceWith](https://github.com/duke-git/lancet/blob/main/docs/slice.md#DifferenceWith)
+- [DeleteAt](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#DeleteAt)
 - [Drop](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Drop)
 - [Every](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Every)
 - [Filter](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Filter)
@@ -266,27 +375,32 @@ import "github.com/duke-git/lancet/slice"
 - [FlattenDeep](#FlattenDeep)
 - [ForEach](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#ForEach)
 - [GroupBy](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#GroupBy)
+- [GroupWith](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#GroupWith)
 - [IntSlice](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#IntSlice)
 - [InterfaceSlice](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#InterfaceSlice)
 - [Intersection](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Intersection)
- [InsertByIndex](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#InsertByIndex)
+- [InsertAt](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#InsertAt)
+- [IndexOf](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#IndexOf)
+- [LastIndexOf](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#LastIndexOf)
 - [Map](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Map)
- [ReverseSlice](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#ReverseSlice)
+- [Reverse](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Reverse)
 - [Reduce](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Reduce)
 - [Shuffle](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Shuffle)
 - [SortByField](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#SortByField)
 - [Some](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Some)
 - [StringSlice](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#StringSlice)
+- [SymmetricDifference](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#SymmetricDifference)
 - [Unique](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Unique)
+- [UniqueBy](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#UniqueBy)
 - [Union](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Union)
- [UpdateByIndex](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#UpdateByIndex)
+- [UpdateAt](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#UpdateAt)
 - [Without](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Without)


-### strutil包含处理字符串的相关函数。
+### 16. strutil包含处理字符串的相关函数。

 ```go
-import "github.com/duke-git/lancet/strutil"
+import "github.com/duke-git/lancet/v2/strutil"
 ```

 #### 函数列表:
@@ -305,14 +419,15 @@ import "github.com/duke-git/lancet/strutil"
 - [PadStart](https://github.com/duke-git/lancet/blob/main/docs/strutil_zh-CN.md#PadStart)
 - [ReverseStr](https://github.com/duke-git/lancet/blob/main/docs/strutil_zh-CN.md#ReverseStr)
 - [SnakeCase](https://github.com/duke-git/lancet/blob/main/docs/strutil_zh-CN.md#SnakeCase)
+- [SplitEx](https://github.com/duke-git/lancet/blob/main/docs/strutil_zh-CN.md#SplitEx)
 - [Wrap](https://github.com/duke-git/lancet/blob/main/docs/strutil_zh-CN.md#Wrap)
 - [Unwrap](https://github.com/duke-git/lancet/blob/main/docs/strutil_zh-CN.md#Unwrap)
  

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

 ```go
-import "github.com/duke-git/lancet/system"
+import "github.com/duke-git/lancet/v2/system"
 ```

 #### 函数列表:
@@ -325,10 +440,10 @@ import "github.com/duke-git/lancet/system"
 - [CompareOsEnv](https://github.com/duke-git/lancet/blob/main/docs/system_zh-CN.md#CompareOsEnv)
 - [ExecCommand](https://github.com/duke-git/lancet/blob/main/docs/system_zh-CN.md#ExecCommand)

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

 ```go
-import "github.com/duke-git/lancet/validator"
+import "github.com/duke-git/lancet/v2/validator"
 ```
 #### 函数列表:

@@ -357,4 +472,23 @@ import "github.com/duke-git/lancet/validator"
 - [IsIpV6](https://github.com/duke-git/lancet/blob/main/docs/validator_zh-CN.md#IsIpV6)
 - [IsStrongPassword](https://github.com/duke-git/lancet/blob/main/docs/validator_zh-CN.md#IsStrongPassword)
 - [IsUrl](https://github.com/duke-git/lancet/blob/main/docs/validator_zh-CN.md#IsUrl)
- [IsWeakPassword](https://github.com/duke-git/lancet/blob/main/docs/validator_zh-CN.md#IsWeakPassword)
+- [IsWeakPassword](https://github.com/duke-git/lancet/blob/main/docs/validator_zh-CN.md#IsWeakPassword)
+
+validator.md#IsWeakPassword)
+### 19. xerror包实现一些错误处理函数
+
+```go
+import "github.com/duke-git/lancet/v2/xerror"
+```
+#### 函数列表:
+- [Unwrap](https://github.com/duke-git/lancet/blob/main/docs/xerror_zh-CN.md#Unwrap)
+
+## 如何贡献代码
+
+非常感激任何的代码提交以使lancet的功能越来越强大。创建pull request时请遵守以下规则。
+
+1. Fork lancet仓库。
+2. 创建自己的特性分支。
+3. 提交变更。
+4. Push分支。
+5. 创建新的pull request。
--- a/algorithm/lru_cache.go
+++ b/algorithm/lru_cache.go
@@ -0,0 +1,102 @@
+package algorithm
+
+type lruNode[K comparable, V any] struct {
+	key   K
+	value V
+	pre   *lruNode[K, V]
+	next  *lruNode[K, V]
+}
+
+// newLruNode return a lruNode pointer
+func newLruNode[K comparable, V any](key K, value V) *lruNode[K, V] {
+	return &lruNode[K, V]{
+		key:   key,
+		value: value,
+		pre:   nil,
+		next:  nil,
+	}
+}
+
+// LRUCache lru cache (thread unsafe)
+type LRUCache[K comparable, V any] struct {
+	cache    map[K]*lruNode[K, V]
+	head     *lruNode[K, V]
+	tail     *lruNode[K, V]
+	capacity int
+	length   int
+}
+
+// NewLRUCache return a LRUCache pointer
+func NewLRUCache[K comparable, V any](capacity int) *LRUCache[K, V] {
+	return &LRUCache[K, V]{
+		cache:    make(map[K]*lruNode[K, V], capacity),
+		head:     nil,
+		tail:     nil,
+		capacity: capacity,
+		length:   0,
+	}
+}
+
+// Get value of key from lru cache
+func (l *LRUCache[K, V]) Get(key K) (V, bool) {
+	var value V
+
+	node, ok := l.cache[key]
+	if ok {
+		l.moveToHead(node)
+		return node.value, true
+	}
+
+	return value, false
+}
+
+// Put value of key into lru cache
+func (l *LRUCache[K, V]) Put(key K, value V) {
+	node, ok := l.cache[key]
+	if !ok {
+		newNode := newLruNode(key, value)
+		l.cache[key] = newNode
+		l.addNode(newNode)
+
+		if len(l.cache) > l.capacity {
+			oldKey := l.deleteNode(l.head)
+			delete(l.cache, oldKey)
+		}
+	} else {
+		node.value = value
+		l.moveToHead(node)
+	}
+	l.length = len(l.cache)
+}
+
+func (l *LRUCache[K, V]) addNode(node *lruNode[K, V]) {
+	if l.tail != nil {
+		l.tail.next = node
+		node.pre = l.tail
+		node.next = nil
+	}
+	l.tail = node
+	if l.head == nil {
+		l.head = node
+	}
+}
+
+func (l *LRUCache[K, V]) deleteNode(node *lruNode[K, V]) K {
+	if node == l.tail {
+		l.tail = l.tail.pre
+	} else if node == l.head {
+		l.head = l.head.next
+	} else {
+		node.pre.next = node.next
+		node.next.pre = node.pre
+	}
+	return node.key
+}
+
+func (l *LRUCache[K, V]) moveToHead(node *lruNode[K, V]) {
+	if l.tail == node {
+		return
+	}
+	l.deleteNode(node)
+	l.addNode(node)
+}
--- a/algorithm/lru_cache_test.go
+++ b/algorithm/lru_cache_test.go
@@ -0,0 +1,36 @@
+package algorithm
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestLRUCache(t *testing.T) {
+	asssert := internal.NewAssert(t, "TestLRUCache")
+
+	cache := NewLRUCache[int, int](2)
+
+	cache.Put(1, 1)
+	cache.Put(2, 2)
+
+	_, ok := cache.Get(0)
+	asssert.Equal(false, ok)
+
+	v, ok := cache.Get(1)
+	asssert.Equal(true, ok)
+	asssert.Equal(1, v)
+
+	v, ok = cache.Get(2)
+	asssert.Equal(true, ok)
+	asssert.Equal(2, v)
+
+	cache.Put(3, 3)
+	v, ok = cache.Get(1)
+	asssert.Equal(false, ok)
+	asssert.NotEqual(1, v)
+
+	v, ok = cache.Get(3)
+	asssert.Equal(true, ok)
+	asssert.Equal(3, v)
+}
--- a/algorithm/search.go
+++ b/algorithm/search.go
@@ -0,0 +1,63 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package algorithm contain some basic algorithm functions. eg. sort, search, list, linklist, stack, queue, tree, graph. TODO
+package algorithm
+
+import "github.com/duke-git/lancet/v2/lancetconstraints"
+
+// Search algorithms see https://github.com/TheAlgorithms/Go/tree/master/search
+
+// LinearSearch Simple linear search algorithm that iterates over all elements of an slice
+// If a target is found, the index of the target is returned. Else the function return -1
+func LinearSearch[T any](slice []T, target T, comparator lancetconstraints.Comparator) int {
+	for i, v := range slice {
+		if comparator.Compare(v, target) == 0 {
+			return i
+		}
+	}
+	return -1
+}
+
+// BinarySearch search for target within a sorted slice, recursive call itself.
+// If a target is found, the index of the target is returned. Else the function return -1
+func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int {
+	if highIndex < lowIndex || len(sortedSlice) == 0 {
+		return -1
+	}
+
+	midIndex := int(lowIndex + (highIndex-lowIndex)/2)
+	isMidValGreatTarget := comparator.Compare(sortedSlice[midIndex], target) == 1
+	isMidValLessTarget := comparator.Compare(sortedSlice[midIndex], target) == -1
+
+	if isMidValGreatTarget {
+		return BinarySearch(sortedSlice, target, lowIndex, midIndex-1, comparator)
+	} else if isMidValLessTarget {
+		return BinarySearch(sortedSlice, target, midIndex+1, highIndex, comparator)
+	}
+
+	return midIndex
+}
+
+// BinaryIterativeSearch search for target within a sorted slice.
+// If a target is found, the index of the target is returned. Else the function return -1
+func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int {
+	startIndex := lowIndex
+	endIndex := highIndex
+
+	var midIndex int
+	for startIndex <= endIndex {
+		midIndex = int(startIndex + (endIndex-startIndex)/2)
+		isMidValGreatTarget := comparator.Compare(sortedSlice[midIndex], target) == 1
+		isMidValLessTarget := comparator.Compare(sortedSlice[midIndex], target) == -1
+
+		if isMidValGreatTarget {
+			endIndex = midIndex - 1
+		} else if isMidValLessTarget {
+			startIndex = midIndex + 1
+		} else {
+			return midIndex
+		}
+	}
+	return -1
+}
--- a/algorithm/search_test.go
+++ b/algorithm/search_test.go
@@ -0,0 +1,33 @@
+package algorithm
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+var sortedNumbers = []int{1, 2, 3, 4, 5, 6, 7, 8}
+
+func TestLinearSearch(t *testing.T) {
+	asssert := internal.NewAssert(t, "TestLinearSearch")
+
+	comparator := &intComparator{}
+	asssert.Equal(4, LinearSearch(sortedNumbers, 5, comparator))
+	asssert.Equal(-1, LinearSearch(sortedNumbers, 9, comparator))
+}
+
+func TestBinarySearch(t *testing.T) {
+	asssert := internal.NewAssert(t, "TestBinarySearch")
+
+	comparator := &intComparator{}
+	asssert.Equal(4, BinarySearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator))
+	asssert.Equal(-1, BinarySearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator))
+}
+
+func TestBinaryIterativeSearch(t *testing.T) {
+	asssert := internal.NewAssert(t, "TestBinaryIterativeSearch")
+
+	comparator := &intComparator{}
+	asssert.Equal(4, BinaryIterativeSearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator))
+	asssert.Equal(-1, BinaryIterativeSearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator))
+}
--- a/algorithm/sorter.go
+++ b/algorithm/sorter.go
@@ -0,0 +1,188 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package algorithm contain some basic algorithm functions. eg. sort, search
+package algorithm
+
+import "github.com/duke-git/lancet/v2/lancetconstraints"
+
+// BubbleSort use bubble to sort slice.
+func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+	for i := 0; i < len(slice); i++ {
+		for j := 0; j < len(slice)-1-i; j++ {
+			isCurrGreatThanNext := comparator.Compare(slice[j], slice[j+1]) == 1
+			if isCurrGreatThanNext {
+				swap(slice, j, j+1)
+			}
+		}
+	}
+}
+
+// InsertionSort use insertion to sort slice.
+func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+	for i := 0; i < len(slice); i++ {
+		for j := i; j > 0; j-- {
+			isPreLessThanCurrent := comparator.Compare(slice[j], slice[j-1]) == -1
+			if isPreLessThanCurrent {
+				swap(slice, j, j-1)
+			} else {
+				break
+			}
+		}
+	}
+}
+
+// SelectionSort use selection to sort slice.
+func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+	for i := 0; i < len(slice); i++ {
+		min := i
+		for j := i + 1; j < len(slice); j++ {
+			if comparator.Compare(slice[j], slice[min]) == -1 {
+				min = j
+			}
+		}
+		swap(slice, i, min)
+	}
+}
+
+// ShellSort shell sort slice.
+func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+	size := len(slice)
+
+	gap := 1
+	for gap < size/3 {
+		gap = 3*gap + 1
+	}
+
+	for gap >= 1 {
+		for i := gap; i < size; i++ {
+			for j := i; j >= gap && comparator.Compare(slice[j], slice[j-gap]) == -1; j -= gap {
+				swap(slice, j, j-gap)
+			}
+		}
+		gap = gap / 3
+	}
+}
+
+// QuickSort quick sorting for slice, lowIndex is 0 and highIndex is len(slice)-1
+func QuickSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) {
+	if lowIndex < highIndex {
+		p := partition(slice, lowIndex, highIndex, comparator)
+		QuickSort(slice, lowIndex, p-1, comparator)
+		QuickSort(slice, p+1, highIndex, comparator)
+	}
+}
+
+// partition split slice into two parts
+func partition[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int {
+	p := slice[highIndex]
+	i := lowIndex
+	for j := lowIndex; j < highIndex; j++ {
+		if comparator.Compare(slice[j], p) == -1 { //slice[j] < p
+			swap(slice, i, j)
+			i++
+		}
+	}
+
+	swap(slice, i, highIndex)
+
+	return i
+}
+
+// HeapSort use heap to sort slice
+func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+	size := len(slice)
+
+	for i := size/2 - 1; i >= 0; i-- {
+		sift(slice, i, size-1, comparator)
+	}
+	for j := size - 1; j > 0; j-- {
+		swap(slice, 0, j)
+		sift(slice, 0, j-1, comparator)
+	}
+}
+
+func sift[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) {
+	i := lowIndex
+	j := 2*i + 1
+
+	temp := slice[i]
+	for j <= highIndex {
+		if j < highIndex && comparator.Compare(slice[j], slice[j+1]) == -1 { //slice[j] < slice[j+1]
+			j++
+		}
+		if comparator.Compare(temp, slice[j]) == -1 { //tmp < slice[j]
+			slice[i] = slice[j]
+			i = j
+			j = 2*i + 1
+		} else {
+			break
+		}
+	}
+	slice[i] = temp
+}
+
+// MergeSort merge sorting for slice
+func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+	mergeSort(slice, 0, len(slice)-1, comparator)
+}
+
+func mergeSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) {
+	if lowIndex < highIndex {
+		mid := (lowIndex + highIndex) / 2
+		mergeSort(slice, lowIndex, mid, comparator)
+		mergeSort(slice, mid+1, highIndex, comparator)
+		merge(slice, lowIndex, mid, highIndex, comparator)
+	}
+}
+
+func merge[T any](slice []T, lowIndex, midIndex, highIndex int, comparator lancetconstraints.Comparator) {
+	i := lowIndex
+	j := midIndex + 1
+	temp := []T{}
+
+	for i <= midIndex && j <= highIndex {
+		//slice[i] < slice[j]
+		if comparator.Compare(slice[i], slice[j]) == -1 {
+			temp = append(temp, slice[i])
+			i++
+		} else {
+			temp = append(temp, slice[j])
+			j++
+		}
+	}
+
+	if i <= midIndex {
+		temp = append(temp, slice[i:midIndex+1]...)
+	} else {
+		temp = append(temp, slice[j:highIndex+1]...)
+	}
+
+	for k := 0; k < len(temp); k++ {
+		slice[lowIndex+k] = temp[k]
+	}
+}
+
+// CountSort use count sorting for slice
+func CountSort[T any](slice []T, comparator lancetconstraints.Comparator) []T {
+	size := len(slice)
+	out := make([]T, size)
+
+	for i := 0; i < size; i++ {
+		count := 0
+		for j := 0; j < size; j++ {
+			//slice[i] > slice[j]
+			if comparator.Compare(slice[i], slice[j]) == 1 {
+				count++
+			}
+		}
+		out[count] = slice[i]
+	}
+
+	return out
+}
+
+// swap two slice value at index i and j
+func swap[T any](slice []T, i, j int) {
+	slice[i], slice[j] = slice[j], slice[i]
+}
--- a/algorithm/sorter_test.go
+++ b/algorithm/sorter_test.go
@@ -0,0 +1,218 @@
+package algorithm
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+// People test mock data
+type people struct {
+	Name string
+	Age  int
+}
+
+// PeopleAageComparator sort people slice by age field
+type peopleAgeComparator struct{}
+
+// Compare implements github.com/duke-git/lancet/v2/lancetconstraints/constraints.go/Comparator
+func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
+	p1, _ := v1.(people)
+	p2, _ := v2.(people)
+
+	//ascending order
+	if p1.Age < p2.Age {
+		return -1
+	} else if p1.Age > p2.Age {
+		return 1
+	}
+	return 0
+}
+
+// var peoples = []people{
+// 	{Name: "a", Age: 20},
+// 	{Name: "b", Age: 10},
+// 	{Name: "c", Age: 17},
+// 	{Name: "d", Age: 8},
+// 	{Name: "e", Age: 28},
+// }
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1 any, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	//ascending order
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+// var intSlice = []int{2, 1, 5, 3, 6, 4}
+
+func TestBubbleSortForStructSlice(t *testing.T) {
+	asssert := internal.NewAssert(t, "TestBubbleSortForStructSlice")
+
+	peoples := []people{
+		{Name: "a", Age: 20},
+		{Name: "b", Age: 10},
+		{Name: "c", Age: 17},
+		{Name: "d", Age: 8},
+		{Name: "e", Age: 28},
+	}
+	comparator := &peopleAgeComparator{}
+	BubbleSort(peoples, comparator)
+
+	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
+	actual := fmt.Sprintf("%v", peoples)
+
+	asssert.Equal(expected, actual)
+}
+
+func TestBubbleSortForIntSlice(t *testing.T) {
+	asssert := internal.NewAssert(t, "TestBubbleSortForIntSlice")
+	numbers := []int{2, 1, 5, 3, 6, 4}
+	comparator := &intComparator{}
+	BubbleSort(numbers, comparator)
+
+	asssert.Equal([]int{1, 2, 3, 4, 5, 6}, numbers)
+}
+
+func TestInsertionSort(t *testing.T) {
+	asssert := internal.NewAssert(t, "TestInsertionSort")
+
+	peoples := []people{
+		{Name: "a", Age: 20},
+		{Name: "b", Age: 10},
+		{Name: "c", Age: 17},
+		{Name: "d", Age: 8},
+		{Name: "e", Age: 28},
+	}
+	comparator := &peopleAgeComparator{}
+	InsertionSort(peoples, comparator)
+
+	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
+	actual := fmt.Sprintf("%v", peoples)
+
+	asssert.Equal(expected, actual)
+}
+
+func TestSelectionSort(t *testing.T) {
+	asssert := internal.NewAssert(t, "TestSelectionSort")
+
+	peoples := []people{
+		{Name: "a", Age: 20},
+		{Name: "b", Age: 10},
+		{Name: "c", Age: 17},
+		{Name: "d", Age: 8},
+		{Name: "e", Age: 28},
+	}
+	comparator := &peopleAgeComparator{}
+	SelectionSort(peoples, comparator)
+
+	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
+	actual := fmt.Sprintf("%v", peoples)
+
+	asssert.Equal(expected, actual)
+}
+
+func TestShellSort(t *testing.T) {
+	asssert := internal.NewAssert(t, "TestShellSort")
+
+	peoples := []people{
+		{Name: "a", Age: 20},
+		{Name: "b", Age: 10},
+		{Name: "c", Age: 17},
+		{Name: "d", Age: 8},
+		{Name: "e", Age: 28},
+	}
+	comparator := &peopleAgeComparator{}
+	ShellSort(peoples, comparator)
+
+	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
+	actual := fmt.Sprintf("%v", peoples)
+
+	asssert.Equal(expected, actual)
+}
+
+func TestQuickSort(t *testing.T) {
+	asssert := internal.NewAssert(t, "TestQuickSort")
+
+	peoples := []people{
+		{Name: "a", Age: 20},
+		{Name: "b", Age: 10},
+		{Name: "c", Age: 17},
+		{Name: "d", Age: 8},
+		{Name: "e", Age: 28},
+	}
+	comparator := &peopleAgeComparator{}
+	QuickSort(peoples, 0, len(peoples)-1, comparator)
+
+	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
+	actual := fmt.Sprintf("%v", peoples)
+
+	asssert.Equal(expected, actual)
+}
+
+func TestHeapSort(t *testing.T) {
+	asssert := internal.NewAssert(t, "TestHeapSort")
+
+	peoples := []people{
+		{Name: "a", Age: 20},
+		{Name: "b", Age: 10},
+		{Name: "c", Age: 17},
+		{Name: "d", Age: 8},
+		{Name: "e", Age: 28},
+	}
+	comparator := &peopleAgeComparator{}
+	HeapSort(peoples, comparator)
+
+	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
+	actual := fmt.Sprintf("%v", peoples)
+
+	asssert.Equal(expected, actual)
+}
+
+func TestMergeSort(t *testing.T) {
+	asssert := internal.NewAssert(t, "TestMergeSort")
+
+	peoples := []people{
+		{Name: "a", Age: 20},
+		{Name: "b", Age: 10},
+		{Name: "c", Age: 17},
+		{Name: "d", Age: 8},
+		{Name: "e", Age: 28},
+	}
+	comparator := &peopleAgeComparator{}
+	MergeSort(peoples, comparator)
+
+	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
+	actual := fmt.Sprintf("%v", peoples)
+
+	asssert.Equal(expected, actual)
+}
+
+func TestCountSort(t *testing.T) {
+	asssert := internal.NewAssert(t, "TestCountSort")
+
+	peoples := []people{
+		{Name: "a", Age: 20},
+		{Name: "b", Age: 10},
+		{Name: "c", Age: 17},
+		{Name: "d", Age: 8},
+		{Name: "e", Age: 28},
+	}
+	comparator := &peopleAgeComparator{}
+	sortedPeopleByAge := CountSort(peoples, comparator)
+	t.Log(sortedPeopleByAge)
+
+	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
+	actual := fmt.Sprintf("%v", sortedPeopleByAge)
+
+	asssert.Equal(expected, actual)
+}
--- a/concurrency/channel.go
+++ b/concurrency/channel.go
@@ -0,0 +1,243 @@
+// 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
+
+import (
+	"context"
+	"sync"
+)
+
+// Channel is a logic object which can generate or manipulate go channel
+// all methods of Channel are in the book tilted《Concurrency in Go》
+type Channel struct {
+}
+
+// NewChannel return a Channel instance
+func NewChannel() *Channel {
+	return &Channel{}
+}
+
+// Generate a data of type any chan, put param `values` into the chan
+func (c *Channel) Generate(ctx context.Context, values ...any) <-chan any {
+	dataStream := make(chan any)
+
+	go func() {
+		defer close(dataStream)
+
+		for _, v := range values {
+			select {
+			case <-ctx.Done():
+				return
+			case dataStream <- v:
+			}
+		}
+	}()
+
+	return dataStream
+}
+
+// Repeat return a data of type any chan, put param `values` into the chan repeatly until cancel the context.
+func (c *Channel) Repeat(ctx context.Context, values ...any) <-chan any {
+	dataStream := make(chan any)
+
+	go func() {
+		defer close(dataStream)
+		for {
+			for _, v := range values {
+				select {
+				case <-ctx.Done():
+					return
+				case dataStream <- v:
+				}
+			}
+		}
+	}()
+	return dataStream
+}
+
+// RepeatFn return a chan, excutes fn repeatly, and put the result into retruned chan
+// until close the `done` channel
+func (c *Channel) RepeatFn(ctx context.Context, fn func() any) <-chan any {
+	dataStream := make(chan any)
+
+	go func() {
+		defer close(dataStream)
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case dataStream <- fn():
+			}
+		}
+	}()
+	return dataStream
+}
+
+// Take return a chan whose values are tahken from another chan
+func (c *Channel) Take(ctx context.Context, valueStream <-chan any, number int) <-chan any {
+	takeStream := make(chan any)
+
+	go func() {
+		defer close(takeStream)
+
+		for i := 0; i < number; i++ {
+			select {
+			case <-ctx.Done():
+				return
+			case takeStream <- <-valueStream:
+			}
+		}
+	}()
+
+	return takeStream
+}
+
+// FanIn merge multiple channels into one channel
+func (c *Channel) FanIn(ctx context.Context, channels ...<-chan any) <-chan any {
+	out := make(chan any)
+
+	go func() {
+		var wg sync.WaitGroup
+		wg.Add(len(channels))
+
+		for _, c := range channels {
+			go func(c <-chan any) {
+				defer wg.Done()
+				for v := range c {
+					select {
+					case <-ctx.Done():
+						return
+					case out <- v:
+					}
+				}
+			}(c)
+		}
+		wg.Wait()
+		close(out)
+	}()
+
+	return out
+}
+
+// Tee split one chanel into two channels
+func (c *Channel) Tee(ctx context.Context, in <-chan any) (<-chan any, <-chan any) {
+	out1 := make(chan any)
+	out2 := make(chan any)
+
+	go func() {
+		defer close(out1)
+		defer close(out2)
+
+		for val := range c.OrDone(ctx, in) {
+			var out1, out2 = out1, out2
+			for i := 0; i < 2; i++ {
+				select {
+				case <-ctx.Done():
+				case out1 <- val:
+					out1 = nil
+				case out2 <- val:
+					out2 = nil
+				}
+			}
+		}
+	}()
+
+	return out1, out2
+}
+
+// Bridge link multiply channels into one channel
+func (c *Channel) Bridge(ctx context.Context, chanStream <-chan <-chan any) <-chan any {
+	valStream := make(chan any)
+
+	go func() {
+		defer close(valStream)
+
+		for {
+			var stream <-chan any
+			select {
+			case maybeStream, ok := <-chanStream:
+				if ok == false {
+					return
+				}
+				stream = maybeStream
+			case <-ctx.Done():
+				return
+			}
+
+			for val := range c.OrDone(ctx, stream) {
+				select {
+				case valStream <- val:
+				case <-ctx.Done():
+				}
+			}
+		}
+	}()
+
+	return valStream
+}
+
+// Or read one or more channels into one channel, will close when any readin channel is closed
+func (c *Channel) Or(channels ...<-chan any) <-chan any {
+	switch len(channels) {
+	case 0:
+		return nil
+	case 1:
+		return channels[0]
+	}
+
+	orDone := make(chan any)
+
+	go func() {
+		defer close(orDone)
+
+		switch len(channels) {
+		case 2:
+			select {
+			case <-channels[0]:
+			case <-channels[1]:
+			}
+		default:
+			m := len(channels) / 2
+			select {
+			case <-c.Or(channels[:m]...):
+			case <-c.Or(channels[m:]...):
+			}
+			// select {
+			// case <-channels[0]:
+			// case <-channels[1]:
+			// case <-channels[2]:
+			// case <-c.Or(append(channels[3:], orDone)...):
+			// }
+		}
+	}()
+
+	return orDone
+}
+
+// OrDone read a channel into another channel, will close until cancel context.
+func (c *Channel) OrDone(ctx context.Context, channel <-chan any) <-chan any {
+	valStream := make(chan any)
+
+	go func() {
+		defer close(valStream)
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case v, ok := <-channel:
+				if !ok {
+					return
+				}
+				select {
+				case valStream <- v:
+				case <-ctx.Done():
+				}
+			}
+		}
+
+	}()
+
+	return valStream
+}
--- a/concurrency/channel_test.go
+++ b/concurrency/channel_test.go
@@ -0,0 +1,206 @@
+package concurrency
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestGenerate(t *testing.T) {
+	assert := internal.NewAssert(t, "TestGenerate")
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := NewChannel()
+	intStream := c.Generate(ctx, 1, 2, 3)
+
+	// for v := range intStream {
+	// 	t.Log(v) //1, 2, 3
+	// }
+	assert.Equal(1, <-intStream)
+	assert.Equal(2, <-intStream)
+	assert.Equal(3, <-intStream)
+}
+
+func TestRepeat(t *testing.T) {
+	assert := internal.NewAssert(t, "TestRepeat")
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := NewChannel()
+	intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 5)
+
+	// for v := range intStream {
+	// 	t.Log(v) //1, 2, 1, 2, 1
+	// }
+	assert.Equal(1, <-intStream)
+	assert.Equal(2, <-intStream)
+	assert.Equal(1, <-intStream)
+	assert.Equal(2, <-intStream)
+	assert.Equal(1, <-intStream)
+}
+
+func TestRepeatFn(t *testing.T) {
+	assert := internal.NewAssert(t, "TestRepeatFn")
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	fn := func() any {
+		s := "a"
+		return s
+	}
+	c := NewChannel()
+	dataStream := c.Take(ctx, c.RepeatFn(ctx, fn), 3)
+
+	// for v := range dataStream {
+	// 	t.Log(v) //a, a, a
+	// }
+
+	assert.Equal("a", <-dataStream)
+	assert.Equal("a", <-dataStream)
+	assert.Equal("a", <-dataStream)
+}
+
+func TestTake(t *testing.T) {
+	assert := internal.NewAssert(t, "TestTake")
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	numbers := make(chan any, 5)
+	numbers <- 1
+	numbers <- 2
+	numbers <- 3
+	numbers <- 4
+	numbers <- 5
+	defer close(numbers)
+
+	c := NewChannel()
+	intStream := c.Take(ctx, numbers, 3)
+
+	assert.Equal(1, <-intStream)
+	assert.Equal(2, <-intStream)
+	assert.Equal(3, <-intStream)
+}
+
+func TestFanIn(t *testing.T) {
+	assert := internal.NewAssert(t, "TestFanIn")
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := NewChannel()
+	channels := make([]<-chan any, 3)
+
+	for i := 0; i < 3; i++ {
+		channels[i] = c.Take(ctx, c.Repeat(ctx, i), 3)
+	}
+
+	mergedChannel := c.FanIn(ctx, channels...)
+
+	for val := range mergedChannel {
+		t.Logf("\t%d\n", val)
+	}
+
+	assert.Equal(1, 1)
+}
+
+func TestOr(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOr")
+
+	sig := func(after time.Duration) <-chan any {
+		c := make(chan interface{})
+		go func() {
+			defer close(c)
+			time.Sleep(after)
+		}()
+		return c
+	}
+
+	start := time.Now()
+
+	c := NewChannel()
+	<-c.Or(
+		sig(1*time.Second),
+		sig(2*time.Second),
+		sig(3*time.Second),
+		sig(4*time.Second),
+		sig(5*time.Second),
+	)
+
+	t.Logf("done after %v", time.Since(start))
+
+	assert.Equal(1, 1)
+}
+
+func TestOrDone(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOrDone")
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := NewChannel()
+	intStream := c.Take(ctx, c.Repeat(ctx, 1), 3)
+
+	var res any
+	for val := range c.OrDone(ctx, intStream) {
+		t.Logf("%v", val)
+		res = val
+	}
+
+	assert.Equal(1, res)
+}
+
+func TestTee(t *testing.T) {
+	assert := internal.NewAssert(t, "TestTee")
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := NewChannel()
+	inStream := c.Take(ctx, c.Repeat(ctx, 1), 4)
+
+	out1, out2 := c.Tee(ctx, inStream)
+	for val := range out1 {
+		val1 := val
+		val2 := <-out2
+		// t.Log("val1 is", val1)
+		// t.Log("val2 is", val2)
+		assert.Equal(1, val1)
+		assert.Equal(1, val2)
+	}
+}
+
+func TestBridge(t *testing.T) {
+	assert := internal.NewAssert(t, "TestBridge")
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := NewChannel()
+	genVals := func() <-chan <-chan any {
+		chanStream := make(chan (<-chan any))
+		go func() {
+			defer close(chanStream)
+			for i := 0; i < 10; i++ {
+				stream := make(chan any, 1)
+				stream <- i
+				close(stream)
+				chanStream <- stream
+			}
+		}()
+		return chanStream
+	}
+
+	index := 0
+	for val := range c.Bridge(ctx, genVals()) {
+		// t.Logf("%v ", val) //0 1 2 3 4 5 6 7 8 9
+		assert.Equal(index, val)
+		index++
+	}
+}
--- a/convertor/convertor.go
+++ b/convertor/convertor.go
@@ -6,9 +6,10 @@ package convertor

 import (
 	"bytes"
-	"encoding/gob"
+	"encoding/binary"
 	"encoding/json"
 	"fmt"
+	"math"
 	"reflect"
 	"regexp"
 	"strconv"
@@ -21,14 +22,44 @@ func ToBool(s string) (bool, error) {
 }

 // ToBytes convert interface to bytes
-func ToBytes(data interface{}) ([]byte, error) {
-	var buf bytes.Buffer
-	enc := gob.NewEncoder(&buf)
-	err := enc.Encode(data)
-	if err != nil {
-		return nil, err
+func ToBytes(value any) ([]byte, error) {
+	v := reflect.ValueOf(value)
+
+	switch value.(type) {
+	case int, int8, int16, int32, int64:
+		number := v.Int()
+		buf := bytes.NewBuffer([]byte{})
+		buf.Reset()
+		err := binary.Write(buf, binary.BigEndian, number)
+		return buf.Bytes(), err
+	case uint, uint8, uint16, uint32, uint64:
+		number := v.Uint()
+		buf := bytes.NewBuffer([]byte{})
+		buf.Reset()
+		err := binary.Write(buf, binary.BigEndian, number)
+		return buf.Bytes(), err
+	case float32:
+		number := float32(v.Float())
+		bits := math.Float32bits(number)
+		bytes := make([]byte, 4)
+		binary.BigEndian.PutUint32(bytes, bits)
+		return bytes, nil
+	case float64:
+		number := v.Float()
+		bits := math.Float64bits(number)
+		bytes := make([]byte, 8)
+		binary.BigEndian.PutUint64(bytes, bits)
+		return bytes, nil
+	case bool:
+		return strconv.AppendBool([]byte{}, v.Bool()), nil
+	case string:
+		return []byte(v.String()), nil
+	case []byte:
+		return v.Bytes(), nil
+	default:
+		newValue, err := json.Marshal(value)
+		return newValue, err
 	}
-	return buf.Bytes(), nil
 }

 // ToChar convert string to char slice
@@ -44,7 +75,7 @@ func ToChar(s string) []string {
 }

 // ToString convert value to string
-func ToString(value interface{}) string {
+func ToString(value any) string {
 	res := ""
 	if value == nil {
 		return res
@@ -76,7 +107,7 @@ func ToString(value interface{}) string {
 }

 // ToJson convert value to a valid json string
-func ToJson(value interface{}) (string, error) {
+func ToJson(value any) (string, error) {
 	res, err := json.Marshal(value)
 	if err != nil {
 		return "", err
@@ -86,7 +117,7 @@ func ToJson(value interface{}) (string, error) {
 }

 // ToFloat convert value to a float64, if input is not a float return 0.0 and error
-func ToFloat(value interface{}) (float64, error) {
+func ToFloat(value any) (float64, error) {
 	v := reflect.ValueOf(value)

 	res := 0.0
@@ -113,7 +144,7 @@ func ToFloat(value interface{}) (float64, error) {
 }

 // ToInt convert value to a int64, if input is not a numeric format return 0 and error
-func ToInt(value interface{}) (int64, error) {
+func ToInt(value any) (int64, error) {
 	v := reflect.ValueOf(value)

 	var res int64
@@ -141,7 +172,7 @@ func ToInt(value interface{}) (int64, error) {

 // StructToMap convert struct to map, only convert exported struct field
 // map key is specified same as struct field tag `json` value
-func StructToMap(value interface{}) (map[string]interface{}, error) {
+func StructToMap(value any) (map[string]any, error) {
 	v := reflect.ValueOf(value)
 	t := reflect.TypeOf(value)

@@ -152,7 +183,7 @@ func StructToMap(value interface{}) (map[string]interface{}, error) {
 		return nil, fmt.Errorf("data type %T not support, shuld be struct or pointer to struct", value)
 	}

-	res := make(map[string]interface{})
+	res := make(map[string]any)

 	fieldNum := t.NumField()
 	pattern := `^[A-Z]`
--- a/convertor/convertor_test.go
+++ b/convertor/convertor_test.go
@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"testing"

-	"github.com/duke-git/lancet/internal"
+	"github.com/duke-git/lancet/v2/internal"
 )

 func TestToChar(t *testing.T) {
@@ -36,26 +36,33 @@ func TestToBool(t *testing.T) {
 func TestToBytes(t *testing.T) {
 	assert := internal.NewAssert(t, "TestToBytes")

-	cases := []interface{}{
+	cases := []any{
 		0,
 		false,
 		"1",
 	}
 	expected := [][]byte{
-		{3, 4, 0, 0},
-		{3, 2, 0, 0},
-		{4, 12, 0, 1, 49},
+		{0, 0, 0, 0, 0, 0, 0, 0},
+		{102, 97, 108, 115, 101},
+		{49},
 	}
 	for i := 0; i < len(cases); i++ {
 		actual, _ := ToBytes(cases[i])
 		assert.Equal(expected[i], actual)
 	}
+
+	bytesData, err := ToBytes("abc")
+	if err != nil {
+		t.Error(err)
+		t.Fail()
+	}
+	assert.Equal("abc", ToString(bytesData))
 }

 func TestToInt(t *testing.T) {
 	assert := internal.NewAssert(t, "TestToInt")

-	cases := []interface{}{"123", "-123", 123,
+	cases := []any{"123", "-123", 123,
 		uint(123), uint8(123), uint16(123), uint32(123), uint64(123),
 		float32(12.3), float64(12.3),
 		"abc", false, "111111111111111111111111111111111111111"}
@@ -71,7 +78,7 @@ func TestToInt(t *testing.T) {
 func TestToFloat(t *testing.T) {
 	assert := internal.NewAssert(t, "TestToFloat")

-	cases := []interface{}{
+	cases := []any{
 		"", "-1", "-.11", "1.23e3", ".123e10", "abc",
 		int(0), int8(1), int16(-1), int32(123), int64(123),
 		uint(123), uint8(123), uint16(123), uint32(123), uint64(123),
@@ -99,7 +106,7 @@ func TestToString(t *testing.T) {
 	}
 	aStruct := TestStruct{Name: "TestStruct"}

-	cases := []interface{}{
+	cases := []any{
 		"", nil,
 		int(0), int8(1), int16(-1), int32(123), int64(123),
 		uint(123), uint8(123), uint16(123), uint32(123), uint64(123),
@@ -147,7 +154,7 @@ func TestStructToMap(t *testing.T) {
 		100,
 	}
 	pm, _ := StructToMap(p)
-	var expected = map[string]interface{}{"name": "test"}
+	var expected = map[string]any{"name": "test"}
 	assert.Equal(expected, pm)
 }

--- a/cryptor/aes_test.go
+++ b/cryptor/aes_test.go
@@ -3,7 +3,7 @@ package cryptor
 import (
 	"testing"

-	"github.com/duke-git/lancet/internal"
+	"github.com/duke-git/lancet/v2/internal"
 )

 func TestAesEcbEncrypt(t *testing.T) {
--- a/cryptor/basic_test.go
+++ b/cryptor/basic_test.go
@@ -3,7 +3,7 @@ package cryptor
 import (
 	"testing"

-	"github.com/duke-git/lancet/internal"
+	"github.com/duke-git/lancet/v2/internal"
 )

 func TestBase64StdEncode(t *testing.T) {
--- a/cryptor/des_test.go
+++ b/cryptor/des_test.go
@@ -3,7 +3,7 @@ package cryptor
 import (
 	"testing"

-	"github.com/duke-git/lancet/internal"
+	"github.com/duke-git/lancet/v2/internal"
 )

 func TestDesEcbEncrypt(t *testing.T) {
--- a/cryptor/rsa_test.go
+++ b/cryptor/rsa_test.go
@@ -3,7 +3,7 @@ package cryptor
 import (
 	"testing"

-	"github.com/duke-git/lancet/internal"
+	"github.com/duke-git/lancet/v2/internal"
 )

 func TestRsaEncrypt(t *testing.T) {
--- a/datastructure/link/doublylink.go
+++ b/datastructure/link/doublylink.go
@@ -0,0 +1,241 @@
+package datastructure
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/duke-git/lancet/v2/datastructure"
+)
+
+// DoublyLink is a linked list. Whose node has a generic Value, Pre pointer points to a previous node of the link, Next pointer points to a next node of the link.
+type DoublyLink[T any] struct {
+	Head   *datastructure.LinkNode[T]
+	length int
+}
+
+// NewDoublyLink return *DoublyLink instance
+func NewDoublyLink[T any]() *DoublyLink[T] {
+	return &DoublyLink[T]{Head: nil}
+}
+
+// InsertAtHead insert value into doubly linklist at head index
+func (link *DoublyLink[T]) InsertAtHead(value T) {
+	newNode := datastructure.NewLinkNode(value)
+	size := link.Size()
+
+	if size == 0 {
+		link.Head = newNode
+		link.length++
+		return
+	}
+
+	newNode.Next = link.Head
+	newNode.Pre = nil
+
+	link.Head.Pre = newNode
+	link.Head = newNode
+
+	link.length++
+}
+
+// InsertAtTail insert value into doubly linklist at tail index
+func (link *DoublyLink[T]) InsertAtTail(value T) {
+	current := link.Head
+	if current == nil {
+		link.InsertAtHead(value)
+		return
+	}
+
+	for current.Next != nil {
+		current = current.Next
+	}
+
+	newNode := datastructure.NewLinkNode(value)
+	newNode.Next = nil
+	newNode.Pre = current
+	current.Next = newNode
+
+	link.length++
+}
+
+// InsertAt insert value into doubly linklist at index
+func (link *DoublyLink[T]) InsertAt(index int, value T) error {
+	size := link.length
+	if index < 0 || index > size {
+		return errors.New("param index should between 0 and the length of doubly link.")
+	}
+
+	if index == 0 {
+		link.InsertAtHead(value)
+		return nil
+	}
+
+	if index == size {
+		link.InsertAtTail(value)
+		return nil
+	}
+
+	i := 0
+	current := link.Head
+
+	for current != nil {
+		if i == index-1 {
+			newNode := datastructure.NewLinkNode(value)
+			newNode.Next = current.Next
+			newNode.Pre = current
+
+			current.Next = newNode
+			link.length++
+
+			return nil
+		}
+		i++
+		current = current.Next
+	}
+
+	return errors.New("doubly link list no exist")
+}
+
+// DeleteAtHead delete value in doubly linklist at head index
+func (link *DoublyLink[T]) DeleteAtHead() error {
+	if link.Head == nil {
+		return errors.New("doubly link list no exist")
+	}
+	current := link.Head
+	link.Head = current.Next
+	link.Head.Pre = nil
+	link.length--
+
+	return nil
+}
+
+// DeleteAtTail delete value in doubly linklist at tail index
+func (link *DoublyLink[T]) DeleteAtTail() error {
+	if link.Head == nil {
+		return errors.New("doubly link list no exist")
+	}
+	current := link.Head
+	if current.Next == nil {
+		return link.DeleteAtHead()
+	}
+
+	for current.Next.Next != nil {
+		current = current.Next
+	}
+
+	current.Next = nil
+	link.length--
+	return nil
+}
+
+// DeleteAt delete value in doubly linklist at index
+func (link *DoublyLink[T]) DeleteAt(index int) error {
+	if link.Head == nil {
+		return errors.New("doubly link list no exist")
+	}
+	current := link.Head
+	if current.Next == nil || index == 0 {
+		return link.DeleteAtHead()
+	}
+
+	if index == link.length-1 {
+		return link.DeleteAtTail()
+	}
+
+	if index < 0 || index > link.length-1 {
+		return errors.New("param index should between 0 and link size -1.")
+	}
+
+	i := 0
+	for current != nil {
+		if i == index-1 {
+			current.Next = current.Next.Next
+			link.length--
+			return nil
+		}
+		i++
+		current = current.Next
+	}
+
+	return errors.New("delete error")
+}
+
+// Reverse the linked list
+func (link *DoublyLink[T]) Reverse() {
+	current := link.Head
+	var temp *datastructure.LinkNode[T]
+
+	for current != nil {
+		temp = current.Pre
+		current.Pre = current.Next
+		current.Next = temp
+		current = current.Pre
+	}
+
+	if temp != nil {
+		link.Head = temp.Pre
+	}
+}
+
+// GetMiddleNode return node at middle index of linked list
+func (link *DoublyLink[T]) GetMiddleNode() *datastructure.LinkNode[T] {
+	if link.Head == nil {
+		return nil
+	}
+	if link.Head.Next == nil {
+		return link.Head
+	}
+	fast := link.Head
+	slow := link.Head
+
+	for fast != nil {
+		fast = fast.Next
+
+		if fast != nil {
+			fast = fast.Next
+			slow = slow.Next
+		} else {
+			return slow
+		}
+	}
+	return slow
+}
+
+// Size return the count of doubly linked list
+func (link *DoublyLink[T]) Size() int {
+	return link.length
+}
+
+// Values return slice of all doubly linklist node value
+func (link *DoublyLink[T]) Values() []T {
+	res := []T{}
+	current := link.Head
+	for current != nil {
+		res = append(res, current.Value)
+		current = current.Next
+	}
+	return res
+}
+
+// Print all nodes info of a linked list
+func (link *DoublyLink[T]) Print() {
+	current := link.Head
+	info := "[ "
+	for current != nil {
+		info += fmt.Sprintf("%+v, ", current)
+		current = current.Next
+	}
+	info += " ]"
+	fmt.Println(info)
+}
+
+// IsEmpty checks if link is empty or not
+func (link *DoublyLink[T]) IsEmpty() bool {
+	return link.length == 0
+}
+
+// Clear all nodes in doubly linklist
+func (link *DoublyLink[T]) Clear() {
+	link.Head = nil
+	link.length = 0
+}
--- a/datastructure/link/doublylink_test.go
+++ b/datastructure/link/doublylink_test.go
@@ -0,0 +1,179 @@
+package datastructure
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestDoublyLink_InsertAtFirst(t *testing.T) {
+	assert := internal.NewAssert(t, "TestDoublyLink_InsertAtFirst")
+
+	link := NewDoublyLink[int]()
+	link.InsertAtHead(1)
+	link.InsertAtHead(2)
+	link.InsertAtHead(3)
+	link.Print()
+
+	expected := []int{3, 2, 1}
+	values := link.Values()
+
+	assert.Equal(expected, values)
+}
+
+func TestDoublyLink_InsertAtTail(t *testing.T) {
+	assert := internal.NewAssert(t, "TestDoublyLink_InsertAtTail")
+
+	link := NewDoublyLink[int]()
+	link.InsertAtTail(1)
+	link.InsertAtTail(2)
+	link.InsertAtTail(3)
+	link.Print()
+
+	expected := []int{1, 2, 3}
+	values := link.Values()
+
+	assert.Equal(expected, values)
+}
+
+func TestDoublyLink_InsertAt(t *testing.T) {
+	assert := internal.NewAssert(t, "TestDoublyLink_InsertAt")
+
+	link := NewDoublyLink[int]()
+
+	err := link.InsertAt(1, 1)
+	assert.IsNotNil(err)
+
+	link.InsertAt(0, 1)
+	link.InsertAt(1, 2)
+	link.InsertAt(2, 4)
+	link.InsertAt(2, 3)
+
+	link.Print()
+
+	expected := []int{1, 2, 3, 4}
+	values := link.Values()
+
+	assert.Equal(expected, values)
+
+}
+
+func TestDoublyLink_DeleteAtHead(t *testing.T) {
+	assert := internal.NewAssert(t, "TestDoublyLink_DeleteAtHead")
+
+	link := NewDoublyLink[int]()
+	err := link.DeleteAtHead()
+	assert.IsNotNil(err)
+
+	link.InsertAtTail(1)
+	link.InsertAtTail(2)
+	link.InsertAtTail(3)
+	link.InsertAtTail(4)
+
+	link.DeleteAtHead()
+	link.Print()
+
+	expected := []int{2, 3, 4}
+	values := link.Values()
+
+	assert.Equal(expected, values)
+}
+
+func TestDoublyLink_DeleteAtTail(t *testing.T) {
+	assert := internal.NewAssert(t, "TestDoublyLink_DeleteAtTail")
+
+	link := NewDoublyLink[int]()
+	err := link.DeleteAtTail()
+	assert.IsNotNil(err)
+
+	link.InsertAtTail(1)
+	link.InsertAtTail(2)
+	link.InsertAtTail(3)
+	link.InsertAtTail(4)
+
+	link.DeleteAtTail()
+	link.Print()
+
+	expected := []int{1, 2, 3}
+	values := link.Values()
+
+	assert.Equal(expected, values)
+}
+
+func TestDoublyLink_DeleteAt(t *testing.T) {
+	assert := internal.NewAssert(t, "TestDoublyLink_DeleteAt")
+
+	link := NewDoublyLink[int]()
+	err := link.DeleteAt(0)
+	assert.IsNotNil(err)
+
+	link.InsertAtTail(1)
+	link.InsertAtTail(2)
+	link.InsertAtTail(3)
+	link.InsertAtTail(4)
+	link.InsertAtTail(5)
+
+	err = link.DeleteAt(5)
+	assert.IsNotNil(err)
+
+	err = link.DeleteAt(0)
+	assert.IsNil(err)
+	assert.Equal([]int{2, 3, 4, 5}, link.Values())
+
+	link.DeleteAt(3)
+	assert.Equal([]int{2, 3, 4}, link.Values())
+
+	link.DeleteAt(1)
+	assert.Equal(2, link.Size())
+	assert.Equal([]int{2, 4}, link.Values())
+}
+
+func TestDoublyLink_Reverse(t *testing.T) {
+	assert := internal.NewAssert(t, "TestDoublyLink_Reverse")
+
+	link := NewDoublyLink[int]()
+	link.InsertAtTail(1)
+	link.InsertAtTail(2)
+	link.InsertAtTail(3)
+	link.InsertAtTail(4)
+
+	link.Reverse()
+	link.Print()
+	assert.Equal([]int{4, 3, 2, 1}, link.Values())
+}
+
+func TestDoublyLink_GetMiddleNode(t *testing.T) {
+	assert := internal.NewAssert(t, "TestDoublyLink_GetMiddleNode")
+
+	link := NewDoublyLink[int]()
+	link.InsertAtTail(1)
+	link.InsertAtTail(2)
+	link.InsertAtTail(3)
+	link.InsertAtTail(4)
+
+	middle1 := link.GetMiddleNode()
+	assert.Equal(3, middle1.Value)
+
+	link.InsertAtTail(5)
+	link.InsertAtTail(6)
+	link.InsertAtTail(7)
+	middle2 := link.GetMiddleNode()
+	assert.Equal(4, middle2.Value)
+}
+
+func TestDoublyLink_Clear(t *testing.T) {
+	assert := internal.NewAssert(t, "TestDoublyLink_Clear")
+
+	link := NewDoublyLink[int]()
+
+	assert.Equal(true, link.IsEmpty())
+	assert.Equal(0, link.Size())
+
+	link.InsertAtTail(1)
+	assert.Equal(false, link.IsEmpty())
+	assert.Equal(1, link.Size())
+
+	link.Clear()
+	assert.Equal(true, link.IsEmpty())
+	assert.Equal(0, link.Size())
+}
--- a/datastructure/link/singlylink.go
+++ b/datastructure/link/singlylink.go
@@ -0,0 +1,246 @@
+package datastructure
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+
+	"github.com/duke-git/lancet/v2/datastructure"
+)
+
+// SinglyLink is a linked list. Whose node has a Value generics and Next pointer points to a next node of the link.
+type SinglyLink[T any] struct {
+	Head   *datastructure.LinkNode[T]
+	length int
+}
+
+// NewSinglyLink return *SinglyLink instance
+func NewSinglyLink[T any]() *SinglyLink[T] {
+	return &SinglyLink[T]{Head: nil}
+}
+
+// InsertAtHead insert value into singly linklist at head index
+func (link *SinglyLink[T]) InsertAtHead(value T) {
+	newNode := datastructure.NewLinkNode(value)
+	newNode.Next = link.Head
+	link.Head = newNode
+	link.length++
+}
+
+// InsertAtTail insert value into singly linklist at tail index
+func (link *SinglyLink[T]) InsertAtTail(value T) {
+	current := link.Head
+	if current == nil {
+		link.InsertAtHead(value)
+		return
+	}
+
+	for current.Next != nil {
+		current = current.Next
+	}
+
+	newNode := datastructure.NewLinkNode(value)
+	newNode.Next = nil
+	current.Next = newNode
+
+	link.length++
+}
+
+// InsertAt insert value into singly linklist at index
+func (link *SinglyLink[T]) InsertAt(index int, value T) error {
+	size := link.length
+	if index < 0 || index > size {
+		return errors.New("param index should between 0 and the length of singly link.")
+	}
+
+	if index == 0 {
+		link.InsertAtHead(value)
+		return nil
+	}
+
+	if index == size {
+		link.InsertAtTail(value)
+		return nil
+	}
+
+	i := 0
+	current := link.Head
+
+	for current != nil {
+		if i == index-1 {
+			newNode := datastructure.NewLinkNode(value)
+			newNode.Next = current.Next
+			current.Next = newNode
+			link.length++
+
+			return nil
+		}
+		i++
+		current = current.Next
+	}
+
+	return errors.New("singly link list no exist")
+}
+
+// DeleteAtHead delete value in singly linklist at head index
+func (link *SinglyLink[T]) DeleteAtHead() error {
+	if link.Head == nil {
+		return errors.New("singly link list no exist")
+	}
+	current := link.Head
+	link.Head = current.Next
+	link.length--
+
+	return nil
+}
+
+// DeleteAtTail delete value in singly linklist at tail index
+func (link *SinglyLink[T]) DeleteAtTail() error {
+	if link.Head == nil {
+		return errors.New("singly link list no exist")
+	}
+	current := link.Head
+	if current.Next == nil {
+		return link.DeleteAtHead()
+	}
+
+	for current.Next.Next != nil {
+		current = current.Next
+	}
+
+	current.Next = nil
+	link.length--
+	return nil
+}
+
+// DeleteAt delete value in singly linklist at index
+func (link *SinglyLink[T]) DeleteAt(index int) error {
+	if link.Head == nil {
+		return errors.New("singly link list no exist")
+	}
+	current := link.Head
+	if current.Next == nil || index == 0 {
+		return link.DeleteAtHead()
+	}
+
+	if index == link.length-1 {
+		return link.DeleteAtTail()
+	}
+
+	if index < 0 || index > link.length-1 {
+		return errors.New("param index should between 0 and link size -1.")
+	}
+
+	i := 0
+	for current != nil {
+		if i == index-1 {
+			current.Next = current.Next.Next
+			link.length--
+			return nil
+		}
+		i++
+		current = current.Next
+	}
+
+	return errors.New("delete error")
+}
+
+// DeleteValue delete value in singly linklist
+func (link *SinglyLink[T]) DeleteValue(value T) {
+	if link.Head == nil {
+		return
+	}
+	dummyHead := datastructure.NewLinkNode(value)
+	dummyHead.Next = link.Head
+	current := dummyHead
+
+	for current.Next != nil {
+		if reflect.DeepEqual(current.Next.Value, value) {
+			current.Next = current.Next.Next
+			link.length--
+		} else {
+			current = current.Next
+		}
+	}
+
+	link.Head = dummyHead.Next
+}
+
+// Reverse the linked list
+func (link *SinglyLink[T]) Reverse() {
+	var pre, next *datastructure.LinkNode[T]
+
+	current := link.Head
+
+	for current != nil {
+		next = current.Next
+		current.Next = pre
+		pre = current
+		current = next
+	}
+
+	link.Head = pre
+}
+
+// GetMiddleNode return node at middle index of linked list
+func (link *SinglyLink[T]) GetMiddleNode() *datastructure.LinkNode[T] {
+	if link.Head == nil {
+		return nil
+	}
+	if link.Head.Next == nil {
+		return link.Head
+	}
+	fast := link.Head
+	slow := link.Head
+
+	for fast != nil {
+		fast = fast.Next
+
+		if fast != nil {
+			fast = fast.Next
+			slow = slow.Next
+		} else {
+			return slow
+		}
+	}
+	return slow
+}
+
+// Size return the count of singly linked list
+func (link *SinglyLink[T]) Size() int {
+	return link.length
+}
+
+// Values return slice of all singly linklist node value
+func (link *SinglyLink[T]) Values() []T {
+	res := []T{}
+	current := link.Head
+	for current != nil {
+		res = append(res, current.Value)
+		current = current.Next
+	}
+	return res
+}
+
+// IsEmpty checks if link is empty or not
+func (link *SinglyLink[T]) IsEmpty() bool {
+	return link.length == 0
+}
+
+// Clear all the node in singly linklist
+func (link *SinglyLink[T]) Clear() {
+	link.Head = nil
+	link.length = 0
+}
+
+// Print all nodes info of a linked list
+func (link *SinglyLink[T]) Print() {
+	current := link.Head
+	info := "[ "
+	for current != nil {
+		info += fmt.Sprintf("%+v, ", current)
+		current = current.Next
+	}
+	info += " ]"
+	fmt.Println(info)
+}
--- a/datastructure/link/singlylink_test.go
+++ b/datastructure/link/singlylink_test.go
@@ -0,0 +1,208 @@
+package datastructure
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestSinglyLink_InsertAtFirst(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSinglyLink_InsertAtFirst")
+
+	link := NewSinglyLink[int]()
+	link.InsertAtHead(1)
+	link.InsertAtHead(2)
+	link.InsertAtHead(3)
+	link.Print()
+
+	expected := []int{3, 2, 1}
+	values := link.Values()
+
+	assert.Equal(expected, values)
+}
+
+func TestSinglyLink_InsertAtTail(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSinglyLink_InsertAtTail")
+
+	link := NewSinglyLink[int]()
+	link.InsertAtTail(1)
+	link.InsertAtTail(2)
+	link.InsertAtTail(3)
+	link.Print()
+
+	expected := []int{1, 2, 3}
+	values := link.Values()
+
+	assert.Equal(expected, values)
+}
+
+func TestSinglyLink_InsertAt(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSinglyLink_InsertAt")
+
+	link := NewSinglyLink[int]()
+
+	err := link.InsertAt(1, 1)
+	assert.IsNotNil(err)
+
+	err = link.InsertAt(0, 1)
+	if err != nil {
+		t.FailNow()
+	}
+	err = link.InsertAt(1, 2)
+	if err != nil {
+		t.FailNow()
+	}
+	err = link.InsertAt(2, 4)
+	if err != nil {
+		t.FailNow()
+	}
+	err = link.InsertAt(2, 3)
+	if err != nil {
+		t.FailNow()
+	}
+
+	link.Print()
+
+	expected := []int{1, 2, 3, 4}
+	values := link.Values()
+
+	assert.Equal(expected, values)
+}
+
+func TestSinglyLink_DeleteAtHead(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSinglyLink_DeleteAtHead")
+
+	link := NewSinglyLink[int]()
+	err := link.DeleteAtHead()
+	assert.IsNotNil(err)
+
+	link.InsertAtTail(1)
+	link.InsertAtTail(2)
+	link.InsertAtTail(3)
+	link.InsertAtTail(4)
+
+	link.DeleteAtHead()
+	link.Print()
+
+	expected := []int{2, 3, 4}
+	values := link.Values()
+
+	assert.Equal(expected, values)
+}
+
+func TestSinglyLink_DeleteAtTail(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSinglyLink_DeleteAtTail")
+
+	link := NewSinglyLink[int]()
+	err := link.DeleteAtTail()
+	assert.IsNotNil(err)
+
+	link.InsertAtTail(1)
+	link.InsertAtTail(2)
+	link.InsertAtTail(3)
+	link.InsertAtTail(4)
+
+	link.DeleteAtTail()
+	link.Print()
+
+	expected := []int{1, 2, 3}
+	values := link.Values()
+
+	assert.Equal(expected, values)
+}
+
+func TestSinglyLink_DeleteValue(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSinglyLink_DeleteValue")
+
+	link := NewSinglyLink[int]()
+
+	link.InsertAtTail(1)
+	link.InsertAtTail(2)
+	link.InsertAtTail(2)
+	link.InsertAtTail(3)
+	link.InsertAtTail(4)
+
+	link.DeleteValue(2)
+	assert.Equal([]int{1, 3, 4}, link.Values())
+
+	link.DeleteValue(1)
+	assert.Equal([]int{3, 4}, link.Values())
+}
+
+func TestSinglyLink_DeleteAt(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSinglyLink_DeleteAt")
+
+	link := NewSinglyLink[int]()
+	err := link.DeleteAt(0)
+	assert.IsNotNil(err)
+
+	link.InsertAtTail(1)
+	link.InsertAtTail(2)
+	link.InsertAtTail(3)
+	link.InsertAtTail(4)
+	link.InsertAtTail(5)
+
+	err = link.DeleteAt(5)
+	assert.IsNotNil(err)
+
+	err = link.DeleteAt(0)
+	assert.IsNil(err)
+	assert.Equal([]int{2, 3, 4, 5}, link.Values())
+
+	link.DeleteAt(3)
+	assert.Equal([]int{2, 3, 4}, link.Values())
+
+	link.DeleteAt(1)
+	assert.Equal(2, link.Size())
+	assert.Equal([]int{2, 4}, link.Values())
+}
+
+func TestSinglyLink_Reverse(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSinglyLink_Reverse")
+
+	link := NewSinglyLink[int]()
+	link.InsertAtTail(1)
+	link.InsertAtTail(2)
+	link.InsertAtTail(3)
+	link.InsertAtTail(4)
+
+	link.Reverse()
+	link.Print()
+	assert.Equal([]int{4, 3, 2, 1}, link.Values())
+}
+
+func TestSinglyLink_GetMiddleNode(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSinglyLink_GetMiddleNode")
+
+	link := NewSinglyLink[int]()
+	link.InsertAtTail(1)
+	link.InsertAtTail(2)
+	link.InsertAtTail(3)
+	link.InsertAtTail(4)
+
+	middle1 := link.GetMiddleNode()
+	assert.Equal(3, middle1.Value)
+
+	link.InsertAtTail(5)
+	link.InsertAtTail(6)
+	link.InsertAtTail(7)
+	middle2 := link.GetMiddleNode()
+	assert.Equal(4, middle2.Value)
+}
+
+func TestSinglyLink_Clear(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSinglyLink_Clear")
+
+	link := NewSinglyLink[int]()
+
+	assert.Equal(true, link.IsEmpty())
+	assert.Equal(0, link.Size())
+
+	link.InsertAtTail(1)
+	assert.Equal(false, link.IsEmpty())
+	assert.Equal(1, link.Size())
+
+	link.Clear()
+	assert.Equal(true, link.IsEmpty())
+	assert.Equal(0, link.Size())
+}
--- a/datastructure/list/list.go
+++ b/datastructure/list/list.go
@@ -0,0 +1,245 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package datastructure implements some data structure. eg. list, linklist, stack, queue, tree, graph.
+package datastructure
+
+import (
+	"reflect"
+)
+
+// List is a linear table, implemented with slice
+type List[T any] struct {
+	data []T
+}
+
+// NewList return a pointer of List
+func NewList[T any](data []T) *List[T] {
+	return &List[T]{data: data}
+}
+
+// Data return list data
+func (l *List[T]) Data() []T {
+	return l.data
+}
+
+// ValueOf return the value pointer at index of list data.
+func (l *List[T]) ValueOf(index int) (*T, bool) {
+	if index < 0 || index >= len(l.data) {
+		return nil, false
+	}
+	return &l.data[index], true
+}
+
+// IndexOf reture the index of value. if not found return -1
+func (l *List[T]) IndexOf(value T) int {
+	index := -1
+	data := l.data
+	for i, v := range data {
+		if reflect.DeepEqual(v, value) {
+			index = i
+			break
+		}
+	}
+	return index
+}
+
+// Contain checks if the value in the list or not
+func (l *List[T]) Contain(value T) bool {
+	data := l.data
+	for _, v := range data {
+		if reflect.DeepEqual(v, value) {
+			return true
+		}
+	}
+	return false
+}
+
+// Push append value to the list data
+func (l *List[T]) Push(value T) {
+	l.data = append(l.data, value)
+}
+
+// InsertAtFirst insert value into list at first index
+func (l *List[T]) InsertAtFirst(value T) {
+	l.InsertAt(0, value)
+}
+
+// InsertAtLast insert value into list at last index
+func (l *List[T]) InsertAtLast(value T) {
+	l.InsertAt(len(l.data), value)
+}
+
+// InsertAt insert value into list at index
+func (l *List[T]) InsertAt(index int, value T) {
+	data := l.data
+	size := len(data)
+
+	if index < 0 || index > size {
+		return
+	}
+	l.data = append(data[:index], append([]T{value}, data[index:]...)...)
+}
+
+// PopFirst delete the first value of list and return it
+func (l *List[T]) PopFirst() (*T, bool) {
+	if len(l.data) == 0 {
+		return nil, false
+	}
+
+	v := l.data[0]
+	l.DeleteAt(0)
+
+	return &v, true
+}
+
+// PopLast delete the last value of list and return it
+func (l *List[T]) PopLast() (*T, bool) {
+	size := len(l.data)
+	if size == 0 {
+		return nil, false
+	}
+
+	v := l.data[size-1]
+	l.DeleteAt(size - 1)
+
+	return &v, true
+}
+
+// DeleteAt delete the value of list at index
+func (l *List[T]) DeleteAt(index int) {
+	data := l.data
+	size := len(data)
+	if index < 0 || index > size-1 {
+		return
+	}
+	if index == size-1 {
+		data = append(data[:index])
+	} else {
+		data = append(data[:index], data[index+1:]...)
+	}
+	l.data = data
+}
+
+// UpdateAt update value of list at index, index shoud between 0 and list size -1
+func (l *List[T]) UpdateAt(index int, value T) {
+	data := l.data
+	size := len(data)
+
+	if index < 0 || index >= size {
+		return
+	}
+	l.data = append(data[:index], append([]T{value}, data[index+1:]...)...)
+}
+
+// Equal compare list to other list, use reflect.DeepEqual
+func (l *List[T]) Equal(other *List[T]) bool {
+	if len(l.data) != len(other.data) {
+		return false
+	}
+
+	for i := 0; i < len(l.data); i++ {
+		if !reflect.DeepEqual(l.data[i], other.data[i]) {
+			return false
+		}
+	}
+
+	return true
+}
+
+// IsEmpty check if the list is empty or not
+func (l *List[T]) IsEmpty() bool {
+	return len(l.data) == 0
+}
+
+// Clear the data of list
+func (l *List[T]) Clear() {
+	l.data = make([]T, 0, 0)
+}
+
+// Clone return a copy of list
+func (l *List[T]) Clone() *List[T] {
+	cl := NewList(make([]T, len(l.data)))
+	copy(cl.data, l.data)
+
+	return cl
+}
+
+// Merge two list, return new list, don't change original list
+func (l *List[T]) Merge(other *List[T]) *List[T] {
+	l1, l2 := len(l.data), len(other.data)
+	ml := NewList(make([]T, l1+l2, l1+l2))
+
+	data := append([]T{}, append(l.data, other.data...)...)
+	ml.data = data
+
+	return ml
+}
+
+// Size return number of list data items
+func (l *List[T]) Size() int {
+	return len(l.data)
+}
+
+// Swap the value of index i and j in list
+func (l *List[T]) Swap(i, j int) {
+	size := len(l.data)
+	if i < 0 || i >= size || j < 0 || j >= size {
+		return
+	}
+	l.data[i], l.data[j] = l.data[j], l.data[i]
+}
+
+// Reverse the item order of list
+func (l *List[T]) Reverse() {
+	for i, j := 0, len(l.data)-1; i < j; i, j = i+1, j-1 {
+		l.data[i], l.data[j] = l.data[j], l.data[i]
+	}
+}
+
+// Unique remove duplicate items in list
+func (l *List[T]) Unique() {
+	data := l.data
+	size := len(data)
+
+	uniqueData := make([]T, 0, 0)
+	for i := 0; i < size; i++ {
+		value := data[i]
+		skip := true
+		for _, v := range uniqueData {
+			if reflect.DeepEqual(value, v) {
+				skip = false
+				break
+			}
+		}
+		if skip {
+			uniqueData = append(uniqueData, value)
+		}
+	}
+
+	l.data = uniqueData
+}
+
+// Union creates a new list contain all element in list l and other, remove duplicate element.
+func (l *List[T]) Union(other *List[T]) *List[T] {
+	res := NewList([]T{})
+
+	res.data = append(res.data, l.data...)
+	res.data = append(res.data, other.data...)
+	res.Unique()
+
+	return res
+}
+
+// Intersection creates a new list whose element both be contained in list l and other
+func (l *List[T]) Intersection(other *List[T]) *List[T] {
+	res := NewList(make([]T, 0, 0))
+
+	for _, v := range l.data {
+		if other.Contain(v) {
+			res.data = append(res.data, v)
+		}
+	}
+
+	return res
+}
--- a/datastructure/list/list_test.go
+++ b/datastructure/list/list_test.go
@@ -0,0 +1,272 @@
+package datastructure
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestListData(t *testing.T) {
+	assert := internal.NewAssert(t, "TestListData")
+
+	list := NewList([]int{1, 2, 3})
+	assert.Equal([]int{1, 2, 3}, list.Data())
+}
+
+func TestValueOf(t *testing.T) {
+	assert := internal.NewAssert(t, "TestValueOf")
+
+	list := NewList([]int{1, 2, 3})
+	v, ok := list.ValueOf(0)
+	assert.Equal(1, *v)
+	assert.Equal(true, ok)
+
+	_, ok = list.ValueOf(3)
+	assert.Equal(false, ok)
+}
+
+func TestIndexOf(t *testing.T) {
+	assert := internal.NewAssert(t, "TestIndexOf")
+
+	list := NewList([]int{1, 2, 3})
+	i := list.IndexOf(1)
+	assert.Equal(0, i)
+
+	i = list.IndexOf(4)
+	assert.Equal(-1, i)
+}
+
+func TestContain(t *testing.T) {
+	assert := internal.NewAssert(t, "TestContain")
+
+	list := NewList([]int{1, 2, 3})
+	assert.Equal(true, list.Contain(1))
+	assert.Equal(false, list.Contain(0))
+}
+
+func TestPush(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPush")
+
+	list := NewList([]int{1, 2, 3})
+	list.Push(4)
+
+	assert.Equal([]int{1, 2, 3, 4}, list.Data())
+}
+
+func TestInsertAtFirst(t *testing.T) {
+	assert := internal.NewAssert(t, "TestInsertAtFirst")
+
+	list := NewList([]int{1, 2, 3})
+	list.InsertAtFirst(0)
+
+	assert.Equal([]int{0, 1, 2, 3}, list.Data())
+}
+
+func TestInsertAtLast(t *testing.T) {
+	assert := internal.NewAssert(t, "TestInsertAtLast")
+
+	list := NewList([]int{1, 2, 3})
+	list.InsertAtLast(4)
+
+	assert.Equal([]int{1, 2, 3, 4}, list.Data())
+}
+
+func TestInsertAt(t *testing.T) {
+	assert := internal.NewAssert(t, "TestInsertAt")
+
+	list := NewList([]int{1, 2, 3})
+
+	list.InsertAt(-1, 0)
+	assert.Equal([]int{1, 2, 3}, list.Data())
+
+	list.InsertAt(4, 0)
+	assert.Equal([]int{1, 2, 3}, list.Data())
+
+	list.InsertAt(0, 0)
+	assert.Equal([]int{0, 1, 2, 3}, list.Data())
+
+	list.InsertAt(4, 4)
+	assert.Equal([]int{0, 1, 2, 3, 4}, list.Data())
+}
+
+func TestPopFirst(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPopFirst")
+
+	list := NewList([]int{1, 2, 3})
+	v, ok := list.PopFirst()
+	assert.Equal(1, *v)
+	assert.Equal(true, ok)
+	assert.Equal([]int{2, 3}, list.Data())
+
+	list2 := NewList([]int{})
+	_, ok = list2.PopFirst()
+	assert.Equal(false, ok)
+	assert.Equal([]int{}, list2.Data())
+}
+
+func TestPopLast(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPopLast")
+
+	list := NewList([]int{1, 2, 3})
+	v, ok := list.PopLast()
+	assert.Equal(3, *v)
+	assert.Equal(true, ok)
+	assert.Equal([]int{1, 2}, list.Data())
+
+	list2 := NewList([]int{})
+	_, ok = list2.PopLast()
+	assert.Equal(false, ok)
+	assert.Equal([]int{}, list2.Data())
+}
+
+func TestDeleteAt(t *testing.T) {
+	assert := internal.NewAssert(t, "TestDeleteAt")
+
+	list := NewList([]int{1, 2, 3, 4})
+
+	list.DeleteAt(-1)
+	assert.Equal([]int{1, 2, 3, 4}, list.Data())
+
+	list.DeleteAt(4)
+	assert.Equal([]int{1, 2, 3, 4}, list.Data())
+
+	list.DeleteAt(0)
+	assert.Equal([]int{2, 3, 4}, list.Data())
+
+	list.DeleteAt(2)
+	assert.Equal([]int{2, 3}, list.Data())
+}
+
+func TestUpdateAt(t *testing.T) {
+	assert := internal.NewAssert(t, "TestUpdateAt")
+
+	list := NewList([]int{1, 2, 3, 4})
+
+	list.UpdateAt(-1, 0)
+	assert.Equal([]int{1, 2, 3, 4}, list.Data())
+
+	list.UpdateAt(4, 0)
+	assert.Equal([]int{1, 2, 3, 4}, list.Data())
+
+	list.UpdateAt(0, 5)
+	assert.Equal([]int{5, 2, 3, 4}, list.Data())
+
+	list.UpdateAt(3, 1)
+	assert.Equal([]int{5, 2, 3, 1}, list.Data())
+}
+
+func TestEqual(t *testing.T) {
+	assert := internal.NewAssert(t, "TestEqual")
+
+	list1 := NewList([]int{1, 2, 3, 4})
+	list2 := NewList([]int{1, 2, 3, 4})
+	list3 := NewList([]int{1, 2, 3})
+
+	assert.Equal(true, list1.Equal(list2))
+	assert.Equal(false, list1.Equal(list3))
+}
+
+func TestIsEmpty(t *testing.T) {
+	assert := internal.NewAssert(t, "TestIsEmpty")
+
+	list1 := NewList([]int{1, 2, 3, 4})
+	list2 := NewList([]int{})
+
+	assert.Equal(false, list1.IsEmpty())
+	assert.Equal(true, list2.IsEmpty())
+}
+
+func TestIsClear(t *testing.T) {
+	assert := internal.NewAssert(t, "TestIsClear")
+
+	list1 := NewList([]int{1, 2, 3, 4})
+	list1.Clear()
+	empty := NewList([]int{})
+
+	assert.Equal(empty, list1)
+}
+
+func TestClone(t *testing.T) {
+	assert := internal.NewAssert(t, "TestClone")
+
+	list1 := NewList([]int{1, 2, 3, 4})
+	list2 := list1.Clone()
+
+	assert.Equal(true, list1.Equal(list2))
+}
+
+func TestMerge(t *testing.T) {
+	assert := internal.NewAssert(t, "TestMerge")
+
+	list1 := NewList([]int{1, 2, 3, 4})
+	list2 := NewList([]int{4, 5, 6})
+	expected := NewList([]int{1, 2, 3, 4, 4, 5, 6})
+
+	list3 := list1.Merge(list2)
+	assert.Equal(true, expected.Equal(list3))
+}
+
+func TestSize(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSize")
+
+	list := NewList([]int{1, 2, 3, 4})
+	empty := NewList([]int{})
+
+	assert.Equal(4, list.Size())
+	assert.Equal(0, empty.Size())
+}
+
+func TestSwap(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSwap")
+
+	list := NewList([]int{1, 2, 3, 4})
+	expected := NewList([]int{4, 2, 3, 1})
+
+	list.Swap(0, 3)
+
+	assert.Equal(true, expected.Equal(list))
+}
+
+func TestReverse(t *testing.T) {
+	assert := internal.NewAssert(t, "TestReverse")
+
+	list := NewList([]int{1, 2, 3, 4})
+	expected := NewList([]int{4, 3, 2, 1})
+
+	list.Reverse()
+
+	assert.Equal(true, expected.Equal(list))
+}
+
+func TestUnique(t *testing.T) {
+	assert := internal.NewAssert(t, "TestUnique")
+
+	list := NewList([]int{1, 2, 2, 3, 4})
+	expected := NewList([]int{1, 2, 3, 4})
+
+	list.Unique()
+
+	assert.Equal(true, expected.Equal(list))
+}
+
+func TestUnion(t *testing.T) {
+	assert := internal.NewAssert(t, "TestUnion")
+
+	list1 := NewList([]int{1, 2, 3, 4})
+	list2 := NewList([]int{4, 5, 6})
+	expected := NewList([]int{1, 2, 3, 4, 5, 6})
+
+	list3 := list1.Union(list2)
+	assert.Equal(true, expected.Equal(list3))
+}
+
+func TestIntersection(t *testing.T) {
+	assert := internal.NewAssert(t, "TestIntersection")
+
+	list1 := NewList([]int{1, 2, 3, 4})
+	list2 := NewList([]int{4, 5, 6})
+	expected := NewList([]int{4})
+
+	list3 := list1.Intersection(list2)
+	assert.Equal(true, expected.Equal(list3))
+}
--- a/datastructure/node.go
+++ b/datastructure/node.go
@@ -0,0 +1,51 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package datastructure implements some data structure. eg. list, linklist, stack, queue, tree, graph.
+package datastructure
+
+// LinkNode is a linkedlist node, which have a Value and Pre points to previous node, Next points to a next node of the link.
+type LinkNode[T any] struct {
+	Value T
+	Pre   *LinkNode[T]
+	Next  *LinkNode[T]
+}
+
+// NewLinkNode return a LinkNode pointer
+func NewLinkNode[T any](value T) *LinkNode[T] {
+	return &LinkNode[T]{value, nil, nil}
+}
+
+// StackNode is a node in stack, which have a Value and Next pointer points to next node in the stack.
+type StackNode[T any] struct {
+	Value T
+	Next  *StackNode[T]
+}
+
+// NewStackNode return a StackNode pointer
+func NewStackNode[T any](value T) *StackNode[T] {
+	return &StackNode[T]{value, nil}
+}
+
+// QueueNode is a node in a queue, which have a Value and Next pointer points to next node in the queue.
+type QueueNode[T any] struct {
+	Value T
+	Next  *QueueNode[T]
+}
+
+// NewQueueNode return a QueueNode pointer
+func NewQueueNode[T any](value T) *QueueNode[T] {
+	return &QueueNode[T]{value, nil}
+}
+
+// TreeNode is node of tree
+type TreeNode[T any] struct {
+	Value T
+	Left  *TreeNode[T]
+	Right *TreeNode[T]
+}
+
+// NewTreeNode return a TreeNode pointer
+func NewTreeNode[T any](val T) *TreeNode[T] {
+	return &TreeNode[T]{val, nil, nil}
+}
--- a/datastructure/queue/arrayqueue.go
+++ b/datastructure/queue/arrayqueue.go
@@ -0,0 +1,119 @@
+package datastructure
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// ArrayQueue implements queue with slice
+type ArrayQueue[T any] struct {
+	items    []T
+	head     int
+	tail     int
+	capacity int
+	size     int
+}
+
+func NewArrayQueue[T any](capacity int) *ArrayQueue[T] {
+	return &ArrayQueue[T]{
+		items:    make([]T, 0, capacity),
+		head:     0,
+		tail:     0,
+		capacity: capacity,
+		size:     0,
+	}
+}
+
+// Data return slice of queue data
+func (q *ArrayQueue[T]) Data() []T {
+	items := []T{}
+	for i := q.head; i < q.tail; i++ {
+		items = append(items, q.items[i])
+	}
+	return items
+}
+
+// Size return number of elements in queue
+func (q *ArrayQueue[T]) Size() int {
+	return q.size
+}
+
+// IsEmpty checks if queue is empty or not
+func (q *ArrayQueue[T]) IsEmpty() bool {
+	return q.size == 0
+}
+
+// IsFull checks if queue is full or not
+func (q *ArrayQueue[T]) IsFull() bool {
+	return q.size == q.capacity
+}
+
+// Front return front value of queue
+func (q *ArrayQueue[T]) Front() T {
+	return q.items[0]
+}
+
+// Back return back value of queue
+func (q *ArrayQueue[T]) Back() T {
+	return q.items[q.size-1]
+}
+
+// EnQueue put element into queue
+func (q *ArrayQueue[T]) Enqueue(item T) bool {
+	if q.head == 0 && q.tail == q.capacity {
+		return false
+	} else if q.head != 0 && q.tail == q.capacity {
+		for i := q.head; i < q.tail; i++ {
+			q.items[i-q.head] = q.items[i]
+		}
+		q.tail = q.tail - q.head
+		q.head = 0
+	}
+
+	q.items = append(q.items, item)
+	q.tail++
+	q.size++
+	return true
+}
+
+// DeQueue remove head element of queue and return it, if queue is empty, return nil and error
+func (q *ArrayQueue[T]) Dequeue() (T, bool) {
+	var item T
+	if q.head == q.tail {
+		return item, false
+	}
+	item = q.items[q.head]
+	q.head++
+	q.size--
+	return item, true
+}
+
+// Clear the queue data
+func (q *ArrayQueue[T]) Clear() {
+	capacity := q.capacity
+	q.items = make([]T, 0, capacity)
+	q.head = 0
+	q.tail = 0
+	q.size = 0
+	q.capacity = capacity
+}
+
+// Contain checks if the value is in queue or not
+func (q *ArrayQueue[T]) Contain(value T) bool {
+	for _, v := range q.items {
+		if reflect.DeepEqual(v, value) {
+			return true
+		}
+	}
+	return false
+}
+
+// Print queue data
+func (q *ArrayQueue[T]) Print() {
+	info := "["
+	for i := q.head; i < q.tail; i++ {
+		info += fmt.Sprintf("%+v, ", q.items[i])
+	}
+	info += "]"
+	fmt.Println(info)
+}
--- a/datastructure/queue/arrayqueue_test.go
+++ b/datastructure/queue/arrayqueue_test.go
@@ -0,0 +1,113 @@
+package datastructure
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestArrayQueue_Enqueue(t *testing.T) {
+	assert := internal.NewAssert(t, "TestArrayQueue_Enqueue")
+
+	queue := NewArrayQueue[int](5)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+
+	expected := []int{1, 2, 3}
+	data := queue.Data()
+	size := queue.Size()
+
+	queue.Print()
+
+	assert.Equal(expected, data)
+	assert.Equal(3, size)
+}
+
+func TestArrayQueue_Dequeue(t *testing.T) {
+	assert := internal.NewAssert(t, "TestArrayQueue_Dequeue")
+
+	queue := NewArrayQueue[int](4)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+
+	val, ok := queue.Dequeue()
+	assert.Equal(true, ok)
+
+	queue.Print()
+	assert.Equal(1, val)
+	assert.Equal([]int{2, 3}, queue.Data())
+}
+
+func TestArrayQueue_Front(t *testing.T) {
+	assert := internal.NewAssert(t, "TestArrayQueue_Front")
+
+	queue := NewArrayQueue[int](4)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+
+	val := queue.Front()
+
+	queue.Print()
+
+	assert.Equal(1, val)
+	assert.Equal([]int{1, 2, 3}, queue.Data())
+}
+
+func TestArrayQueue_Back(t *testing.T) {
+	assert := internal.NewAssert(t, "TestArrayQueue_Back")
+
+	queue := NewArrayQueue[int](4)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+
+	val := queue.Back()
+
+	queue.Print()
+
+	assert.Equal(3, val)
+	assert.Equal([]int{1, 2, 3}, queue.Data())
+}
+
+func TestArrayQueue_Contain(t *testing.T) {
+	assert := internal.NewAssert(t, "TestArrayQueue_Contain")
+
+	queue := NewArrayQueue[int](4)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+
+	assert.Equal(true, queue.Contain(1))
+	assert.Equal(false, queue.Contain(4))
+}
+
+func TestArrayQueue_Clear(t *testing.T) {
+	assert := internal.NewAssert(t, "TestArrayQueue_Clear")
+
+	queue := NewArrayQueue[int](4)
+
+	assert.Equal(true, queue.IsEmpty())
+	assert.Equal(0, queue.Size())
+
+	queue.Enqueue(1)
+	assert.Equal(false, queue.IsEmpty())
+	assert.Equal(1, queue.Size())
+
+	queue.Clear()
+	assert.Equal(true, queue.IsEmpty())
+	assert.Equal(0, queue.Size())
+}
+
+func TestArrayQueue_IsFull(t *testing.T) {
+	assert := internal.NewAssert(t, "TestArrayQueue_IsFull")
+
+	queue := NewArrayQueue[int](3)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+
+	assert.Equal(true, queue.IsFull())
+}
--- a/datastructure/queue/circularqueue.go
+++ b/datastructure/queue/circularqueue.go
@@ -0,0 +1,118 @@
+package datastructure
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+// CircularQueue implements circular queue with slice,
+// last index of CircularQueue don't contain value, so acturl capacity is capacity - 1
+type CircularQueue[T any] struct {
+	data     []T
+	front    int
+	rear     int
+	capacity int
+}
+
+// NewCircularQueue return a empty CircularQueue pointer
+func NewCircularQueue[T any](capacity int) *CircularQueue[T] {
+	data := make([]T, capacity)
+	return &CircularQueue[T]{data: data, front: 0, rear: 0, capacity: capacity}
+}
+
+// Data return slice of queue data
+func (q *CircularQueue[T]) Data() []T {
+	data := []T{}
+
+	front := q.front
+	rear := q.rear
+	if front <= rear {
+		return q.data[front:rear]
+	}
+
+	data = append(data, q.data[front:]...)
+	data = append(data, q.data[0:rear]...)
+
+	return data
+}
+
+// Size return number of elements in circular queue
+func (q *CircularQueue[T]) Size() int {
+	if q.capacity == 0 {
+		return 0
+	}
+	return (q.rear - q.front + q.capacity) % q.capacity
+}
+
+// IsEmpty checks if queue is empty or not
+func (q *CircularQueue[T]) IsEmpty() bool {
+	return q.front == q.rear
+}
+
+// IsFull checks if queue is full or not
+func (q *CircularQueue[T]) IsFull() bool {
+	return (q.rear+1)%q.capacity == q.front
+}
+
+// Front return front value of queue
+func (q *CircularQueue[T]) Front() T {
+	return q.data[q.front]
+}
+
+// Back return back value of queue
+func (q *CircularQueue[T]) Back() T {
+	if q.rear-1 >= 0 {
+		return q.data[q.rear-1]
+	}
+	return q.data[q.capacity-1]
+}
+
+// Enqueue put element into queue
+func (q *CircularQueue[T]) Enqueue(value T) error {
+	if q.IsFull() {
+		return errors.New("queue is full!")
+	}
+
+	q.data[q.rear] = value
+	q.rear = (q.rear + 1) % q.capacity
+
+	return nil
+}
+
+// Dequeue remove head element of queue and return it, if queue is empty, return nil and error
+func (q *CircularQueue[T]) Dequeue() (*T, error) {
+	if q.IsEmpty() {
+		return nil, errors.New("queue is empty")
+	}
+
+	headItem := q.data[q.front]
+	var t T
+	q.data[q.front] = t
+	q.front = (q.front + 1) % q.capacity
+
+	return &headItem, nil
+}
+
+// Clear the queue data
+func (q *CircularQueue[T]) Clear() {
+	q.data = []T{}
+	q.front = 0
+	q.rear = 0
+	q.capacity = 0
+}
+
+// Contain checks if the value is in queue or not
+func (q *CircularQueue[T]) Contain(value T) bool {
+	for _, v := range q.data {
+		if reflect.DeepEqual(v, value) {
+			return true
+		}
+	}
+	return false
+}
+
+// Print queue data
+func (q *CircularQueue[T]) Print() {
+	fmt.Printf("%+v\n", q)
+}
--- a/datastructure/queue/circularqueue_test.go
+++ b/datastructure/queue/circularqueue_test.go
@@ -0,0 +1,148 @@
+package datastructure
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestCircularQueue_Enqueue(t *testing.T) {
+	assert := internal.NewAssert(t, "TestCircularQueue_Enqueue")
+
+	queue := NewCircularQueue[int](6)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+	queue.Enqueue(4)
+	queue.Enqueue(5)
+
+	queue.Print()
+	assert.Equal([]int{1, 2, 3, 4, 5}, queue.Data())
+	assert.Equal(5, queue.Size())
+
+	err := queue.Enqueue(6)
+	assert.IsNotNil(err)
+}
+
+func TestCircularQueue_Dequeue(t *testing.T) {
+	assert := internal.NewAssert(t, "TestCircularQueue_DeQueue")
+
+	queue := NewCircularQueue[int](6)
+	assert.Equal(true, queue.IsEmpty())
+
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+	queue.Enqueue(4)
+	queue.Enqueue(5)
+
+	val, err := queue.Dequeue()
+	assert.IsNil(err)
+
+	assert.Equal(1, *val)
+	assert.Equal(false, queue.IsFull())
+
+	val, _ = queue.Dequeue()
+	queue.Print()
+	assert.Equal(2, *val)
+
+	queue.Enqueue(6)
+	queue.Print()
+	assert.Equal(false, queue.IsFull())
+}
+
+func TestCircularQueue_Front(t *testing.T) {
+	assert := internal.NewAssert(t, "TestCircularQueue_Front")
+
+	queue := NewCircularQueue[int](6)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+	queue.Enqueue(4)
+	queue.Enqueue(5)
+
+	queue.Print()
+
+	queue.Dequeue()
+	queue.Dequeue()
+	queue.Enqueue(6)
+	queue.Enqueue(7)
+
+	queue.Print()
+
+	val := queue.Front()
+	assert.Equal(3, val)
+	assert.Equal(5, queue.Size())
+}
+
+func TestCircularQueue_Back(t *testing.T) {
+	assert := internal.NewAssert(t, "TestCircularQueue_Back")
+
+	queue := NewCircularQueue[int](6)
+	assert.Equal(true, queue.IsEmpty())
+
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+	queue.Enqueue(4)
+	queue.Enqueue(5)
+
+	queue.Print()
+	assert.Equal(5, queue.Back())
+
+	queue.Dequeue()
+	queue.Dequeue()
+	queue.Enqueue(6)
+	queue.Enqueue(7)
+
+	queue.Print()
+	assert.Equal(7, queue.Back())
+}
+
+func TestCircularQueue_Contain(t *testing.T) {
+	assert := internal.NewAssert(t, "TestCircularQueue_Contain")
+
+	queue := NewCircularQueue[int](2)
+	queue.Enqueue(1)
+	assert.Equal(true, queue.Contain(1))
+	assert.Equal(false, queue.Contain(2))
+}
+
+func TestCircularQueue_Clear(t *testing.T) {
+	assert := internal.NewAssert(t, "TestCircularQueue_Clear")
+
+	queue := NewCircularQueue[int](3)
+	assert.Equal(true, queue.IsEmpty())
+	assert.Equal(0, queue.Size())
+
+	queue.Enqueue(1)
+	assert.Equal(false, queue.IsEmpty())
+	assert.Equal(1, queue.Size())
+
+	queue.Clear()
+	assert.Equal(true, queue.IsEmpty())
+	assert.Equal(0, queue.Size())
+}
+
+func TestCircularQueue_Data(t *testing.T) {
+	assert := internal.NewAssert(t, "TestCircularQueue_Data")
+
+	queue := NewCircularQueue[int](6)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+	queue.Enqueue(4)
+	queue.Enqueue(5)
+
+	queue.Print()
+	assert.Equal([]int{1, 2, 3, 4, 5}, queue.Data())
+
+	queue.Dequeue()
+	queue.Dequeue()
+	queue.Enqueue(6)
+	queue.Enqueue(7)
+
+	queue.Print()
+	assert.Equal([]int{3, 4, 5, 6, 7}, queue.Data())
+
+}
--- a/datastructure/queue/linkedqueue.go
+++ b/datastructure/queue/linkedqueue.go
@@ -0,0 +1,117 @@
+package datastructure
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+
+	"github.com/duke-git/lancet/v2/datastructure"
+)
+
+// LinkedQueue implements queue with link list
+type LinkedQueue[T any] struct {
+	head   *datastructure.QueueNode[T]
+	tail   *datastructure.QueueNode[T]
+	length int
+}
+
+// NewLinkedQueue return a empty LinkedQueue pointer
+func NewLinkedQueue[T any]() *LinkedQueue[T] {
+	return &LinkedQueue[T]{head: nil, tail: nil, length: 0}
+}
+
+// Data return slice of queue data
+func (q *LinkedQueue[T]) Data() []T {
+	res := []T{}
+	current := q.head
+
+	for current != nil {
+		res = append(res, current.Value)
+		current = current.Next
+	}
+	return res
+}
+
+// Size return length of queue data
+func (q *LinkedQueue[T]) Size() int {
+	return q.length
+}
+
+// IsEmpty checks if queue is empty or not
+func (q *LinkedQueue[T]) IsEmpty() bool {
+	return q.length == 0
+}
+
+// Enqueue put element into queue
+func (q *LinkedQueue[T]) Enqueue(value T) {
+	newNode := datastructure.NewQueueNode(value)
+
+	if q.IsEmpty() {
+		q.head = newNode
+		q.tail = newNode
+	} else {
+		q.tail.Next = newNode
+		q.tail = newNode
+	}
+	q.length++
+}
+
+// Dequeue delete head element of queue then return it, if queue is empty, return nil and error
+func (q *LinkedQueue[T]) Dequeue() (*T, error) {
+	if q.IsEmpty() {
+		return nil, errors.New("queue is empty")
+	}
+
+	head := q.head
+	q.head = q.head.Next
+	q.length--
+
+	return &head.Value, nil
+}
+
+// Front return front value of queue
+func (q *LinkedQueue[T]) Front() (*T, error) {
+	if q.IsEmpty() {
+		return nil, errors.New("queue is empty")
+	}
+	return &q.head.Value, nil
+}
+
+// Back return back value of queue
+func (q *LinkedQueue[T]) Back() (*T, error) {
+	if q.IsEmpty() {
+		return nil, errors.New("queue is empty")
+	}
+	return &q.tail.Value, nil
+}
+
+// Clear clear the queue data
+func (q *LinkedQueue[T]) Clear() {
+	q.head = nil
+	q.tail = nil
+	q.length = 0
+}
+
+// Print all nodes info of queue link
+func (q *LinkedQueue[T]) Print() {
+	current := q.head
+	info := "[ "
+	for current != nil {
+		info += fmt.Sprintf("%+v, ", current)
+		current = current.Next
+	}
+	info += " ]"
+	fmt.Println(info)
+}
+
+// Contain checks if the value is in queue or not
+func (q *LinkedQueue[T]) Contain(value T) bool {
+	current := q.head
+	for current != nil {
+		if reflect.DeepEqual(current.Value, value) {
+			return true
+		}
+		current = current.Next
+	}
+	return false
+}
--- a/datastructure/queue/linkedqueue_test.go
+++ b/datastructure/queue/linkedqueue_test.go
@@ -0,0 +1,97 @@
+package datastructure
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestLinkedQueue_Enqueue(t *testing.T) {
+	assert := internal.NewAssert(t, "TestLinkedQueue_Enqueue")
+
+	queue := NewLinkedQueue[int]()
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+
+	queue.Print()
+
+	assert.Equal([]int{1, 2, 3}, queue.Data())
+	assert.Equal(3, queue.Size())
+}
+
+func TestLinkedQueue_Dequeue(t *testing.T) {
+	assert := internal.NewAssert(t, "TestLinkedQueue_DeQueue")
+
+	queue := NewLinkedQueue[int]()
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+
+	val, _ := queue.Dequeue()
+
+	queue.Print()
+
+	assert.Equal([]int{2, 3}, queue.Data())
+	assert.Equal(1, *val)
+}
+
+func TestLinkedQueue_Front(t *testing.T) {
+	assert := internal.NewAssert(t, "TestLinkedQueue_Front")
+
+	queue := NewLinkedQueue[int]()
+	_, err := queue.Front()
+	assert.IsNotNil(err)
+
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+
+	val, err := queue.Front()
+	assert.Equal(1, *val)
+	assert.IsNil(err)
+}
+
+func TestLinkedQueue_Back(t *testing.T) {
+	assert := internal.NewAssert(t, "TestLinkedQueue_Back")
+
+	queue := NewLinkedQueue[int]()
+	_, err := queue.Back()
+	assert.IsNotNil(err)
+
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+
+	val, err := queue.Back()
+	assert.Equal(3, *val)
+	assert.IsNil(err)
+}
+
+func TestLinkedQueue_Clear(t *testing.T) {
+	assert := internal.NewAssert(t, "TestLinkedQueue_Back")
+
+	queue := NewLinkedQueue[int]()
+	assert.Equal(true, queue.IsEmpty())
+
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+	assert.Equal(false, queue.IsEmpty())
+
+	queue.Clear()
+	assert.Equal(true, queue.IsEmpty())
+}
+
+func TestLinkedQueue_Contain(t *testing.T) {
+	assert := internal.NewAssert(t, "TestLinkedQueue_Contain")
+
+	queue := NewLinkedQueue[int]()
+
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+
+	assert.Equal(true, queue.Contain(1))
+	assert.Equal(false, queue.Contain(4))
+}
--- a/datastructure/queue/priorityqueue.go
+++ b/datastructure/queue/priorityqueue.go
@@ -0,0 +1,113 @@
+package datastructure
+
+import (
+	"errors"
+
+	"github.com/duke-git/lancet/v2/lancetconstraints"
+)
+
+// PriorityQueue is a priority queue implemented by binary heap tree
+// type T should implements Compare function in lancetconstraints.Comparator interface.
+type PriorityQueue[T any] struct {
+	items      []T
+	size       int
+	comparator lancetconstraints.Comparator
+}
+
+// NewPriorityQueue return a pointer of PriorityQueue
+// param `comparator` is used to compare values in the queue
+func NewPriorityQueue[T any](capacity int, comparator lancetconstraints.Comparator) *PriorityQueue[T] {
+	return &PriorityQueue[T]{
+		items:      make([]T, capacity+1),
+		size:       0,
+		comparator: comparator,
+	}
+}
+
+// IsEmpty checks if the queue is empty or not
+func (q *PriorityQueue[T]) IsEmpty() bool {
+	return q.size == 0
+}
+
+// Size get number of items in the queue
+func (q *PriorityQueue[T]) Size() int {
+	return q.size
+}
+
+// IsFull checks if the queue capacity is full or not
+func (q *PriorityQueue[T]) IsFull() bool {
+	return q.size == len(q.items)-1
+}
+
+// Data return a slice of queue data
+func (q *PriorityQueue[T]) Data() []T {
+	data := make([]T, q.size)
+	for i := 1; i < q.size+1; i++ {
+		data[i-1] = q.items[i]
+	}
+
+	return data
+}
+
+// Enqueue insert value into queue
+func (q *PriorityQueue[T]) Enqueue(val T) error {
+	if q.IsFull() {
+		return errors.New("queue is already full.")
+	}
+	q.size++
+	q.items[q.size] = val
+	q.swim(q.size)
+	return nil
+}
+
+// Dequeue delete and return max value in queue
+func (q *PriorityQueue[T]) Dequeue() (T, bool) {
+	var val T
+	if q.IsEmpty() {
+		return val, false
+	}
+
+	max := q.items[1]
+
+	q.swap(1, q.size)
+	q.size--
+	q.sink(1)
+
+	//set zero value for rest values of the queue
+	q.items[q.size+1] = val
+
+	return max, true
+}
+
+// swim when child's key is larger than parent's key, exchange them.
+func (q *PriorityQueue[T]) swim(index int) {
+	for index > 1 && q.comparator.Compare(q.items[index/2], q.items[index]) < 0 {
+		q.swap(index, index/2)
+		index = index / 2
+	}
+}
+
+// sink when parent's key smaller than child's key, exchange parent's key with larger child's key.
+func (q *PriorityQueue[T]) sink(index int) {
+
+	for 2*index <= q.size {
+		j := 2 * index
+
+		// get larger child node index
+		if j < q.size && q.comparator.Compare(q.items[j], q.items[j+1]) < 0 {
+			j++
+		}
+		// if parent larger than child, stop
+		if !(q.comparator.Compare(q.items[index], q.items[j]) < 0) {
+			break
+		}
+
+		q.swap(index, j)
+		index = j
+	}
+}
+
+// swap the two values at index i and j
+func (q *PriorityQueue[T]) swap(i, j int) {
+	q.items[i], q.items[j] = q.items[j], q.items[i]
+}
--- a/datastructure/queue/priorityqueue_test.go
+++ b/datastructure/queue/priorityqueue_test.go
@@ -0,0 +1,64 @@
+package datastructure
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+func TestPriorityQueue_Enqueue(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPriorityQueue_Enqueue")
+
+	comparator := &intComparator{}
+	pq := NewPriorityQueue[int](10, comparator)
+
+	assert.Equal(true, pq.IsEmpty())
+	assert.Equal(false, pq.IsFull())
+
+	for i := 1; i < 11; i++ {
+		pq.Enqueue(i)
+	}
+
+	assert.Equal(true, pq.IsFull())
+
+	queueData := pq.Data()
+	assert.Equal([]int{10, 9, 6, 7, 8, 2, 5, 1, 4, 3}, queueData)
+
+}
+
+func TestPriorityQueue_Dequeue(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPriorityQueue_Dequeue")
+
+	comparator := &intComparator{}
+	pq := NewPriorityQueue[int](10, comparator)
+
+	_, ok := pq.Dequeue()
+	assert.Equal(false, ok)
+
+	for i := 1; i < 11; i++ {
+		pq.Enqueue(i)
+	}
+
+	assert.Equal(10, pq.Size())
+
+	val, ok := pq.Dequeue()
+	assert.Equal(true, ok)
+	assert.Equal(10, val)
+
+	assert.Equal([]int{9, 8, 6, 7, 3, 2, 5, 1, 4}, pq.Data())
+
+	assert.Equal(9, pq.Size())
+}
--- a/datastructure/set/set.go
+++ b/datastructure/set/set.go
@@ -0,0 +1,136 @@
+package datastructure
+
+// Set is a data container, like slice, but element of set is not duplicate
+type Set[T comparable] map[T]bool
+
+// NewSet return a instance of set
+func NewSet[T comparable](values ...T) Set[T] {
+	set := make(Set[T])
+	set.Add(values...)
+	return set
+}
+
+// Add value to set
+func (s Set[T]) Add(values ...T) {
+	for _, v := range values {
+		s[v] = true
+	}
+}
+
+// Contain checks if set contains value or not
+func (s Set[T]) Contain(value T) bool {
+	_, ok := s[value]
+	return ok
+}
+
+// ContainAll checks if set contains other set
+func (s Set[T]) ContainAll(other Set[T]) bool {
+	for k := range other {
+		_, ok := s[k]
+		if !ok {
+			return false
+		}
+	}
+	return true
+}
+
+// Clone return a copy of set
+func (s Set[T]) Clone() Set[T] {
+	set := NewSet[T]()
+	set.Add(s.Values()...)
+	return set
+}
+
+// Delete value of set
+func (s Set[T]) Delete(values ...T) {
+	for _, v := range values {
+		delete(s, v)
+	}
+}
+
+// Equal checks if two set has same elements or not
+func (s Set[T]) Equal(other Set[T]) bool {
+	if s.Size() != other.Size() {
+		return false
+	}
+
+	return s.ContainAll(other) && other.ContainAll(s)
+}
+
+// Iterate call function by every element of set
+func (s Set[T]) Iterate(fn func(value T)) {
+	for v := range s {
+		fn(v)
+	}
+}
+
+// IsEmpty checks the set is empty or not
+func (s Set[T]) IsEmpty() bool {
+	return len(s) == 0
+}
+
+// Size get the number of elements in set
+func (s Set[T]) Size() int {
+	return len(s)
+}
+
+// Values return all values of set
+func (s Set[T]) Values() []T {
+	values := make([]T, 0, 0)
+
+	s.Iterate(func(value T) {
+		values = append(values, value)
+	})
+
+	return values
+}
+
+// Union creates a new set contain all element of set s and other
+func (s Set[T]) Union(other Set[T]) Set[T] {
+	set := s.Clone()
+	set.Add(other.Values()...)
+	return set
+}
+
+// Intersection creates a new set whose element both be contained in set s and other
+func (s Set[T]) Intersection(other Set[T]) Set[T] {
+	set := NewSet[T]()
+	s.Iterate(func(value T) {
+		if other.Contain(value) {
+			set.Add(value)
+		}
+	})
+
+	return set
+}
+
+// SymmetricDifference creates a new set whose element is in set1 or set2, but not in both sets
+func (s Set[T]) SymmetricDifference(other Set[T]) Set[T] {
+	set := NewSet[T]()
+	s.Iterate(func(value T) {
+		if !other.Contain(value) {
+			set.Add(value)
+		}
+	})
+
+	other.Iterate(func(value T) {
+		if !s.Contain(value) {
+			set.Add(value)
+		}
+	})
+
+	return set
+}
+
+// Minus creates an set of whose element in origin set but not in compared set
+func (s Set[T]) Minus(comparedSet Set[T]) Set[T] {
+	set := NewSet[T]()
+
+	s.Iterate(func(value T) {
+		if !comparedSet.Contain(value) {
+			set.Add(value)
+		}
+	})
+
+	return set
+}
--- a/datastructure/set/set_test.go
+++ b/datastructure/set/set_test.go
@@ -0,0 +1,149 @@
+package datastructure
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestSet_Add(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSet_Add")
+
+	set := NewSet[int]()
+	set.Add(1, 2, 3)
+
+	expected := NewSet(1, 2, 3)
+
+	assert.Equal(true, set.Equal(expected))
+}
+
+func TestSet_Contain(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSet_Contain")
+
+	set := NewSet[int]()
+	set.Add(1, 2, 3)
+
+	assert.Equal(true, set.Contain(1))
+	assert.Equal(false, set.Contain(4))
+}
+
+func TestSet_ContainAll(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSet_ContainAll")
+
+	set1 := NewSet(1, 2, 3)
+	set2 := NewSet(1, 2)
+	set3 := NewSet(1, 2, 3, 4)
+
+	assert.Equal(true, set1.ContainAll(set2))
+	assert.Equal(false, set1.ContainAll(set3))
+}
+
+func TestSet_Clone(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSet_Clone")
+
+	set1 := NewSet(1, 2, 3)
+	set2 := set1.Clone()
+
+	assert.Equal(true, set1.Size() == set2.Size())
+	assert.Equal(true, set1.ContainAll(set2))
+}
+
+func TestSet_Delete(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSet_Delete")
+
+	set := NewSet[int]()
+	set.Add(1, 2, 3)
+	set.Delete(3)
+
+	expected := NewSet(1, 2)
+
+	assert.Equal(true, set.Equal(expected))
+}
+
+func TestSet_Equal(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSet_Equal")
+
+	set1 := NewSet(1, 2, 3)
+	set2 := NewSet(1, 2, 3)
+	set3 := NewSet(1, 2, 3, 4)
+
+	assert.Equal(true, set1.Equal(set2))
+	assert.Equal(false, set1.Equal(set3))
+}
+
+func TestSet_Iterate(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSet_Iterate")
+
+	set := NewSet(1, 2, 3)
+	arr := []int{}
+	set.Iterate(func(value int) {
+		arr = append(arr, value)
+	})
+
+	assert.Equal(3, len(arr))
+}
+
+func TestSet_IsEmpty(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSet_IsEmpty")
+
+	set := NewSet[int]()
+	assert.Equal(true, set.IsEmpty())
+}
+
+func TestSet_Size(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSet_Size")
+
+	set := NewSet(1, 2, 3)
+	assert.Equal(3, set.Size())
+}
+
+func TestSet_Values(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSet_Values")
+
+	set := NewSet(1, 2, 3)
+	values := set.Values()
+
+	assert.Equal(3, len(values))
+}
+
+func TestSet_Union(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSet_Union")
+
+	set1 := NewSet(1, 2, 3)
+	set2 := NewSet(2, 3, 4, 5)
+	expected := NewSet(1, 2, 3, 4, 5)
+	unionSet := set1.Union(set2)
+
+	assert.Equal(expected, unionSet)
+}
+
+func TestSet_Intersection(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSet_Intersection")
+
+	set1 := NewSet(1, 2, 3)
+	set2 := NewSet(2, 3, 4, 5)
+	expected := NewSet(2, 3)
+	intersectionSet := set1.Intersection(set2)
+
+	assert.Equal(expected, intersectionSet)
+}
+
+func TestSet_SymmetricDifference(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSet_SymmetricDifference")
+
+	set1 := NewSet(1, 2, 3)
+	set2 := NewSet(2, 3, 4, 5)
+
+	assert.Equal(NewSet(1, 4, 5), set1.SymmetricDifference(set2))
+}
+
+func TestSet_Minus(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSet_Minus")
+
+	set1 := NewSet(1, 2, 3)
+	set2 := NewSet(2, 3, 4, 5)
+	set3 := NewSet(2, 3)
+
+	assert.Equal(NewSet(1), set1.Minus(set2))
+	assert.Equal(NewSet(4, 5), set2.Minus(set3))
+}
--- a/datastructure/stack/arraystack.go
+++ b/datastructure/stack/arraystack.go
@@ -0,0 +1,62 @@
+package datastructure
+
+import "errors"
+
+// ArrayStack implements stack with slice
+type ArrayStack[T any] struct {
+	data   []T
+	length int
+}
+
+// NewArrayStack return a empty ArrayStack pointer
+func NewArrayStack[T any]() *ArrayStack[T] {
+	return &ArrayStack[T]{data: []T{}, length: 0}
+}
+
+// Data return stack data
+func (s *ArrayStack[T]) Data() []T {
+	return s.data
+}
+
+// Size return length of stack data
+func (s *ArrayStack[T]) Size() int {
+	return s.length
+}
+
+// IsEmpty checks if stack is empty or not
+func (s *ArrayStack[T]) IsEmpty() bool {
+	return s.length == 0
+}
+
+// Push element into stack
+func (s *ArrayStack[T]) Push(value T) {
+	s.data = append([]T{value}, s.data...)
+	s.length++
+}
+
+// Pop delete the top element of stack then return it, if stack is empty, return nil and error
+func (s *ArrayStack[T]) Pop() (*T, error) {
+	if s.IsEmpty() {
+		return nil, errors.New("stack is empty")
+	}
+
+	topItem := s.data[0]
+	s.data = s.data[1:]
+	s.length--
+
+	return &topItem, nil
+}
+
+// Peak return the top element of stack
+func (s *ArrayStack[T]) Peak() (*T, error) {
+	if s.IsEmpty() {
+		return nil, errors.New("stack is empty")
+	}
+	return &s.data[0], nil
+}
+
+// Clear the stack data
+func (s *ArrayStack[T]) Clear() {
+	s.data = []T{}
+	s.length = 0
+}
--- a/datastructure/stack/arraystack_test.go
+++ b/datastructure/stack/arraystack_test.go
@@ -0,0 +1,77 @@
+package datastructure
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestArrayStack_Push(t *testing.T) {
+	assert := internal.NewAssert(t, "TestArrayStack_Push")
+
+	stack := NewArrayStack[int]()
+	stack.Push(1)
+	stack.Push(2)
+	stack.Push(3)
+
+	expected := []int{3, 2, 1}
+	values := stack.Data()
+	length := stack.Size()
+
+	assert.Equal(expected, values)
+	assert.Equal(3, length)
+}
+
+func TestArrayStack_Pop(t *testing.T) {
+	assert := internal.NewAssert(t, "TestArrayStack_Pop")
+
+	stack := NewArrayStack[int]()
+	_, err := stack.Pop()
+	assert.IsNotNil(err)
+
+	stack.Push(1)
+	stack.Push(2)
+	stack.Push(3)
+
+	topItem, err := stack.Pop()
+	assert.IsNil(err)
+	assert.Equal(3, *topItem)
+
+	expected := []int{2, 1}
+	assert.Equal(expected, stack.Data())
+}
+
+func TestArrayStack_Peak(t *testing.T) {
+	assert := internal.NewAssert(t, "TestArrayStack_Peak")
+
+	stack := NewArrayStack[int]()
+	_, err := stack.Peak()
+	assert.IsNotNil(err)
+
+	stack.Push(1)
+	stack.Push(2)
+	stack.Push(3)
+
+	topItem, err := stack.Peak()
+	assert.IsNil(err)
+	assert.Equal(3, *topItem)
+
+	expected := []int{3, 2, 1}
+	assert.Equal(expected, stack.Data())
+}
+
+func TestArrayStack_Clear(t *testing.T) {
+	assert := internal.NewAssert(t, "TestArrayStack_Clear")
+
+	stack := NewArrayStack[int]()
+	assert.Equal(true, stack.IsEmpty())
+	assert.Equal(0, stack.Size())
+
+	stack.Push(1)
+	assert.Equal(false, stack.IsEmpty())
+	assert.Equal(1, stack.Size())
+
+	stack.Clear()
+	assert.Equal(true, stack.IsEmpty())
+	assert.Equal(0, stack.Size())
+}
--- a/datastructure/stack/linkedstack.go
+++ b/datastructure/stack/linkedstack.go
@@ -0,0 +1,94 @@
+package datastructure
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/duke-git/lancet/v2/datastructure"
+)
+
+// LinkedStack implements stack with link list
+type LinkedStack[T any] struct {
+	top    *datastructure.StackNode[T]
+	length int
+}
+
+// NewLinkedStack return a empty LinkedStack pointer
+func NewLinkedStack[T any]() *LinkedStack[T] {
+	return &LinkedStack[T]{top: nil, length: 0}
+}
+
+// Data return stack data
+func (s *LinkedStack[T]) Data() []T {
+	res := []T{}
+	current := s.top
+
+	for current != nil {
+		res = append(res, current.Value)
+		current = current.Next
+	}
+	return res
+}
+
+// Size return length of stack data
+func (s *LinkedStack[T]) Size() int {
+	return s.length
+}
+
+// IsEmpty checks if stack is empty or not
+func (s *LinkedStack[T]) IsEmpty() bool {
+	return s.length == 0
+}
+
+// Push element into stack
+func (s *LinkedStack[T]) Push(value T) {
+	newNode := datastructure.NewStackNode(value)
+	top := s.top
+	if top == nil {
+		s.top = newNode
+	} else {
+		newNode.Next = top
+		s.top = newNode
+	}
+
+	s.length++
+}
+
+// Pop delete the top element of stack then return it, if stack is empty, return nil and error
+func (s *LinkedStack[T]) Pop() (*T, error) {
+	if s.IsEmpty() {
+		return nil, errors.New("stack is empty")
+	}
+
+	top := s.top
+	s.top = s.top.Next
+	s.length--
+
+	return &top.Value, nil
+}
+
+// Peak return the top element of stack then return it
+func (s *LinkedStack[T]) Peak() (*T, error) {
+	if s.IsEmpty() {
+		return nil, errors.New("stack is empty")
+	}
+	return &s.top.Value, nil
+}
+
+// Clear clear the stack data
+func (s *LinkedStack[T]) Clear() {
+	s.top = nil
+	s.length = 0
+}
+
+// Print all nodes info of stack link
+func (s *LinkedStack[T]) Print() {
+	current := s.top
+	info := "[ "
+	for current != nil {
+		info += fmt.Sprintf("%+v, ", current)
+		current = current.Next
+	}
+	info += " ]"
+	fmt.Println(info)
+}
--- a/datastructure/stack/linkedstack_test.go
+++ b/datastructure/stack/linkedstack_test.go
@@ -0,0 +1,80 @@
+package datastructure
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestLinkedStack_Push(t *testing.T) {
+	assert := internal.NewAssert(t, "TestLinkedStack_Push")
+
+	stack := NewLinkedStack[int]()
+	stack.Push(1)
+	stack.Push(2)
+	stack.Push(3)
+
+	stack.Print()
+
+	expected := []int{3, 2, 1}
+	values := stack.Data()
+	size := stack.Size()
+
+	assert.Equal(expected, values)
+	assert.Equal(3, size)
+}
+
+func TestLinkedStack_Pop(t *testing.T) {
+	assert := internal.NewAssert(t, "TestLinkedStack_Pop")
+
+	stack := NewLinkedStack[int]()
+	_, err := stack.Pop()
+	assert.IsNotNil(err)
+
+	stack.Push(1)
+	stack.Push(2)
+	stack.Push(3)
+
+	topItem, err := stack.Pop()
+	assert.IsNil(err)
+	assert.Equal(3, *topItem)
+
+	expected := []int{2, 1}
+	stack.Print()
+	assert.Equal(expected, stack.Data())
+}
+
+func TestLinkedStack_Peak(t *testing.T) {
+	assert := internal.NewAssert(t, "TestLinkedStack_Peak")
+
+	stack := NewLinkedStack[int]()
+	_, err := stack.Peak()
+	assert.IsNotNil(err)
+
+	stack.Push(1)
+	stack.Push(2)
+	stack.Push(3)
+
+	topItem, err := stack.Peak()
+	assert.IsNil(err)
+	assert.Equal(3, *topItem)
+
+	expected := []int{3, 2, 1}
+	assert.Equal(expected, stack.Data())
+}
+
+func TestLinkedStack_Empty(t *testing.T) {
+	assert := internal.NewAssert(t, "TestLinkedStack_Empty")
+
+	stack := NewLinkedStack[int]()
+	assert.Equal(true, stack.IsEmpty())
+	assert.Equal(0, stack.Size())
+
+	stack.Push(1)
+	assert.Equal(false, stack.IsEmpty())
+	assert.Equal(1, stack.Size())
+
+	stack.Clear()
+	assert.Equal(true, stack.IsEmpty())
+	assert.Equal(0, stack.Size())
+}
--- a/datastructure/tree/bstree.go
+++ b/datastructure/tree/bstree.go
@@ -0,0 +1,108 @@
+package datastructure
+
+import (
+	"math"
+
+	"github.com/duke-git/lancet/v2/datastructure"
+	"github.com/duke-git/lancet/v2/lancetconstraints"
+)
+
+// BSTree is a binary search tree data structure in which each node has at most two children,
+// which are referred to as the left child and the right child.
+// In BSTree: leftNode < rootNode < rightNode
+// type T should implements Compare function in lancetconstraints.Comparator interface.
+type BSTree[T any] struct {
+	root       *datastructure.TreeNode[T]
+	comparator lancetconstraints.Comparator
+}
+
+// NewBSTree create a BSTree pointer
+// param `comparator` is used to compare values in the tree
+func NewBSTree[T any](rootData T, comparator lancetconstraints.Comparator) *BSTree[T] {
+	root := datastructure.NewTreeNode(rootData)
+	return &BSTree[T]{root, comparator}
+}
+
+// InsertNode insert data into BSTree
+func (t *BSTree[T]) Insert(data T) {
+	root := t.root
+	newNode := datastructure.NewTreeNode(data)
+	if root == nil {
+		t.root = newNode
+	} else {
+		insertTreeNode(root, newNode, t.comparator)
+	}
+}
+
+// DeletetNode delete data into BSTree
+func (t *BSTree[T]) Delete(data T) {
+	deleteTreeNode(t.root, data, t.comparator)
+}
+
+// NodeLevel get node level in BSTree
+func (t *BSTree[T]) NodeLevel(node *datastructure.TreeNode[T]) int {
+	if node == nil {
+		return 0
+	}
+	left := float64(t.NodeLevel(node.Left))
+	right := float64(t.NodeLevel(node.Right))
+
+	return int(math.Max(left, right)) + 1
+}
+
+// PreOrderTraverse traverse tree node in pre order
+func (t *BSTree[T]) PreOrderTraverse() []T {
+	return preOrderTraverse(t.root)
+}
+
+// PostOrderTraverse traverse tree node in post order
+func (t *BSTree[T]) PostOrderTraverse() []T {
+	return postOrderTraverse(t.root)
+}
+
+// InOrderTraverse traverse tree node in mid order
+func (t *BSTree[T]) InOrderTraverse() []T {
+	return inOrderTraverse(t.root)
+}
+
+// LevelOrderTraverse traverse tree node in level order
+func (t *BSTree[T]) LevelOrderTraverse() []T {
+	traversal := make([]T, 0)
+	levelOrderTraverse(t.root, &traversal)
+	return traversal
+}
+
+// Depth returns the calculated depth of a binary saerch tree
+func (t *BSTree[T]) Depth() int {
+	return calculateDepth(t.root, 0)
+}
+
+// IsSubTree checks if the tree `t` has `subTree` or not
+func (t *BSTree[T]) HasSubTree(subTree *BSTree[T]) bool {
+	return hasSubTree(t.root, subTree.root, t.comparator)
+}
+
+func hasSubTree[T any](superTreeRoot, subTreeRoot *datastructure.TreeNode[T],
+	comparator lancetconstraints.Comparator) bool {
+	res := false
+
+	if superTreeRoot != nil && subTreeRoot != nil {
+		if comparator.Compare(superTreeRoot.Value, subTreeRoot.Value) == 0 {
+			res = isSubTree(superTreeRoot, subTreeRoot, comparator)
+		}
+		if !res {
+			res = hasSubTree(superTreeRoot.Left, subTreeRoot, comparator)
+		}
+		if !res {
+			res = hasSubTree(superTreeRoot.Right, subTreeRoot, comparator)
+		}
+	}
+	return res
+}
+
+// Print the bstree structure
+func (t *BSTree[T]) Print() {
+	maxLevel := t.NodeLevel(t.root)
+	nodes := []*datastructure.TreeNode[T]{t.root}
+	printTreeNodes(nodes, 1, maxLevel)
+}
--- a/datastructure/tree/bstree_test.go
+++ b/datastructure/tree/bstree_test.go
@@ -0,0 +1,157 @@
+package datastructure
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func TestBSTree_Insert(t *testing.T) {
+	bstree := NewBSTree(6, &intComparator{})
+
+	bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+	bstree.Print()
+}
+
+func TestBSTree_PreOrderTraverse(t *testing.T) {
+	assert := internal.NewAssert(t, "TestBSTree_PreOrderTraverse")
+
+	bstree := NewBSTree(6, &intComparator{})
+
+	bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+	acturl := bstree.PreOrderTraverse()
+	t.Log(acturl)
+	assert.Equal([]int{6, 5, 2, 4, 7}, acturl)
+}
+
+func TestBSTree_PostOrderTraverse(t *testing.T) {
+	assert := internal.NewAssert(t, "TestBSTree_PostOrderTraverse")
+
+	bstree := NewBSTree(6, &intComparator{})
+
+	bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+	acturl := bstree.PostOrderTraverse()
+	t.Log(acturl)
+	assert.Equal([]int{5, 2, 4, 7, 6}, acturl)
+}
+
+func TestBSTree_InOrderTraverse(t *testing.T) {
+	assert := internal.NewAssert(t, "TestBSTree_InOrderTraverse")
+
+	bstree := NewBSTree(6, &intComparator{})
+
+	bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+	acturl := bstree.InOrderTraverse()
+	t.Log(acturl)
+	assert.Equal([]int{2, 4, 5, 6, 7}, acturl)
+}
+
+func TestBSTree_LevelOrderTraverse(t *testing.T) {
+	assert := internal.NewAssert(t, "TestBSTree_LevelOrderTraverse")
+
+	bstree := NewBSTree(6, &intComparator{})
+
+	bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+	bstree.Print()
+
+	acturl := bstree.LevelOrderTraverse()
+	t.Log(acturl)
+	assert.Equal([]int{6, 5, 7, 2, 4}, acturl)
+}
+
+func TestBSTree_Delete(t *testing.T) {
+	assert := internal.NewAssert(t, "TestBSTree_Delete")
+
+	bstree := NewBSTree(6, &intComparator{})
+
+	bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+	bstree.Print()
+
+	bstree.Delete(4)
+	bstree.Print()
+	acturl1 := bstree.InOrderTraverse()
+	t.Log(acturl1)
+	assert.Equal([]int{2, 5, 6, 7}, acturl1)
+
+	//todo
+	// bstree.DeletetNode(6, comparator)
+	// bstree.Print()
+	// acturl2 := bstree.InOrderTraverse()
+	// t.Log(acturl2)
+	// assert.Equal([]int{2, 5, 7}, acturl2)
+}
+
+func TestBSTree_Depth(t *testing.T) {
+	assert := internal.NewAssert(t, "TestBSTree_Depth")
+
+	bstree := NewBSTree(6, &intComparator{})
+
+	bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+	bstree.Print()
+
+	assert.Equal(bstree.Depth(), 4)
+}
+
+func TestBSTree_IsSubTree(t *testing.T) {
+	assert := internal.NewAssert(t, "TestBSTree_IsSubTree")
+
+	superTree := NewBSTree(8, &intComparator{})
+	superTree.Insert(4)
+	superTree.Insert(5)
+	superTree.Insert(6)
+	superTree.Insert(9)
+	superTree.Insert(4)
+
+	superTree.Print()
+
+	subTree := NewBSTree(5, &intComparator{})
+	subTree.Insert(4)
+	subTree.Insert(6)
+
+	subTree.Print()
+
+	assert.Equal(true, superTree.HasSubTree(subTree))
+	assert.Equal(false, subTree.HasSubTree(superTree))
+}
--- a/datastructure/tree/tree_internal.go
+++ b/datastructure/tree/tree_internal.go
@@ -0,0 +1,238 @@
+package datastructure
+
+import (
+	"fmt"
+	"math"
+
+	"github.com/duke-git/lancet/v2/datastructure"
+	"github.com/duke-git/lancet/v2/lancetconstraints"
+)
+
+func preOrderTraverse[T any](node *datastructure.TreeNode[T]) []T {
+	data := []T{}
+	if node != nil {
+		data = append(data, node.Value)
+		data = append(data, preOrderTraverse(node.Left)...)
+		data = append(data, preOrderTraverse(node.Right)...)
+	}
+	return data
+}
+
+func postOrderTraverse[T any](node *datastructure.TreeNode[T]) []T {
+	data := []T{}
+	if node != nil {
+		data = append(data, preOrderTraverse(node.Left)...)
+		data = append(data, preOrderTraverse(node.Right)...)
+		data = append(data, node.Value)
+	}
+	return data
+}
+
+func inOrderTraverse[T any](node *datastructure.TreeNode[T]) []T {
+	data := []T{}
+	if node != nil {
+		data = append(data, inOrderTraverse(node.Left)...)
+		data = append(data, node.Value)
+		data = append(data, inOrderTraverse(node.Right)...)
+	}
+	return data
+}
+
+func preOrderPrint[T any](node *datastructure.TreeNode[T]) {
+	if node == nil {
+		return
+	}
+
+	fmt.Printf("%v, ", node.Value)
+	preOrderPrint(node.Left)
+	preOrderPrint(node.Right)
+}
+
+func postOrderPrint[T any](node *datastructure.TreeNode[T]) {
+	if node == nil {
+		return
+	}
+
+	preOrderPrint(node.Left)
+	preOrderPrint(node.Right)
+	fmt.Printf("%v, ", node.Value)
+}
+
+func inOrderPrint[T any](node *datastructure.TreeNode[T]) {
+	if node == nil {
+		return
+	}
+
+	inOrderPrint(node.Left)
+	fmt.Printf("%v, ", node.Value)
+	inOrderPrint(node.Right)
+}
+
+func levelOrderTraverse[T any](root *datastructure.TreeNode[T], traversal *[]T) {
+	var q []*datastructure.TreeNode[T] // queue
+	var n *datastructure.TreeNode[T]   // temp node
+
+	q = append(q, root)
+
+	for len(q) != 0 {
+		n, q = q[0], q[1:]
+		*traversal = append(*traversal, n.Value)
+		if n.Left != nil {
+			q = append(q, n.Left)
+		}
+		if n.Right != nil {
+			q = append(q, n.Right)
+		}
+	}
+}
+
+func insertTreeNode[T any](rootNode, newNode *datastructure.TreeNode[T], comparator lancetconstraints.Comparator) {
+	if comparator.Compare(newNode.Value, rootNode.Value) == -1 {
+		if rootNode.Left == nil {
+			rootNode.Left = newNode
+		} else {
+			insertTreeNode(rootNode.Left, newNode, comparator)
+		}
+	} else {
+		if rootNode.Right == nil {
+			rootNode.Right = newNode
+		} else {
+			insertTreeNode(rootNode.Right, newNode, comparator)
+		}
+	}
+}
+
+// todo, delete root node failed
+func deleteTreeNode[T any](node *datastructure.TreeNode[T], data T, comparator lancetconstraints.Comparator) *datastructure.TreeNode[T] {
+	if node == nil {
+		return nil
+	}
+	if comparator.Compare(data, node.Value) == -1 {
+		node.Left = deleteTreeNode(node.Left, data, comparator)
+	} else if comparator.Compare(data, node.Value) == 1 {
+		node.Right = deleteTreeNode(node.Right, data, comparator)
+	} else {
+		if node.Left == nil {
+			node = node.Right
+		} else if node.Right == nil {
+			node = node.Left
+		} else {
+			l := node.Right
+			d := inOrderSuccessor(l)
+			d.Left = node.Left
+			return node.Right
+		}
+	}
+
+	return node
+}
+
+func inOrderSuccessor[T any](root *datastructure.TreeNode[T]) *datastructure.TreeNode[T] {
+	cur := root
+	for cur.Left != nil {
+		cur = cur.Left
+	}
+	return cur
+}
+
+func printTreeNodes[T any](nodes []*datastructure.TreeNode[T], level, maxLevel int) {
+	if len(nodes) == 0 || isAllNil(nodes) {
+		return
+	}
+
+	floor := maxLevel - level
+	endgeLines := int(math.Pow(float64(2), (math.Max(float64(floor)-1, 0))))
+	firstSpaces := int(math.Pow(float64(2), float64(floor))) - 1
+	betweenSpaces := int(math.Pow(float64(2), float64(floor)+1)) - 1
+
+	printSpaces(firstSpaces)
+
+	newNodes := []*datastructure.TreeNode[T]{}
+	for _, node := range nodes {
+		if node != nil {
+			fmt.Printf("%v", node.Value)
+			newNodes = append(newNodes, node.Left)
+			newNodes = append(newNodes, node.Right)
+		} else {
+			newNodes = append(newNodes, nil)
+			newNodes = append(newNodes, nil)
+			printSpaces(1)
+		}
+
+		printSpaces(betweenSpaces)
+	}
+
+	fmt.Println("")
+
+	for i := 1; i <= endgeLines; i++ {
+		for j := 0; j < len(nodes); j++ {
+			printSpaces(firstSpaces - i)
+			if nodes[j] == nil {
+				printSpaces(endgeLines + endgeLines + i + 1)
+				continue
+			}
+
+			if nodes[j].Left != nil {
+				fmt.Print("/")
+			} else {
+				printSpaces(1)
+			}
+
+			printSpaces(i + i - 1)
+
+			if nodes[j].Right != nil {
+				fmt.Print("\\")
+			} else {
+				printSpaces(1)
+			}
+			printSpaces(endgeLines + endgeLines - 1)
+		}
+		fmt.Println("")
+	}
+
+	printTreeNodes(newNodes, level+1, maxLevel)
+}
+
+// printSpaces
+func printSpaces(n int) {
+	for i := 0; i < n; i++ {
+		fmt.Print(" ")
+	}
+}
+
+func isAllNil[T any](nodes []*datastructure.TreeNode[T]) bool {
+	for _, v := range nodes {
+		if v != nil {
+			return false
+		}
+	}
+	return true
+}
+
+func calculateDepth[T any](node *datastructure.TreeNode[T], depth int) int {
+	if node == nil {
+		return depth
+	}
+	return max(calculateDepth(node.Left, depth+1), calculateDepth(node.Right, depth+1))
+}
+
+func isSubTree[T any](superTreeRoot, subTreeRoot *datastructure.TreeNode[T], comparator lancetconstraints.Comparator) bool {
+	if subTreeRoot == nil {
+		return true
+	}
+	if superTreeRoot == nil {
+		return false
+	}
+	if comparator.Compare(superTreeRoot.Value, subTreeRoot.Value) != 0 {
+		return false
+	}
+	res := isSubTree(superTreeRoot.Left, subTreeRoot.Left, comparator) && isSubTree(superTreeRoot.Right, subTreeRoot.Right, comparator)
+	return res
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
--- a/datetime/conversion.go
+++ b/datetime/conversion.go
@@ -0,0 +1,60 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license.
+
+package datetime
+
+import "time"
+
+type theTime struct {
+	unix int64
+}
+
+// NewUnixNow return unix timestamp of current time
+func NewUnixNow() *theTime {
+	return &theTime{unix: time.Now().Unix()}
+}
+
+// NewUnix return unix timestamp of specified time
+func NewUnix(unix int64) *theTime {
+	return &theTime{unix: unix}
+}
+
+// NewFormat return unix timestamp of specified time string, t should be "yyyy-mm-dd hh:mm:ss"
+func NewFormat(t string) (*theTime, error) {
+	timeLayout := "2006-01-02 15:04:05"
+	loc := time.FixedZone("CST", 8*3600)
+	tt, err := time.ParseInLocation(timeLayout, t, loc)
+	if err != nil {
+		return nil, err
+	}
+	return &theTime{unix: tt.Unix()}, nil
+}
+
+// NewISO8601 return unix timestamp of specified iso8601 time string
+func NewISO8601(iso8601 string) (*theTime, error) {
+	t, err := time.ParseInLocation(time.RFC3339, iso8601, time.UTC)
+	if err != nil {
+		return nil, err
+	}
+	return &theTime{unix: t.Unix()}, nil
+}
+
+// ToUnix return unix timestamp
+func (t *theTime) ToUnix() int64 {
+	return t.unix
+}
+
+// ToFormat return the time string 'yyyy-mm-dd hh:mm:ss' of unix time
+func (t *theTime) ToFormat() string {
+	return time.Unix(t.unix, 0).Format("2006-01-02 15:04:05")
+}
+
+// ToFormatForTpl return the time string which format is specified tpl
+func (t *theTime) ToFormatForTpl(tpl string) string {
+	return time.Unix(t.unix, 0).Format(tpl)
+}
+
+// ToFormatForTpl return iso8601 time string
+func (t *theTime) ToIso8601() string {
+	return time.Unix(t.unix, 0).Format(time.RFC3339)
+}
--- a/datetime/conversion_test.go
+++ b/datetime/conversion_test.go
@@ -0,0 +1,53 @@
+package datetime
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestToUnix(t *testing.T) {
+	assert := internal.NewAssert(t, "TestToUnix")
+
+	tm1 := NewUnixNow()
+	unixTimestamp := tm1.ToUnix()
+	tm2 := NewUnix(unixTimestamp)
+
+	assert.Equal(tm1, tm2)
+}
+
+func TestToFormat(t *testing.T) {
+	assert := internal.NewAssert(t, "TestToFormat")
+
+	_, err := NewFormat("2022/03/18 17:04:05")
+	assert.IsNotNil(err)
+
+	tm, err := NewFormat("2022-03-18 17:04:05")
+	assert.IsNil(err)
+
+	t.Log("ToFormat -> ", tm.ToFormat())
+}
+
+func TestToFormatForTpl(t *testing.T) {
+	assert := internal.NewAssert(t, "TestToFormatForTpl")
+
+	_, err := NewFormat("2022/03/18 17:04:05")
+	assert.IsNotNil(err)
+
+	tm, err := NewFormat("2022-03-18 17:04:05")
+	assert.IsNil(err)
+
+	t.Log("ToFormatForTpl -> ", tm.ToFormatForTpl("2006/01/02 15:04:05"))
+}
+
+func TestToIso8601(t *testing.T) {
+	assert := internal.NewAssert(t, "TestToIso8601")
+
+	_, err := NewISO8601("2022-03-18 17:04:05")
+	assert.IsNotNil(err)
+
+	tm, err := NewISO8601("2006-01-02T15:04:05.999Z")
+	assert.IsNil(err)
+
+	t.Log("ToIso8601 -> ", tm.ToIso8601())
+}
--- a/datetime/datetime_test.go
+++ b/datetime/datetime_test.go
@@ -4,7 +4,7 @@ import (
 	"testing"
 	"time"

-	"github.com/duke-git/lancet/internal"
+	"github.com/duke-git/lancet/v2/internal"
 )

 func TestAddDay(t *testing.T) {
--- a/docs/algorithm.md
+++ b/docs/algorithm.md
@@ -0,0 +1,595 @@
+# Algorithm
+Package algorithm implements some basic algorithm. eg. sort, search.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source
+
+- [https://github.com/duke-git/lancet/blob/main/algorithm/sorter.go](https://github.com/duke-git/lancet/blob/main/algorithm/sorter.go)
+- [https://github.com/duke-git/lancet/blob/main/algorithm/search.go](https://github.com/duke-git/lancet/blob/main/algorithm/search.go)
+- [https://github.com/duke-git/lancet/blob/main/algorithm/lru_cache.go](https://github.com/duke-git/lancet/blob/main/algorithm/lru_cache.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage
+```go
+import (
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+- [BubbleSort](#BubbleSort)
+- [InsertionSort](#InsertionSort)
+- [SelectionSort](#SelectionSort)
+- [ShellSort](#ShellSort)
+- [QuickSort](#QuickSort)
+- [HeapSort](#HeapSort)
+- [MergeSort](#MergeSort)
+- [CountSort](#CountSort)
+- [BinarySearch](#BinarySearch)
+- [BinaryIterativeSearch](#BinaryIterativeSearch)
+
+- [LinearSearch](#LinearSearch)
+- [LRUCache](#LRUCache)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+
+
+### <span id="BubbleSort">BubbleSort</span>
+<p>Sort slice with bubble sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
+
+<b>Signature:</b>
+
+```go
+func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    intSlice := []int{2, 1, 5, 3, 6, 4}
+    comparator := &intComparator{}
+    algorithm.BubbleSort(intSlice, comparator)
+
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+}
+```
+
+
+
+
+### <span id="InsertionSort">InsertionSort</span>
+<p>Sort slice with insertion sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
+
+<b>Signature:</b>
+
+```go
+func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type people struct {
+        Name string
+        Age  int
+    }
+
+    // PeopleAageComparator sort people slice by age field
+    type peopleAgeComparator struct{}
+
+    // Compare implements github.com/duke-git/lancet/lancetconstraints/constraints.go/Comparator
+    func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
+        p1, _ := v1.(people)
+        p2, _ := v2.(people)
+
+        //ascending order
+        if p1.Age < p2.Age {
+            return -1
+        } else if p1.Age > p2.Age {
+            return 1
+        }
+        return 0
+
+        //decending order
+        // if p1.Age > p2.Age {
+        // 	return -1
+        // } else if p1.Age < p2.Age {
+        // 	return 1
+        // }
+    }
+
+    var peoples = []people{
+        {Name: "a", Age: 20},
+        {Name: "b", Age: 10},
+        {Name: "c", Age: 17},
+        {Name: "d", Age: 8},
+        {Name: "e", Age: 28},
+    }
+    comparator := &peopleAgeComparator{}
+    algorithm.InsertionSort(peoples, comparator)
+
+    fmt.Println(peoples) //[{d 8} {b 10} {c 17} {a 20} {e 28}]
+}
+```
+
+
+
+
+### <span id="SelectionSort">SelectionSort</span>
+<p>Sort slice with selection sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
+
+<b>Signature:</b>
+
+```go
+func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    intSlice := []int{2, 1, 5, 3, 6, 4}
+    comparator := &intComparator{}
+    algorithm.SelectionSort(intSlice, comparator)
+
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+}
+```
+
+
+
+
+### <span id="ShellSort">ShellSort</span>
+<p>Sort slice with shell sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
+
+<b>Signature:</b>
+
+```go
+func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    intSlice := []int{2, 1, 5, 3, 6, 4}
+    comparator := &intComparator{}
+    algorithm.ShellSort(intSlice, comparator)
+
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+}
+```
+
+
+
+
+### <span id="QuickSort">QuickSort</span>
+<p>Sort slice with quick sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
+
+<b>Signature:</b>
+
+```go
+func QuickSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    intSlice := []int{2, 1, 5, 3, 6, 4}
+    comparator := &intComparator{}
+    algorithm.QuickSort(intSlice, 0, len(intSlice)-1, comparator)
+
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+}
+```
+
+
+
+
+### <span id="HeapSort">HeapSort</span>
+<p>Sort slice with heap sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
+
+<b>Signature:</b>
+
+```go
+func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    intSlice := []int{2, 1, 5, 3, 6, 4}
+    comparator := &intComparator{}
+    algorithm.HeapSort(intSlice, comparator)
+
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+}
+```
+
+
+
+
+### <span id="MergeSort">MergeSort</span>
+<p>Sort slice with merge sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
+
+<b>Signature:</b>
+
+```go
+func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    intSlice := []int{2, 1, 5, 3, 6, 4}
+    comparator := &intComparator{}
+    algorithm.MergeSort(intSlice, comparator)
+
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+}
+```
+
+
+
+### <span id="CountSort">CountSort</span>
+<p>Sort slice with count sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
+
+<b>Signature:</b>
+
+```go
+func CountSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    intSlice := []int{2, 1, 5, 3, 6, 4}
+    comparator := &intComparator{}
+    sortedSlice := algorithm.CountSort(intSlice, comparator)
+
+    fmt.Println(sortedSlice) //[]int{1, 2, 3, 4, 5, 6}
+}
+```
+
+
+
+
+### <span id="BinarySearch">BinarySearch</span>
+<p>BinarySearch search for target within a sorted slice, recursive call itself. If a target is found, the index of the target is returned. Else the function return -1.</p>
+
+<b>Signature:</b>
+
+```go
+func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    var sortedNumbers = []int{1, 2, 3, 4, 5, 6, 7, 8}
+    comparator := &intComparator{}
+    foundIndex := algorithm.BinarySearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator)
+    fmt.Println(foundIndex) //4
+
+    notFoundIndex := algorithm.BinarySearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator)
+    fmt.Println(notFoundIndex) //-1
+}
+```
+
+
+
+### <span id="BinaryIterativeSearch">BinaryIterativeSearch</span>
+<p>BinaryIterativeSearch search for target within a sorted slice, recursive call itself. If a target is found, the index of the target is returned. Else the function return -1.</p>
+
+<b>Signature:</b>
+
+```go
+func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    var sortedNumbers = []int{1, 2, 3, 4, 5, 6, 7, 8}
+    comparator := &intComparator{}
+    foundIndex := algorithm.BinaryIterativeSearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator)
+    fmt.Println(foundIndex) //4
+
+    notFoundIndex := algorithm.BinaryIterativeSearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator)
+    fmt.Println(notFoundIndex) //-1
+}
+```
+
+
+
+
+### <span id="LinearSearch">LinearSearch</span>
+<p>LinearSearch Simple linear search algorithm that iterates over all elements of an slice. If a target is found, the index of the target is returned. Else the function return -1.</p>
+
+<b>Signature:</b>
+
+```go
+func LinearSearch[T any](slice []T, target T, comparator lancetconstraints.Comparator) int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    intSlice := []int{2, 1, 5, 3, 6, 4}
+    comparator := &intComparator{}
+    foundIndex := algorithm.LinearSearch(intSlice, 5, comparator)
+    fmt.Println(foundIndex) //2
+
+    notFoundIndex := algorithm.LinearSearch(sortedNumbers, 0, comparator)
+    fmt.Println(notFoundIndex) //-1
+}
+```
+
+
+
+
+### <span id="LRUCache">LRUCache</span>
+<p>LRUCache implements mem cache with lru.</p>
+
+<b>Signature:</b>
+
+```go
+func NewLRUCache[K comparable, V any](capacity int) *LRUCache[K, V]
+func (l *LRUCache[K, V]) Get(key K) (V, bool)
+func (l *LRUCache[K, V]) Put(key K, value V)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    cache := algorithm.NewLRUCache[int, int](2)
+
+	cache.Put(1, 1)
+	cache.Put(2, 2)
+
+    _, ok := cache.Get(0) // ok -> false
+
+    v, ok := cache.Get(1) // v->1, ok->true
+
+}
+```
--- a/docs/algorithm_zh-CN.md
+++ b/docs/algorithm_zh-CN.md
@@ -0,0 +1,596 @@
+# Algorithm
+algorithm算法包实现一些基本算法，sort，search，lrucache。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码
+
+- [https://github.com/duke-git/lancet/blob/main/algorithm/sorter.go](https://github.com/duke-git/lancet/blob/main/algorithm/sorter.go)
+- [https://github.com/duke-git/lancet/blob/main/algorithm/search.go](https://github.com/duke-git/lancet/blob/main/algorithm/search.go)
+- [https://github.com/duke-git/lancet/blob/main/algorithm/lru_cache.go](https://github.com/duke-git/lancet/blob/main/algorithm/lru_cache.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法
+```go
+import (
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+- [BubbleSort](#BubbleSort)
+- [InsertionSort](#InsertionSort)
+- [SelectionSort](#SelectionSort)
+- [ShellSort](#ShellSort)
+- [QuickSort](#QuickSort)
+- [HeapSort](#HeapSort)
+- [MergeSort](#MergeSort)
+
+- [CountSort](#CountSort)
+- [BinarySearch](#BinarySearch)
+- [BinaryIterativeSearch](#BinaryIterativeSearch)
+- [LinearSearch](#LinearSearch)
+- [LRUCache](#LRUCache)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+
+
+### <span id="BubbleSort">BubbleSort</span>
+<p>冒泡排序，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<b>函数签名:</b>
+
+```go
+func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    intSlice := []int{2, 1, 5, 3, 6, 4}
+    comparator := &intComparator{}
+    algorithm.BubbleSort(intSlice, comparator)
+
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+}
+```
+
+
+
+
+### <span id="InsertionSort">InsertionSort</span>
+<p>插入排序，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<b>函数签名:</b>
+
+```go
+func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type people struct {
+        Name string
+        Age  int
+    }
+
+    // PeopleAageComparator sort people slice by age field
+    type peopleAgeComparator struct{}
+
+    // Compare implements github.com/duke-git/lancet/lancetconstraints/constraints.go/Comparator
+    func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
+        p1, _ := v1.(people)
+        p2, _ := v2.(people)
+
+        //ascending order
+        if p1.Age < p2.Age {
+            return -1
+        } else if p1.Age > p2.Age {
+            return 1
+        }
+        return 0
+
+        //decending order
+        // if p1.Age > p2.Age {
+        // 	return -1
+        // } else if p1.Age < p2.Age {
+        // 	return 1
+        // }
+    }
+
+    var peoples = []people{
+        {Name: "a", Age: 20},
+        {Name: "b", Age: 10},
+        {Name: "c", Age: 17},
+        {Name: "d", Age: 8},
+        {Name: "e", Age: 28},
+    }
+    comparator := &peopleAgeComparator{}
+    algorithm.InsertionSort(peoples, comparator)
+
+    fmt.Println(intSlice) //[{d 8} {b 10} {c 17} {a 20} {e 28}]
+}
+```
+
+
+
+
+### <span id="SelectionSort">SelectionSort</span>
+<p>选择排序，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<b>函数签名:</b>
+
+```go
+func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    intSlice := []int{2, 1, 5, 3, 6, 4}
+    comparator := &intComparator{}
+    algorithm.SelectionSort(intSlice, comparator)
+
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+}
+```
+
+
+
+
+### <span id="ShellSort">ShellSort</span>
+<p>希尔排序，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<b>函数签名:</b>
+
+```go
+func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    intSlice := []int{2, 1, 5, 3, 6, 4}
+    comparator := &intComparator{}
+    algorithm.ShellSort(intSlice, comparator)
+
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+}
+```
+
+
+
+
+### <span id="QuickSort">QuickSort</span>
+<p>快速排序，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<b>函数签名:</b>
+
+```go
+func QuickSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) []T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    intSlice := []int{2, 1, 5, 3, 6, 4}
+    comparator := &intComparator{}
+    algorithm.QuickSort(intSlice, 0, len(intSlice)-1, comparator)
+
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+}
+```
+
+
+
+
+### <span id="HeapSort">HeapSort</span>
+<p>堆排序，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<b>函数签名:</b>
+
+```go
+func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    intSlice := []int{2, 1, 5, 3, 6, 4}
+    comparator := &intComparator{}
+    algorithm.HeapSort(intSlice, comparator)
+
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+}
+```
+
+
+
+
+### <span id="MergeSort">MergeSort</span>
+<p>归并排序，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<b>函数签名:</b>
+
+```go
+func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    intSlice := []int{2, 1, 5, 3, 6, 4}
+    comparator := &intComparator{}
+    algorithm.MergeSort(intSlice, comparator)
+
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
+}
+```
+
+
+
+### <span id="CountSort">CountSort</span>
+<p>计数排序，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<b>函数签名:</b>
+
+```go
+func CountSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    intSlice := []int{2, 1, 5, 3, 6, 4}
+    comparator := &intComparator{}
+    sortedSlice := algorithm.CountSort(intSlice, comparator)
+
+    fmt.Println(sortedSlice) //[]int{1, 2, 3, 4, 5, 6}
+}
+```
+
+
+
+
+### <span id="BinarySearch">BinarySearch</span>
+<p>二分递归查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<b>函数签名:</b>
+
+```go
+func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    var sortedNumbers = []int{1, 2, 3, 4, 5, 6, 7, 8}
+    comparator := &intComparator{}
+    foundIndex := algorithm.BinarySearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator)
+    fmt.Println(foundIndex) //4
+
+    notFoundIndex := algorithm.BinarySearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator)
+    fmt.Println(notFoundIndex) //-1
+}
+```
+
+
+
+### <span id="BinaryIterativeSearch">BinaryIterativeSearch</span>
+<p>二分迭代查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<b>函数签名:</b>
+
+```go
+func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    var sortedNumbers = []int{1, 2, 3, 4, 5, 6, 7, 8}
+    comparator := &intComparator{}
+    foundIndex := algorithm.BinaryIterativeSearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator)
+    fmt.Println(foundIndex) //4
+
+    notFoundIndex := algorithm.BinaryIterativeSearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator)
+    fmt.Println(notFoundIndex) //-1
+}
+```
+
+
+
+
+### <span id="LinearSearch">LinearSearch</span>
+<p>线性查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包lancetconstraints.Comparator</p>
+
+<b>函数签名:</b>
+
+```go
+func LinearSearch[T any](slice []T, target T, comparator lancetconstraints.Comparator) int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    type intComparator struct{}
+
+    func (c *intComparator) Compare(v1 any, v2 any) int {
+        val1, _ := v1.(int)
+        val2, _ := v2.(int)
+
+        //ascending order
+        if val1 < val2 {
+            return -1
+        } else if val1 > val2 {
+            return 1
+        }
+        return 0
+    }
+
+    intSlice := []int{2, 1, 5, 3, 6, 4}
+    comparator := &intComparator{}
+    foundIndex := algorithm.LinearSearch(intSlice, 5, comparator)
+    fmt.Println(foundIndex) //2
+
+    notFoundIndex := algorithm.LinearSearch(sortedNumbers, 0, comparator)
+    fmt.Println(notFoundIndex) //-1
+}
+```
+
+
+
+
+### <span id="LRUCache">LRUCache</span>
+<p>lru实现缓存</p>
+
+<b>函数签名:</b>
+
+```go
+func NewLRUCache[K comparable, V any](capacity int) *LRUCache[K, V]
+func (l *LRUCache[K, V]) Get(key K) (V, bool)
+func (l *LRUCache[K, V]) Put(key K, value V)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/algorithm"
+)
+
+func main() {
+    cache := algorithm.NewLRUCache[int, int](2)
+
+	cache.Put(1, 1)
+	cache.Put(2, 2)
+
+    _, ok := cache.Get(0) // ok -> false
+
+    v, ok := cache.Get(1) // v->1, ok->true
+
+}
+```
--- a/docs/concurrency.md
+++ b/docs/concurrency.md
@@ -0,0 +1,390 @@
+# Concurrency
+Package concurrency contain some functions to support concurrent programming. eg, goroutine, channel, async.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source:
+
+- [https://github.com/duke-git/lancet/blob/main/concurrency/channel.go](https://github.com/duke-git/lancet/blob/main/concurrency/channel.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage:
+```go
+import (
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+### Channel
+- [NewChannel](#NewChannel)
+- [Bridge](#Bridge)
+- [FanIn](#FanIn)
+- [Generate](#Generate)
+- [Or](#Or)
+- [OrDone](#OrDone)
+- [Repeat](#Repeat)
+- [RepeatFn](#RepeatFn)
+- [Take](#Take)
+- [Tee](#Tee)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+
+## Channel
+### <span id="NewChannel">NewChannel</span>
+<p>return a Channel pointer instance.</p>
+
+<b>Signature:</b>
+
+```go
+type Channel struct {}
+func NewChannel() *Channel
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    c := concurrency.NewChannel()
+}
+```
+
+
+
+### <span id="Bridge">Bridge</span>
+
+<p>Link multiple channels into one channel until cancel the context.</p>
+
+<b>Signature:</b>
+
+```go
+func (c *Channel) Bridge(ctx context.Context, chanStream <-chan <-chan any) <-chan any
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := concurrency.NewChannel()
+	genVals := func() <-chan <-chan any {
+		chanStream := make(chan (<-chan any))
+		go func() {
+			defer close(chanStream)
+			for i := 0; i < 10; i++ {
+				stream := make(chan any, 1)
+				stream <- i
+				close(stream)
+				chanStream <- stream
+			}
+		}()
+		return chanStream
+	}
+
+	index := 0
+	for val := range c.Bridge(ctx, genVals()) {
+		fmt.Printf("%v ", val) //0 1 2 3 4 5 6 7 8 9
+	}
+}
+```
+
+
+
+
+### <span id="FanIn">FanIn</span>
+
+<p>merge multiple channels into one channel until cancel the context.</p>
+
+<b>Signature:</b>
+
+```go
+func (c *Channel) FanIn(ctx context.Context, channels ...<-chan any) <-chan any
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := concurrency.NewChannel()
+	channels := make([]<-chan any, 3)
+
+	for i := 0; i < 3; i++ {
+		channels[i] = c.Take(ctx, c.Repeat(ctx, i), 3)
+	}
+
+	mergedChannel := c.FanIn(ctx, channels...)
+
+	for val := range mergedChannel {
+		fmt.Println("\t%d\n", val) //1,2,1,0,0,1,0,2,2 (order not for sure)
+	}
+}
+```
+
+
+### <span id="Repeat">Repeat</span>
+
+<p>Return a chan, put param `values` into the chan repeatly until cancel the context.</p>
+
+<b>Signature:</b>
+
+```go
+func (c *Channel) Repeat(ctx context.Context, values ...any) <-chan any
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := concurrency.NewChannel()
+	intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 5)
+
+	for v := range intStream {
+     	fmt.Println(v) //1, 2, 1, 2, 1
+	}
+}
+```
+
+
+
+
+### <span id="RepeatFn">RepeatFn</span>
+
+<p>Return a chan, excutes fn repeatly, and put the result into retruned chan until cancel context.</p>
+
+<b>Signature:</b>
+
+```go
+func (c *Channel) RepeatFn(ctx context.Context, fn func() any) <-chan any
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	fn := func() any {
+		s := "a"
+		return s
+	}
+	c := concurrency.NewChannel()
+	dataStream := c.Take(ctx, c.RepeatFn(ctx, fn), 3)
+
+	for v := range dataStream {
+	    fmt.Println(v) //a, a, a
+	}
+}
+```
+
+
+
+### <span id="Or">Or</span>
+
+<p>Read one or more channels into one channel, will close when any readin channel is closed.</p>
+
+<b>Signature:</b>
+
+```go
+func (c *Channel) Or(channels ...<-chan any) <-chan any
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    sig := func(after time.Duration) <-chan any {
+		c := make(chan interface{})
+		go func() {
+			defer close(c)
+			time.Sleep(after)
+		}()
+		return c
+	}
+
+	start := time.Now()
+
+	c := concurrency.NewChannel()
+	<-c.Or(
+		sig(1*time.Second),
+		sig(2*time.Second),
+		sig(3*time.Second),
+		sig(4*time.Second),
+		sig(5*time.Second),
+	)
+
+	fmt.Println("done after %v", time.Since(start)) //1.003s
+}
+```
+
+
+
+
+### <span id="OrDone">OrDone</span>
+
+<p>Read a channel into another channel, will close until cancel context.</p>
+
+<b>Signature:</b>
+
+```go
+func (c *Channel) OrDone(ctx context.Context, channel <-chan any) <-chan any
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := concurrency.NewChannel()
+	intStream := c.Take(ctx, c.Repeat(ctx, 1), 3)
+
+	for val := range c.OrDone(ctx, intStream) {
+		fmt.Println(val)  //1
+	}
+}
+```
+
+
+
+
+### <span id="Take">Take</span>
+
+<p>Return a chan whose values are tahken from another chan until cancel context.</p>
+
+<b>Signature:</b>
+
+```go
+func (c *Channel) Take(ctx context.Context, valueStream <-chan any, number int) <-chan any
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	numbers := make(chan any, 5)
+	numbers <- 1
+	numbers <- 2
+	numbers <- 3
+	numbers <- 4
+	numbers <- 5
+	defer close(numbers)
+
+	c := concurrency.NewChannel()
+	intStream := c.Take(ctx, numbers, 3)
+
+	for val := range intStream {
+        fmt.Println(val) //1, 2, 3
+	}
+}
+```
+
+
+
+### <span id="Tee">Tee</span>
+
+<p>Split one chanel into two channels until cancel context.</p>
+
+<b>Signature:</b>
+
+```go
+func (c *Channel) Tee(ctx context.Context, in <-chan any) (<-chan any, <-chan any)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := concurrency.NewChannel()
+	inStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 4)
+
+	out1, out2 := c.Tee(ctx, inStream)
+	for val := range out1 {
+        fmt.Println(val) //1
+        fmt.Println(<-out2) //1
+	}
+}
+```
--- a/docs/concurrency_zh-CN.md
+++ b/docs/concurrency_zh-CN.md
@@ -0,0 +1,390 @@
+# Concurrency
+并发包包含一些支持并发编程的功能。例如：goroutine, channel, async等。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+- [https://github.com/duke-git/lancet/blob/main/concurrency/channel.go](https://github.com/duke-git/lancet/blob/main/concurrency/channel.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+```go
+import (
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+### Channel
+- [NewChannel](#NewChannel)
+- [Bridge](#Bridge)
+- [FanIn](#FanIn)
+- [Generate](#Generate)
+- [Or](#Or)
+- [OrDone](#OrDone)
+- [Repeat](#Repeat)
+- [RepeatFn](#RepeatFn)
+- [Take](#Take)
+- [Tee](#Tee)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+
+### Channel
+### <span id="NewChannel">NewChannel</span>
+<p>返回一个 Channel 指针实例</p>
+
+<b>函数签名:</b>
+
+```go
+type Channel struct {}
+func NewChannel() *Channel
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    c := concurrency.NewChannel()
+}
+```
+
+
+
+### <span id="Bridge">Bridge</span>
+
+<p>将多个通道链接到一个通道，直到取消上下文。</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel) Bridge(ctx context.Context, chanStream <-chan <-chan any) <-chan any
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := concurrency.NewChannel()
+	genVals := func() <-chan <-chan any {
+		chanStream := make(chan (<-chan any))
+		go func() {
+			defer close(chanStream)
+			for i := 0; i < 10; i++ {
+				stream := make(chan any, 1)
+				stream <- i
+				close(stream)
+				chanStream <- stream
+			}
+		}()
+		return chanStream
+	}
+
+	index := 0
+	for val := range c.Bridge(ctx, genVals()) {
+		fmt.Printf("%v ", val) //0 1 2 3 4 5 6 7 8 9
+	}
+}
+```
+
+
+
+
+### <span id="FanIn">FanIn</span>
+
+<p>将多个通道合并为一个通道，直到取消上下文</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel) FanIn(ctx context.Context, channels ...<-chan any) <-chan any
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := concurrency.NewChannel()
+	channels := make([]<-chan any, 3)
+
+	for i := 0; i < 3; i++ {
+		channels[i] = c.Take(ctx, c.Repeat(ctx, i), 3)
+	}
+
+	mergedChannel := c.FanIn(ctx, channels...)
+
+	for val := range mergedChannel {
+		fmt.Println("\t%d\n", val) //1,2,1,0,0,1,0,2,2 (order not for sure)
+	}
+}
+```
+
+
+### <span id="Repeat">Repeat</span>
+
+<p>返回一个chan，将参数`values`重复放入chan，直到取消上下文。</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel) Repeat(ctx context.Context, values ...any) <-chan any
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := concurrency.NewChannel()
+	intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 5)
+
+	for v := range intStream {
+     	fmt.Println(v) //1, 2, 1, 2, 1
+	}
+}
+```
+
+
+
+
+### <span id="RepeatFn">RepeatFn</span>
+
+<p>返回一个chan，重复执行函数fn，并将结果放入返回的chan，直到取消上下文。</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel) RepeatFn(ctx context.Context, fn func() any) <-chan any
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	fn := func() any {
+		s := "a"
+		return s
+	}
+	c := concurrency.NewChannel()
+	dataStream := c.Take(ctx, c.RepeatFn(ctx, fn), 3)
+
+	for v := range dataStream {
+	    fmt.Println(v) //a, a, a
+	}
+}
+```
+
+
+
+### <span id="Or">Or</span>
+
+<p>将一个或多个通道读取到一个通道中，当任何读取通道关闭时将结束读取。</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel) Or(channels ...<-chan any) <-chan any
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    sig := func(after time.Duration) <-chan any {
+		c := make(chan interface{})
+		go func() {
+			defer close(c)
+			time.Sleep(after)
+		}()
+		return c
+	}
+
+	start := time.Now()
+
+	c := concurrency.NewChannel()
+	<-c.Or(
+		sig(1*time.Second),
+		sig(2*time.Second),
+		sig(3*time.Second),
+		sig(4*time.Second),
+		sig(5*time.Second),
+	)
+
+	fmt.Println("done after %v", time.Since(start)) //1.003s
+}
+```
+
+
+
+
+### <span id="OrDone">OrDone</span>
+
+<p>将一个通道读入另一个通道，直到取消上下文。</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel) OrDone(ctx context.Context, channel <-chan any) <-chan any
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := concurrency.NewChannel()
+	intStream := c.Take(ctx, c.Repeat(ctx, 1), 3)
+
+	for val := range c.OrDone(ctx, intStream) {
+		fmt.Println(val)  //1
+	}
+}
+```
+
+
+
+
+### <span id="Take">Take</span>
+
+<p>返回一个chan，其值从另一个chan获取，直到取消上下文。</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel) Take(ctx context.Context, valueStream <-chan any, number int) <-chan any
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	numbers := make(chan any, 5)
+	numbers <- 1
+	numbers <- 2
+	numbers <- 3
+	numbers <- 4
+	numbers <- 5
+	defer close(numbers)
+
+	c := concurrency.NewChannel()
+	intStream := c.Take(ctx, numbers, 3)
+
+	for val := range intStream {
+        fmt.Println(val) //1, 2, 3
+	}
+}
+```
+
+
+
+### <span id="Tee">Tee</span>
+
+<p>将一个通道分成两个通道，直到取消上下文。</p>
+
+<b>函数签名:</b>
+
+```go
+func (c *Channel) Tee(ctx context.Context, in <-chan any) (<-chan any, <-chan any)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/duke-git/lancet/v2/concurrency"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c := concurrency.NewChannel()
+	inStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 4)
+
+	out1, out2 := c.Tee(ctx, inStream)
+	for val := range out1 {
+        fmt.Println(val) //1
+        fmt.Println(<-out2) //1
+	}
+}
+```
--- a/docs/convertor.md
+++ b/docs/convertor.md
@@ -5,14 +5,14 @@ Package convertor contains some functions for data type convertion.

 ## Source:

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

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

 ## Usage:
 ```go
 import (
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 ```

@@ -50,12 +50,12 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
    colorHex := "#003366"
-    r, g, b := ColorHexToRGB(colorHex)
+    r, g, b := convertor.ColorHexToRGB(colorHex)
    fmt.Println(r, g, b) //0,51,102
 }
 ```
@@ -78,14 +78,14 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
    r := 0
    g := 51
    b := 102
-    colorHex := ColorRGBToHex(r, g, b)
+    colorHex := convertor.ColorRGBToHex(r, g, b)

    fmt.Println(colorHex) //#003366
 }
@@ -109,7 +109,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
@@ -136,7 +136,7 @@ func main() {
 <b>Signature:</b>

 ```go
-func ToBytes(data interface{}) ([]byte, error)
+func ToBytes(data any) ([]byte, error)
 ```
 <b>Example:</b>

@@ -145,7 +145,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
@@ -175,7 +175,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
@@ -199,7 +199,7 @@ func main() {
 <b>Signature:</b>

 ```go
-func ToFloat(value interface{}) (float64, error)
+func ToFloat(value any) (float64, error)
 ```
 <b>Example:</b>

@@ -208,7 +208,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
@@ -232,7 +232,7 @@ func main() {
 <b>Signature:</b>

 ```go
-func ToInt(value interface{}) (int64, error)
+func ToInt(value any) (int64, error)
 ```
 <b>Example:</b>

@@ -241,7 +241,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
@@ -265,7 +265,7 @@ func main() {
 <b>Signature:</b>

 ```go
-func ToJson(value interface{}) (string, error)
+func ToJson(value any) (string, error)
 ```
 <b>Example:</b>

@@ -274,7 +274,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
@@ -293,7 +293,7 @@ func main() {
 <b>Signature:</b>

 ```go
-func ToString(value interface{}) string
+func ToString(value any) string
 ```
 <b>Example:</b>

@@ -302,7 +302,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
@@ -321,7 +321,7 @@ func main() {
 <b>Signature:</b>

 ```go
-func StructToMap(value interface{}) (map[string]interface{}, error)
+func StructToMap(value any) (map[string]any, error)
 ```
 <b>Example:</b>

@@ -330,7 +330,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
--- a/docs/convertor_zh-CN.md
+++ b/docs/convertor_zh-CN.md
@@ -5,7 +5,7 @@ convertor转换器包支持一些常见的数据类型转换

 ## 源码:

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

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

@@ -13,7 +13,7 @@ convertor转换器包支持一些常见的数据类型转换

 ```go
 import (
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 ```

@@ -52,12 +52,12 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
    colorHex := "#003366"
-    r, g, b := ColorHexToRGB(colorHex)
+    r, g, b := convertor.ColorHexToRGB(colorHex)
    fmt.Println(r, g, b) //0,51,102
 }
 ```
@@ -80,14 +80,14 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
    r := 0
    g := 51
    b := 102
-    colorHex := ColorRGBToHex(r, g, b)
+    colorHex := convertor.ColorRGBToHex(r, g, b)

    fmt.Println(colorHex) //#003366
 }
@@ -111,7 +111,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
@@ -138,7 +138,7 @@ func main() {
 <b>函数签名:</b>

 ```go
-func ToBytes(data interface{}) ([]byte, error)
+func ToBytes(data any) ([]byte, error)
 ```
 <b>列子:</b>

@@ -147,7 +147,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
@@ -177,7 +177,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
@@ -201,7 +201,7 @@ func main() {
 <b>函数签名:</b>

 ```go
-func ToFloat(value interface{}) (float64, error)
+func ToFloat(value any) (float64, error)
 ```
 <b>列子:</b>

@@ -210,7 +210,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
@@ -234,7 +234,7 @@ func main() {
 <b>函数签名:</b>

 ```go
-func ToInt(value interface{}) (int64, error)
+func ToInt(value any) (int64, error)
 ```
 <b>例子:</b>

@@ -243,7 +243,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
@@ -267,7 +267,7 @@ func main() {
 <b>函数签名:</b>

 ```go
-func ToJson(value interface{}) (string, error)
+func ToJson(value any) (string, error)
 ```
 <b>列子:</b>

@@ -276,7 +276,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
@@ -295,7 +295,7 @@ func main() {
 <b>函数签名:</b>

 ```go
-func ToString(value interface{}) string
+func ToString(value any) string
 ```
 <b>例子:</b>

@@ -304,7 +304,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
@@ -323,7 +323,7 @@ func main() {
 <b>函数签名:</b>

 ```go
-func StructToMap(value interface{}) (map[string]interface{}, error)
+func StructToMap(value any) (map[string]any, error)
 ```
 <b>列子:</b>

@@ -332,7 +332,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )

 func main() {
--- a/docs/cryptor.md
+++ b/docs/cryptor.md
@@ -15,7 +15,7 @@ Package cryptor contains some functions for data encryption and decryption. Supp
 ## Usage:
 ```go
 import (
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 ```

@@ -80,7 +80,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -110,7 +110,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -140,7 +140,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -171,7 +171,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -202,7 +202,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -234,7 +234,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -264,7 +264,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -295,7 +295,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -325,7 +325,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -356,7 +356,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -384,7 +384,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -412,7 +412,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -443,7 +443,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -475,7 +475,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -506,7 +506,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -538,7 +538,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -570,7 +570,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -600,7 +600,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -631,7 +631,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -661,7 +661,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -693,7 +693,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -721,7 +721,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -749,7 +749,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -777,7 +777,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -806,7 +806,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -834,7 +834,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -862,7 +862,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -890,7 +890,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -918,7 +918,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -946,7 +946,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -976,7 +976,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -1012,7 +1012,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
--- a/docs/cryptor_zh-CN.md
+++ b/docs/cryptor_zh-CN.md
@@ -15,7 +15,7 @@ cryptor加密包支持数据加密和解密，获取md5，hash值。支持base64
 ## 用法:
 ```go
 import (
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 ```

@@ -80,7 +80,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -110,7 +110,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -140,7 +140,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -171,7 +171,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -203,7 +203,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -235,7 +235,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -265,7 +265,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -296,7 +296,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -326,7 +326,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -356,7 +356,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -384,7 +384,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -412,7 +412,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -443,7 +443,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -475,7 +475,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -506,7 +506,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -538,7 +538,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -570,7 +570,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -600,7 +600,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -631,7 +631,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -661,7 +661,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -692,7 +692,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -720,7 +720,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -748,7 +748,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -776,7 +776,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -805,7 +805,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -833,7 +833,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -861,7 +861,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -889,7 +889,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -917,7 +917,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -945,7 +945,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -975,7 +975,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
@@ -1009,7 +1009,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )

 func main() {
--- a/docs/datastructure/linklist.md
+++ b/docs/datastructure/linklist.md
--- a/docs/datastructure/linklist_zh-CN.md
+++ b/docs/datastructure/linklist_zh-CN.md
--- a/docs/datastructure/list.md
+++ b/docs/datastructure/list.md
@@ -0,0 +1,713 @@
+# List
+List is a linear table, implemented with slice.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source
+
+- [https://github.com/duke-git/lancet/blob/main/datastructure/list/list.go](https://github.com/duke-git/lancet/blob/main/datastructure/list/list.go)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage
+```go
+import (
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+
+- [NewList](#NewList)
+- [Contain](#Contain)
+- [Data](#Data)
+- [ValueOf](#ValueOf)
+- [IndexOf](#IndexOf)
+- [Push](#Push)
+- [PopFirst](#PopFirst)
+- [PopLast](#PopLast)
+- [DeleteAt](#DeleteAt)
+- [InsertAt](#InsertAt)
+- [UpdateAt](#UpdateAt)
+- [Equal](#Equal)
+- [IsEmpty](#IsEmpty)
+- [Clear](#Clear)
+- [Clone](#Clone)
+- [Merge](#Merge)
+- [Size](#Size)
+- [Swap](#Swap)
+- [Reverse](#Reverse)
+- [Unique](#Unique)
+- [Union](#Union)
+- [Intersection](#Intersection)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+### <span id="NewList">NewList</span>
+<p>List is a linear table, implemented with slice.
+NewList function return a list pointer</p>
+
+<b>Signature:</b>
+
+```go
+type List[T any] struct {
+	data []T
+}
+func NewList[T any](data []T) *List[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+    fmt.Println(li)
+}
+```
+
+
+
+### <span id="Contain">Contain</span>
+<p>Check if the value in the list or not</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) Contain(value T) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+
+    fmt.Println(li.Contain(1)) //true
+    fmt.Println(li.Contain(0)) //false
+}
+```
+
+
+
+
+### <span id="Data">Data</span>
+<p>Return slice of list data</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) Data() []T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+    data := li.Data()
+
+    fmt.Println(data) //[]int{1, 2, 3}
+}
+```
+
+
+
+
+### <span id="ValueOf">ValueOf</span>
+<p>Return the value pointer at index in list</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) ValueOf(index int) (*T, bool)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+    v, ok := li.ValueOf(0)
+
+    fmt.Println(*v) //1
+    fmt.Println(ok) //true
+}
+```
+
+
+
+
+### <span id="IndexOf">IndexOf</span>
+<p>Reture the index of value in the list. if not found return -1</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) IndexOf(value T) int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+
+    fmt.Println(li.IndexOf(1)) //0
+    fmt.Println(li.IndexOf(0)) //-1
+}
+```
+
+
+
+### <span id="Push">Push</span>
+<p>Append value to the list</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) Push(value T)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+    li.Push(4)
+
+    fmt.Println(li.Data()) //[]int{1, 2, 3, 4}
+}
+```
+
+
+
+
+### <span id="PopFirst">PopFirst</span>
+<p>Delete the first value of list and return it</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) PopFirst() (*T, bool)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+    v, ok := li.PopFirst()
+
+    fmt.Println(*v) //1
+    fmt.Println(ok) //true
+    fmt.Println(li.Data()) //2, 3
+}
+```
+
+
+
+
+
+### <span id="PopLast">PopFirst</span>
+<p>Delete the last value of list and return it</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) PopLast() (*T, bool)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+    v, ok := li.PopLast()
+
+    fmt.Println(*v) //3
+    fmt.Println(ok) //true
+    fmt.Println(li.Data()) //1, 2
+}
+```
+
+
+
+
+### <span id="DeleteAt">DeleteAt</span>
+<p>Delete the value of list at index, if index is not between 0 and length of list data, do nothing</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) DeleteAt(index int)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3, 4})
+
+    li.DeleteAt(-1)
+    fmt.Println(li.Data()) //1,2,3,4
+
+    li.DeleteAt(4)
+    fmt.Println(li.Data()) //1,2,3,4
+
+    li.DeleteAt(0)
+    fmt.Println(li.Data()) //2,3,4
+
+    li.DeleteAt(2)
+    fmt.Println(li.Data()) //2,3
+}
+```
+
+
+
+
+### <span id="InsertAt">InsertAt</span>
+<p>Insert value into list at index, if index is not between 0 and length of list data, do nothing</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) InsertAt(index int, value T)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+
+    li.InsertAt(-1, 0)
+    fmt.Println(li.Data()) //1,2,3
+
+    li.InsertAt(4, 0)
+    fmt.Println(li.Data()) //1,2,3
+
+    li.InsertAt(3, 4)
+    fmt.Println(li.Data()) //1,2,3,4
+
+    // li.InsertAt(2, 4)
+    // fmt.Println(li.Data()) //1,2,4,3
+}
+```
+
+
+
+### <span id="UpdateAt">UpdateAt</span>
+<p>Update value of list at index, index shoud between 0 and list size - 1</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) UpdateAt(index int, value T)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+
+    li.UpdateAt(-1, 0)
+    fmt.Println(li.Data()) //1,2,3
+
+    li.UpdateAt(2, 4)
+    fmt.Println(li.Data()) //1,2,4
+
+    li.UpdateAt(3, 5)
+    fmt.Println(li.Data()) //1,2,4
+}
+```
+
+
+### <span id="Equal">Equal</span>
+<p>Compare a list to another list, use reflect.DeepEqual on every element</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) Equal(other *List[T]) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li1 := list.NewList([]int{1, 2, 3, 4})
+    li2 := list.NewList([]int{1, 2, 3, 4})
+    li3 := list.NewList([]int{1, 2, 3})
+
+    fmt.Println(li1.Equal(li2)) //true
+    fmt.Println(li1.Equal(li3)) //false
+}
+```
+
+
+
+### <span id="IsEmpty">IsEmpty</span>
+<p>Check if a list is empty or not</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) IsEmpty() bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li1 := list.NewList([]int{1, 2, 3})
+    li2 := list.NewList([]int{})
+
+    fmt.Println(li1.IsEmpty()) //false
+    fmt.Println(li2.IsEmpty()) //true
+}
+```
+
+
+
+
+### <span id="Clear">Clear</span>
+<p>Clear the data of list</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) Clear()
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+    li.Clear()
+
+    fmt.Println(li.Data()) // empty
+}
+```
+
+
+
+### <span id="Clone">Clone</span>
+<p>Return a copy of list</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) Clone() *List[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+    cloneList := li.Clone()
+
+    fmt.Println(cloneList.Data()) // 1,2,3
+}
+```
+
+
+
+
+### <span id="Merge">Merge</span>
+<p>Merge two list, return new list, don't change original list</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) Merge(other *List[T]) *List[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li1 := list.NewList([]int{1, 2, 3, 4})
+    li2 := list.NewList([]int{4, 5, 6})
+    li3 := li1.Merge(li2)
+
+    fmt.Println(li3.Data()) //1, 2, 3, 4, 4, 5, 6
+}
+```
+
+
+
+### <span id="Size">Size</span>
+<p>Return number of list data items</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) Size() int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3, 4})
+
+    fmt.Println(li.Size()) //4
+}
+```
+
+
+
+
+### <span id="Swap">Swap</span>
+<p>Swap the value at two index in list</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) Swap(i, j int)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3, 4})
+    li.Swap(0, 3)
+
+    fmt.Println(li.Data()) //4, 2, 3, 1
+}
+```
+
+
+
+
+### <span id="Reverse">Reverse</span>
+<p>Reverse the data item order of list</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) Reverse()
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3, 4})
+    li.Reverse()
+
+    fmt.Println(li.Data()) //4, 3, 2, 1
+}
+```
+
+
+
+
+### <span id="Unique">Unique</span>
+<p>Remove duplicate items in list</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) Unique()
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 2, 3, 4})
+    li.Unique()
+
+    fmt.Println(li.Data()) //1,2,3,4
+}
+```
+
+
+
+
+### <span id="Union">Union</span>
+<p>Creates a new list contain all elements in list l and other, remove duplicate element</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) Union(other *List[T]) *List[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li1 := list.NewList([]int{1, 2, 3, 4})
+    li2 := list.NewList([]int{4, 5, 6})
+    li3 := li1.Union(li2)
+
+    fmt.Println(li3.Data()) //1,2,3,4,5,6
+}
+```
+
+
+
+
+### <span id="Intersection">Intersection</span>
+<p>Creates a new list whose element both be contained in list l and other</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) Intersection(other *List[T]) *List[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li1 := list.NewList([]int{1, 2, 3, 4})
+    li2 := list.NewList([]int{4, 5, 6})
+    li3 := li1.Intersection(li2)
+
+    fmt.Println(li3.Data()) //4
+}
+```
--- a/docs/datastructure/list_zh-CN.md
+++ b/docs/datastructure/list_zh-CN.md
@@ -0,0 +1,712 @@
+# List
+List是线性表数据结构, 用go切片实现。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码
+
+- [https://github.com/duke-git/lancet/blob/main/datastructure/list/list.go](https://github.com/duke-git/lancet/blob/main/datastructure/list/list.go)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法
+```go
+import (
+    "github.com/duke-git/lancet/v2/datastructure"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+- [NewList](#NewList)
+- [Contain](#Contain)
+- [Data](#Data)
+- [ValueOf](#ValueOf)
+- [IndexOf](#IndexOf)
+- [Push](#Push)
+- [PopFirst](#PopFirst)
+- [PopLast](#PopLast)
+- [DeleteAt](#DeleteAt)
+- [InsertAt](#InsertAt)
+- [UpdateAt](#UpdateAt)
+- [Equal](#Equal)
+- [IsEmpty](#IsEmpty)
+- [Clear](#Clear)
+- [Clone](#Clone)
+- [Merge](#Merge)
+- [Size](#Size)
+- [Swap](#Swap)
+- [Reverse](#Reverse)
+- [Unique](#Unique)
+- [Union](#Union)
+- [Intersection](#Intersection)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+### <span id="NewList">NewList</span>
+<p>返回List指针实例</p>
+
+<b>函数签名:</b>
+
+```go
+type List[T any] struct {
+	data []T
+}
+func NewList[T any](data []T) *List[T]
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+    fmt.Println(li)
+}
+```
+
+
+
+### <span id="Contain">Contain</span>
+<p>判断列表中是否包含特定值</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) Contain(value T) bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+
+    fmt.Println(li.Contain(1)) //true
+    fmt.Println(li.Contain(0)) //false
+}
+```
+
+
+
+
+### <span id="Data">Data</span>
+<p>返回List中所有数据（切片）</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) Data() []T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+    data := li.Data()
+
+    fmt.Println(data) //[]int{1, 2, 3}
+}
+```
+
+
+
+
+### <span id="ValueOf">ValueOf</span>
+<p>返回列表中索引处的值指针</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) ValueOf(index int) (*T, bool)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+    v, ok := li.ValueOf(0)
+
+    fmt.Println(*v) //1
+    fmt.Println(ok) //true
+}
+```
+
+
+
+
+### <span id="IndexOf">IndexOf</span>
+<p>返回列表中值的索引，如果没有找到返回-1</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) IndexOf(value T) int
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+
+    fmt.Println(li.IndexOf(1)) //0
+    fmt.Println(li.IndexOf(0)) //-1
+}
+```
+
+
+
+### <span id="Push">Push</span>
+<p>将值附加到列表末尾</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) Push(value T)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+    li.Push(4)
+
+    fmt.Println(li.Data()) //[]int{1, 2, 3, 4}
+}
+```
+
+
+
+
+### <span id="PopFirst">PopFirst</span>
+<p>删除列表的第一个值并返回该值</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) PopFirst() (*T, bool)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+    v, ok := li.PopFirst()
+
+    fmt.Println(*v) //1
+    fmt.Println(ok) //true
+    fmt.Println(li.Data()) //2, 3
+}
+```
+
+
+
+
+
+### <span id="PopLast">PopFirst</span>
+<p>删除列表的最后一个值并返回该值</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) PopLast() (*T, bool)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+    v, ok := li.PopLast()
+
+    fmt.Println(*v) //3
+    fmt.Println(ok) //true
+    fmt.Println(li.Data()) //1, 2
+}
+```
+
+
+
+
+### <span id="DeleteAt">DeleteAt</span>
+<p>删除索引处列表的值，如果索引不在0和列表数据长度之间，则不执行任何操作</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) DeleteAt(index int)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3, 4})
+
+    li.DeleteAt(-1)
+    fmt.Println(li.Data()) //1,2,3,4
+
+    li.DeleteAt(4)
+    fmt.Println(li.Data()) //1,2,3,4
+
+    li.DeleteAt(0)
+    fmt.Println(li.Data()) //2,3,4
+
+    li.DeleteAt(2)
+    fmt.Println(li.Data()) //2,3
+}
+```
+
+
+
+
+### <span id="InsertAt">InsertAt</span>
+<p>在索引处插入值到列表中，如果索引不在 0 和列表数据长度之间，则不执行任何操作</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) InsertAt(index int, value T)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+
+    li.InsertAt(-1, 0)
+    fmt.Println(li.Data()) //1,2,3
+
+    li.InsertAt(4, 0)
+    fmt.Println(li.Data()) //1,2,3
+
+    li.InsertAt(3, 4)
+    fmt.Println(li.Data()) //1,2,3,4
+
+    // li.InsertAt(2, 4)
+    // fmt.Println(li.Data()) //1,2,4,3
+}
+```
+
+
+
+### <span id="UpdateAt">UpdateAt</span>
+<p>更新索引处列表的值，索引应该在0和列表数据长度-1之间</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) UpdateAt(index int, value T)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+
+    li.UpdateAt(-1, 0)
+    fmt.Println(li.Data()) //1,2,3
+
+    li.UpdateAt(2, 4)
+    fmt.Println(li.Data()) //1,2,4
+
+    li.UpdateAt(3, 5)
+    fmt.Println(li.Data()) //1,2,4
+}
+```
+
+
+### <span id="Equal">Equal</span>
+<p>比较一个列表和另一个列表，在每个元素上使用 reflect.DeepEqual</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) Equal(other *List[T]) bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li1 := list.NewList([]int{1, 2, 3, 4})
+    li2 := list.NewList([]int{1, 2, 3, 4})
+    li3 := list.NewList([]int{1, 2, 3})
+
+    fmt.Println(li1.Equal(li2)) //true
+    fmt.Println(li1.Equal(li3)) //false
+}
+```
+
+
+
+### <span id="IsEmpty">IsEmpty</span>
+<p>判断列表是否为空</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) IsEmpty() bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li1 := list.NewList([]int{1, 2, 3})
+    li2 := list.NewList([]int{})
+
+    fmt.Println(li1.IsEmpty()) //false
+    fmt.Println(li2.IsEmpty()) //true
+}
+```
+
+
+
+
+### <span id="Clear">Clear</span>
+<p>清空列表数据</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) Clear()
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+    li.Clear()
+
+    fmt.Println(li.Data()) // empty
+}
+```
+
+
+
+### <span id="Clone">Clone</span>
+<p>返回列表的一个拷贝</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) Clone() *List[T]
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3})
+    cloneList := li.Clone()
+
+    fmt.Println(cloneList.Data()) // 1,2,3
+}
+```
+
+
+
+
+### <span id="Merge">Merge</span>
+<p>合并两个列表，返回新的列表</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) Merge(other *List[T]) *List[T]
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li1 := list.NewList([]int{1, 2, 3, 4})
+    li2 := list.NewList([]int{4, 5, 6})
+    li3 := li1.Merge(li2)
+
+    fmt.Println(li3.Data()) //1, 2, 3, 4, 4, 5, 6
+}
+```
+
+
+
+### <span id="Size">Size</span>
+<p>返回列表数据项的数量</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) Size() int
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3, 4})
+
+    fmt.Println(li.Size()) //4
+}
+```
+
+
+
+
+### <span id="Swap">Swap</span>
+<p>交换列表中两个索引位置的值</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) Swap(i, j int)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3, 4})
+    li.Swap(0, 3)
+
+    fmt.Println(li.Data()) //4, 2, 3, 1
+}
+```
+
+
+
+
+### <span id="Reverse">Reverse</span>
+<p>反转列表的数据项顺序</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) Reverse()
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 3, 4})
+    li.Reverse()
+
+    fmt.Println(li.Data()) //4, 3, 2, 1
+}
+```
+
+
+
+
+### <span id="Unique">Unique</span>
+<p>列表去除重复数据项</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) Unique()
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li := list.NewList([]int{1, 2, 2, 3, 4})
+    li.Unique()
+
+    fmt.Println(li.Data()) //1,2,3,4
+}
+```
+
+
+
+
+### <span id="Union">Union</span>
+<p>两个列表取并集，去除重复数据项</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) Union(other *List[T]) *List[T]
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li1 := list.NewList([]int{1, 2, 3, 4})
+    li2 := list.NewList([]int{4, 5, 6})
+    li3 := li1.Union(li2)
+
+    fmt.Println(li3.Data()) //1,2,3,4,5,6
+}
+```
+
+
+
+
+### <span id="Intersection">Intersection</span>
+<p>两个列表取交集</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) Intersection(other *List[T]) *List[T]
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    li1 := list.NewList([]int{1, 2, 3, 4})
+    li2 := list.NewList([]int{4, 5, 6})
+    li3 := li1.Intersection(li2)
+
+    fmt.Println(li3.Data()) //4
+}
+```
--- a/docs/datastructure/queue.md
+++ b/docs/datastructure/queue.md
--- a/docs/datastructure/queue_zh-CN.md
+++ b/docs/datastructure/queue_zh-CN.md
--- a/docs/datastructure/set.md
+++ b/docs/datastructure/set.md
@@ -0,0 +1,489 @@
+# 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)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage
+```go
+import (
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+
+- [NewSet](#NewSet)
+- [Values](#Values)
+- [Add](#Add)
+- [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>
+
+## Documentation
+
+### <span id="NewSet">NewSet</span>
+<p>Make a Set instance</p>
+
+<b>Signature:</b>
+
+```go
+type Set[T comparable] map[T]bool
+func NewSet[T comparable](values ...T) Set[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    st := set.NewSet[int](1,2,2,3)
+    fmt.Println(st.Values()) //1,2,3
+}
+```
+
+
+
+
+### <span id="Values">Values</span>
+<p>Return slice of all set data</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) Values() []T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    st := set.NewSet[int](1,2,2,3)
+    fmt.Println(st.Values()) //1,2,3
+}
+```
+
+
+
+
+### <span id="Add">Add</span>
+<p>Add value to set</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) Add(values ...T)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    st := set.NewSet[int]()
+    st.Add(1, 2, 3)
+
+    fmt.Println(st.Values()) //1,2,3
+}
+```
+
+
+
+### <span id="Delete">Delete</span>
+<p>Delete value in set</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) Delete(values ...T)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    st := set.NewSet[int]()
+    st.Add(1, 2, 3)
+
+    set.Delete(3)
+    fmt.Println(st.Values()) //1,2
+}
+```
+
+
+
+### <span id="Contain">Contain</span>
+<p>Check if value is in set or not</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) Contain(value T) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    st := set.NewSet[int]()
+    st.Add(1, 2, 3)
+
+    fmt.Println(st.Contain(1)) //true
+    fmt.Println(st.Contain(4)) //false
+}
+```
+
+
+
+
+### <span id="ContainAll">ContainAll</span>
+<p>Checks if set contains another set</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) ContainAll(other Set[T]) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+	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>
+
+```go
+func (s Set[T]) Size() int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+
+    fmt.Println(set1.Size()) //3
+}
+```
+
+
+
+### <span id="Clone">Clone</span>
+<p>Make a copy of set</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) Clone() Set[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+    set2 := set1.Clone()
+
+    fmt.Println(set1.Size() == set2.Size()) //true
+    fmt.Println(set1.ContainAll(set2)) //true
+}
+```
+
+
+
+
+### <span id="Equal">Equal</span>
+<p>Check if two sets has same elements or not</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) Equal(other Set[T]) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+    set2 := set.NewSet(1, 2, 3)
+    set3 := set.NewSet(1, 2, 3, 4)
+
+    fmt.Println(set1.Equal(set2)) //true
+    fmt.Println(set1.Equal(set3)) //false
+}
+```
+
+
+
+### <span id="Iterate">Iterate</span>
+<p>Call function by every element of set</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) Iterate(fn func(value T))
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+    arr := []int{}
+    set.Iterate(func(value int) {
+        arr = append(arr, value)
+    })
+
+    fmt.Println(arr) //1,2,3
+}
+```
+
+
+
+### <span id="IsEmpty">IsEmpty</span>
+<p>Check if the set is empty or not</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) IsEmpty() bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+    set2 := set.NewSet()
+
+    fmt.Println(set1.IsEmpty()) //false
+    fmt.Println(set2.IsEmpty()) //true
+}
+```
+
+
+
+### <span id="Union">Union</span>
+<p>Create a new set contain all element of set s and other</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) Union(other Set[T]) Set[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+    set2 := set.NewSet(2, 3, 4, 5)
+    set3 := set1.Union(set2)
+
+    fmt.Println(set3.Values()) //1,2,3,4,5
+}
+```
+
+
+
+### <span id="Intersection">Intersection</span>
+<p>Create a new set whose element both be contained in set s and other</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) Intersection(other Set[T]) Set[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+    set2 := set.NewSet(2, 3, 4, 5)
+    set3 := set1.Intersection(set2)
+
+    fmt.Println(set3.Values()) //2,3
+}
+```
+
+
+
+
+
+### <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>
+
+```go
+func (s Set[T]) SymmetricDifference(other Set[T]) Set[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+	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>
+
+```go
+func (s Set[T]) Minus(comparedSet Set[T]) Set[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+	set2 := set.NewSet(2, 3, 4, 5)
+	set3 := set.NewSet(2, 3)
+
+    res1 := set1.Minus(set2)
+    fmt.Println(res1.Values()) //1
+
+    res2 := set2.Minus(set3)
+    fmt.Println(res2.Values()) //4,5
+}
+```
+
+
+
--- a/docs/datastructure/set_zh-CN.md
+++ b/docs/datastructure/set_zh-CN.md
@@ -0,0 +1,489 @@
+# 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)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法
+```go
+import (
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+- [NewSet](#NewSet)
+- [Values](#Values)
+- [Add](#Add)
+- [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>
+
+```go
+type Set[T comparable] map[T]bool
+func NewSet[T comparable](values ...T) Set[T]
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    st := set.NewSet[int](1,2,2,3)
+    fmt.Println(st.Values()) //1,2,3
+}
+```
+
+
+
+
+### <span id="Values">Values</span>
+<p>获取集合中所有元素的切片</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) Values() []T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    st := set.NewSet[int](1,2,2,3)
+    fmt.Println(st.Values()) //1,2,3
+}
+```
+
+
+
+
+### <span id="Add">Add</span>
+<p>向集合中添加元素</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) Add(values ...T)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    st := set.NewSet[int]()
+    st.Add(1, 2, 3)
+
+    fmt.Println(st.Values()) //1,2,3
+}
+```
+
+
+
+### <span id="Delete">Delete</span>
+<p>删除集合中元素</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) Delete(values ...T)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    st := set.NewSet[int]()
+    st.Add(1, 2, 3)
+
+    set.Delete(3)
+    fmt.Println(st.Values()) //1,2
+}
+```
+
+
+
+### <span id="Contain">Contain</span>
+<p>判断集合是否包含某个值</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) Contain(value T) bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    st := set.NewSet[int]()
+    st.Add(1, 2, 3)
+
+    fmt.Println(st.Contain(1)) //true
+    fmt.Println(st.Contain(4)) //false
+}
+```
+
+
+
+
+### <span id="ContainAll">ContainAll</span>
+<p>判断集合是否包含另一个集合</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) ContainAll(other Set[T]) bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+	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>
+
+```go
+func (s Set[T]) Size() int
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+
+    fmt.Println(set1.Size()) //3
+}
+```
+
+
+
+### <span id="Clone">Clone</span>
+<p>克隆一个集合</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) Clone() Set[T]
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+    set2 := set1.Clone()
+
+    fmt.Println(set1.Size() == set2.Size()) //true
+    fmt.Println(set1.ContainAll(set2)) //true
+}
+```
+
+
+
+
+### <span id="Equal">Equal</span>
+<p>比较两个集合是否相等，包含相同元素为相等</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) Equal(other Set[T]) bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+    set2 := set.NewSet(1, 2, 3)
+    set3 := set.NewSet(1, 2, 3, 4)
+
+    fmt.Println(set1.Equal(set2)) //true
+    fmt.Println(set1.Equal(set3)) //false
+}
+```
+
+
+
+### <span id="Iterate">Iterate</span>
+<p>迭代结合，在每个元素上调用函数</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) Iterate(fn func(value T))
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+    arr := []int{}
+    set.Iterate(func(value int) {
+        arr = append(arr, value)
+    })
+
+    fmt.Println(arr) //1,2,3
+}
+```
+
+
+
+### <span id="IsEmpty">IsEmpty</span>
+<p>判断集合是否为空</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) IsEmpty() bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+    set2 := set.NewSet()
+
+    fmt.Println(set1.IsEmpty()) //false
+    fmt.Println(set2.IsEmpty()) //true
+}
+```
+
+
+
+### <span id="Union">Union</span>
+<p>求两个集合的并集</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) Union(other Set[T]) Set[T]
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+    set2 := set.NewSet(2, 3, 4, 5)
+    set3 := set1.Union(set2)
+
+    fmt.Println(set3.Values()) //1,2,3,4,5
+}
+```
+
+
+
+### <span id="Intersection">Intersection</span>
+<p>求两个集合的交集</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) Intersection(other Set[T]) Set[T]
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+    set2 := set.NewSet(2, 3, 4, 5)
+    set3 := set1.Intersection(set2)
+
+    fmt.Println(set3.Values()) //2,3
+}
+```
+
+
+
+
+
+### <span id="SymmetricDifference">SymmetricDifference</span>
+<p>返回一个集合，其中元素在第一个集合或第二个集合中，且不同时存在于两个集合中</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) SymmetricDifference(other Set[T]) Set[T]
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+	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>
+
+```go
+func (s Set[T]) Minus(comparedSet Set[T]) Set[T]
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    set "github.com/duke-git/lancet/v2/datastructure/set"
+)
+
+func main() {
+    set1 := set.NewSet(1, 2, 3)
+	set2 := set.NewSet(2, 3, 4, 5)
+	set3 := set.NewSet(2, 3)
+
+    res1 := set1.Minus(set2)
+    fmt.Println(res1.Values()) //1
+
+    res2 := set2.Minus(set3)
+    fmt.Println(res2.Values()) //4,5
+}
+```
+
+
+
--- a/docs/datastructure/stack.md
+++ b/docs/datastructure/stack.md
@@ -0,0 +1,611 @@
+# Stack
+Stack is an abstract data type that serves as a collection of elements. Elements follow the LIFO principle. FIFO is last-in, first-out, meaning that the most recently produced items are recorded as sold first.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source
+
+- [https://github.com/duke-git/lancet/blob/main/datastructure/stack/arraystack.go](https://github.com/duke-git/lancet/blob/main/datastructure/stack/arraystack.go)
+- [https://github.com/duke-git/lancet/blob/main/datastructure/stack/linkedstack.go](https://github.com/duke-git/lancet/blob/main/datastructure/stack/linkedstack.go)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage
+```go
+import (
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+
+### 1. ArrayStack
+
+- [NewArrayStack](#NewArrayStack)
+- [Push](#ArrayStack_Push)
+- [Pop](#ArrayStack_Pop)
+- [Peak](#ArrayStack_Peak)
+- [Data](#ArrayStack_Data)
+- [Size](#ArrayStack_Size)
+- [IsEmpty](#ArrayStack_IsEmpty)
+- [Clear](#ArrayStack_Clear)
+
+### 2. LinkedStack
+
+- [NewLinkedStack](#NewLinkedStack)
+- [Push](#LinkedStack_Push)
+- [Pop](#LinkedStack_Pop)
+- [Peak](#LinkedStack_Peak)
+- [Data](#LinkedStack_Data)
+- [Size](#LinkedStack_Size)
+- [IsEmpty](#LinkedStack_IsEmpty)
+- [Clear](#LinkedStack_Clear)
+- [Print](#LinkedStack_Print)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+### 1. ArrayStack
+ArrayStack is a stack implemented by slice.
+
+### <span id="NewArrayStack">NewArrayStack</span>
+<p>Return a empty ArrayStack pointer</p>
+
+<b>Signature:</b>
+
+```go
+type ArrayStack[T any] struct {
+	data   []T
+	length int
+}
+func NewArrayStack[T any]() *ArrayStack[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewArrayStack[int]()
+    fmt.Println(sk)
+}
+```
+
+
+
+
+### <span id="ArrayStack_Push">Push</span>
+<p>Push element into array stack</p>
+
+<b>Signature:</b>
+
+```go
+func (s *ArrayStack[T]) Push(value T)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewArrayStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    fmt.Println(sk.Data()) //[]int{3, 2, 1}
+}
+```
+
+
+
+
+### <span id="ArrayStack_Pop">Pop</span>
+<p>Delete the top element of stack then return it, if stack is empty, return nil and error</p>
+
+<b>Signature:</b>
+
+```go
+func (s *ArrayStack[T]) Pop() (*T, error)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewArrayStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    val, err := sk.Pop()
+    fmt.Println(err) //nil
+    fmt.Println(*val) //3
+
+    fmt.Println(sk.Data()) //[]int{2, 1}
+}
+```
+
+
+
+
+### <span id="ArrayStack_Peak">Peak</span>
+<p>Return the top element of array stack</p>
+
+<b>Signature:</b>
+
+```go
+func (s *ArrayStack[T]) Peak() (*T, error)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewArrayStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    val, err := sk.Peak()
+    fmt.Println(err) //nil
+    fmt.Println(*val) //3
+
+    fmt.Println(sk.Data()) //[]int{3, 2, 1}
+}
+```
+
+
+
+
+### <span id="ArrayStack_Data">Data</span>
+<p>Return a slice of all data in array stack</p>
+
+<b>Signature:</b>
+
+```go
+func (s *ArrayStack[T]) Data() []T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewArrayStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    fmt.Println(sk.Data()) //[]int{3, 2, 1}
+}
+```
+
+
+
+
+### <span id="ArrayStack_Size">Size</span>
+<p>Return number of elements in array stack</p>
+
+<b>Signature:</b>
+
+```go
+func (s *ArrayStack[T]) Size() int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewArrayStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    fmt.Println(sk.Size()) //3
+}
+```
+
+
+
+
+### <span id="ArrayStack_IsEmpty">IsEmpty</span>
+<p>Check if array stack is empty or not</p>
+
+<b>Signature:</b>
+
+```go
+func (s *ArrayStack[T]) IsEmpty() bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewArrayStack[int]()
+    fmt.Println(sk.IsEmpty()) //true
+
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    fmt.Println(sk.IsEmpty()) //false
+}
+```
+
+
+
+
+### <span id="ArrayStack_Clear">Clear</span>
+<p>Clear all elments in array stack</p>
+
+<b>Signature:</b>
+
+```go
+func (s *ArrayStack[T]) Clear()
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewArrayStack[int]()
+
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    sk.Clear()
+
+    fmt.Println(sk.Data()) //[]int{}
+}
+```
+
+
+
+### 2. LinkedStack
+LinkedStack is a stack implemented by linked list.
+
+### <span id="NewLinkedStack">NewLinkedStack</span>
+<p>Return a empty LinkedStack pointer</p>
+
+<b>Signature:</b>
+
+```go
+type StackNode[T any] struct {
+	Value T
+	Next  *StackNode[T]
+}
+type LinkedStack[T any] struct {
+	top    *datastructure.StackNode[T]
+	length int
+}
+func NewLinkedStack[T any]() *LinkedStack[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+    fmt.Println(sk)
+}
+```
+
+
+
+
+### <span id="LinkedStack_Push">Push</span>
+<p>Push element into linked stack</p>
+
+<b>Signature:</b>
+
+```go
+func (s *LinkedStack[T]) Push(value T)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    fmt.Println(sk.Data()) //[]int{3, 2, 1}
+}
+```
+
+
+
+
+### <span id="LinkedStack_Pop">Pop</span>
+<p>Delete the top element of stack then return it, if stack is empty, return nil and error</p>
+
+<b>Signature:</b>
+
+```go
+func (s *LinkedStack[T]) Pop() (*T, error)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    val, err := sk.Pop()
+    fmt.Println(err) //nil
+    fmt.Println(*val) //3
+
+    fmt.Println(sk.Data()) //[]int{2, 1}
+}
+```
+
+
+
+
+### <span id="LinkedStack_Peak">Peak</span>
+<p>Return the top element of linked stack</p>
+
+<b>Signature:</b>
+
+```go
+func (s *LinkedStack[T]) Peak() (*T, error)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    val, err := sk.Peak()
+    fmt.Println(err) //nil
+    fmt.Println(*val) //3
+
+    fmt.Println(sk.Data()) //[]int{3, 2, 1}
+}
+```
+
+
+
+
+### <span id="LinkedStack_Data">Data</span>
+<p>Return a slice of all data in linked stack</p>
+
+<b>Signature:</b>
+
+```go
+func (s *LinkedStack[T]) Data() []T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    fmt.Println(sk.Data()) //[]int{3, 2, 1}
+}
+```
+
+
+
+
+### <span id="LinkedStack_Size">Size</span>
+<p>Return number of elements in linked stack</p>
+
+<b>Signature:</b>
+
+```go
+func (s *LinkedStack[T]) Size() int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    fmt.Println(sk.Size()) //3
+}
+```
+
+
+
+
+### <span id="LinkedStack_IsEmpty">IsEmpty</span>
+<p>Check if linked stack is empty or not</p>
+
+<b>Signature:</b>
+
+```go
+func (s *LinkedStack[T]) IsEmpty() bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+    fmt.Println(sk.IsEmpty()) //true
+
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    fmt.Println(sk.IsEmpty()) //false
+}
+```
+
+
+
+
+### <span id="LinkedStack_Clear">Clear</span>
+<p>Clear all elments in linked stack</p>
+
+<b>Signature:</b>
+
+```go
+func (s *LinkedStack[T]) Clear()
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    sk.Clear()
+
+    fmt.Println(sk.Data()) //[]int{}
+}
+```
+
+
+
+
+### <span id="LinkedStack_Print">Print</span>
+<p>Print the structure of a linked stack</p>
+
+<b>Signature:</b>
+
+```go
+func (s *LinkedStack[T]) Print()
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+
+    sk.Print() //[ &{Value:3 Next:0xc000010260}, &{Value:2 Next:0xc000010250}, &{Value:1 Next:<nil>},  ]
+}
+```
--- a/docs/datastructure/stack_zh-CN.md
+++ b/docs/datastructure/stack_zh-CN.md
@@ -0,0 +1,611 @@
+# Stack
+栈数据结构，包括ArrayStack（数组栈）和LinkedStack（链表栈）。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码
+
+- [https://github.com/duke-git/lancet/blob/main/datastructure/stack/arraystack.go](https://github.com/duke-git/lancet/blob/main/datastructure/stack/arraystack.go)
+- [https://github.com/duke-git/lancet/blob/main/datastructure/stack/linkedstack.go](https://github.com/duke-git/lancet/blob/main/datastructure/stack/linkedstack.go)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法
+```go
+import (
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+### 1. ArrayStack（数组栈）
+
+- [NewArrayStack](#NewArrayStack)
+- [Push](#ArrayStack_Push)
+- [Pop](#ArrayStack_Pop)
+- [Peak](#ArrayStack_Peak)
+- [Data](#ArrayStack_Data)
+- [Size](#ArrayStack_Size)
+- [IsEmpty](#ArrayStack_IsEmpty)
+- [Clear](#ArrayStack_Clear)
+
+### 2. LinkedStack（链表栈）
+
+- [NewLinkedStack](#NewLinkedStack)
+- [Push](#LinkedStack_Push)
+- [Pop](#LinkedStack_Pop)
+- [Peak](#LinkedStack_Peak)
+- [Data](#LinkedStack_Data)
+- [Size](#LinkedStack_Size)
+- [IsEmpty](#LinkedStack_IsEmpty)
+- [Clear](#LinkedStack_Clear)
+- [Print](#LinkedStack_Print)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+### 1. ArrayStack
+用切片实现栈结构
+
+### <span id="NewArrayStack">NewArrayStack</span>
+<p>返回ArrayStack指针实例</p>
+
+<b>函数签名:</b>
+
+```go
+type ArrayStack[T any] struct {
+	data   []T
+	length int
+}
+func NewArrayStack[T any]() *ArrayStack[T]
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewArrayStack[int]()
+    fmt.Println(sk)
+}
+```
+
+
+
+
+### <span id="ArrayStack_Push">Push</span>
+<p>将元素加入数组栈</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *ArrayStack[T]) Push(value T)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewArrayStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    fmt.Println(sk.Data()) //[]int{3, 2, 1}
+}
+```
+
+
+
+
+### <span id="ArrayStack_Pop">Pop</span>
+<p>删除栈顶元素并返回该元素指针</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *ArrayStack[T]) Pop() (*T, error)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewArrayStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    val, err := sk.Pop()
+    fmt.Println(err) //nil
+    fmt.Println(*val) //3
+
+    fmt.Println(sk.Data()) //[]int{2, 1}
+}
+```
+
+
+
+
+### <span id="ArrayStack_Peak">Peak</span>
+<p>返回栈顶元素指针</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *ArrayStack[T]) Peak() (*T, error)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewArrayStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    val, err := sk.Peak()
+    fmt.Println(err) //nil
+    fmt.Println(*val) //3
+
+    fmt.Println(sk.Data()) //[]int{3, 2, 1}
+}
+```
+
+
+
+
+### <span id="ArrayStack_Data">Data</span>
+<p>返回栈中所有元素组成的切片</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *ArrayStack[T]) Data() []T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewArrayStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    fmt.Println(sk.Data()) //[]int{3, 2, 1}
+}
+```
+
+
+
+
+### <span id="ArrayStack_Size">Size</span>
+<p>返回栈中元素的数量</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *ArrayStack[T]) Size() int
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewArrayStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    fmt.Println(sk.Size()) //3
+}
+```
+
+
+
+
+### <span id="ArrayStack_IsEmpty">IsEmpty</span>
+<p>判断栈是否为空</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *ArrayStack[T]) IsEmpty() bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewArrayStack[int]()
+    fmt.Println(sk.IsEmpty()) //true
+
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    fmt.Println(sk.IsEmpty()) //false
+}
+```
+
+
+
+
+### <span id="ArrayStack_Clear">Clear</span>
+<p>清空栈元素，使栈为空</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *ArrayStack[T]) Clear()
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewArrayStack[int]()
+
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    sk.Clear()
+
+    fmt.Println(sk.Data()) //[]int{}
+}
+```
+
+
+
+### 2. LinkedStack
+链表实现的栈结构。
+
+### <span id="NewLinkedStack">NewLinkedStack</span>
+<p>返回LinkedStack指针实例</p>
+
+<b>函数签名:</b>
+
+```go
+type StackNode[T any] struct {
+	Value T
+	Next  *StackNode[T]
+}
+type LinkedStack[T any] struct {
+	top    *datastructure.StackNode[T]
+	length int
+}
+func NewLinkedStack[T any]() *LinkedStack[T]
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+    fmt.Println(sk)
+}
+```
+
+
+
+
+### <span id="LinkedStack_Push">Push</span>
+<p>将元素加入链表栈</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *LinkedStack[T]) Push(value T)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    fmt.Println(sk.Data()) //[]int{3, 2, 1}
+}
+```
+
+
+
+
+### <span id="LinkedStack_Pop">Pop</span>
+<p>删除栈顶元素并返回该元素指针</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *LinkedStack[T]) Pop() (*T, error)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    val, err := sk.Pop()
+    fmt.Println(err) //nil
+    fmt.Println(*val) //3
+
+    fmt.Println(sk.Data()) //[]int{2, 1}
+}
+```
+
+
+
+
+### <span id="LinkedStack_Peak">Peak</span>
+<p>返回栈顶元素指针</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *LinkedStack[T]) Peak() (*T, error)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    val, err := sk.Peak()
+    fmt.Println(err) //nil
+    fmt.Println(*val) //3
+
+    fmt.Println(sk.Data()) //[]int{3, 2, 1}
+}
+```
+
+
+
+
+### <span id="LinkedStack_Data">Data</span>
+<p>返回栈中所有元素组成的切片</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *LinkedStack[T]) Data() []T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    fmt.Println(sk.Data()) //[]int{3, 2, 1}
+}
+```
+
+
+
+
+### <span id="LinkedStack_Size">Size</span>
+<p>返回栈中元素的数量</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *LinkedStack[T]) Size() int
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    fmt.Println(sk.Size()) //3
+}
+```
+
+
+
+
+### <span id="LinkedStack_IsEmpty">IsEmpty</span>
+<p>判断栈是否为空</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *LinkedStack[T]) IsEmpty() bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+    fmt.Println(sk.IsEmpty()) //true
+
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    fmt.Println(sk.IsEmpty()) //false
+}
+```
+
+
+
+
+### <span id="LinkedStack_Clear">Clear</span>
+<p>清空栈元素，使栈为空</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *LinkedStack[T]) Clear()
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+    sk.Clear()
+
+    fmt.Println(sk.Data()) //[]int{}
+}
+```
+
+
+
+
+### <span id="LinkedStack_Print">Print</span>
+<p>打印链表栈结构</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *LinkedStack[T]) Print()
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    stack "github.com/duke-git/lancet/v2/datastructure/stack"
+)
+
+func main() {
+    sk := stack.NewLinkedStack[int]()
+
+    sk.Push(1)
+    sk.Push(2)
+    sk.Push(3)
+
+
+    sk.Print() //[ &{Value:3 Next:0xc000010260}, &{Value:2 Next:0xc000010250}, &{Value:1 Next:<nil>},  ]
+}
+```
--- a/docs/datastructure/tree.md
+++ b/docs/datastructure/tree.md
@@ -0,0 +1,527 @@
+# Tree
+Tree is a collection of tree nodes. Each tree node has a value, a left pointer point to left node and a right pointer point to right node.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source
+
+- [https://github.com/duke-git/lancet/blob/main/datastructure/tree/bstree.go](https://github.com/duke-git/lancet/blob/main/datastructure/tree/bstree.go)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage
+```go
+import (
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+
+### 1. BSTree
+
+- [NewBSTree](#NewBSTree)
+- [Insert](#BSTree_Insert)
+- [Delete](#BSTree_Delete)
+- [PreOrderTraverse](#BSTree_PreOrderTraverse)
+- [InOrderTraverse](#BSTree_InOrderTraverse)
+- [PostOrderTraverse](#BSTree_PostOrderTraverse)
+  
+- [LevelOrderTraverse](#BSTree_LevelOrderTraverse)
+- [Depth](#BSTree_Depth)
+- [HasSubTree](#BSTree_HasSubTree)
+- [Print](#BSTree_Print)
+
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+## 1. BSTree
+BSTree is a binary search tree data structure in which each node has at two children, which are referred to as the left child and the right child. In BSTree: leftNode < rootNode < rightNode. Type T should implements Compare function in lancetconstraints.Comparator interface.
+
+### <span id="NewBSTree">NewBSTree</span>
+<p>Make a BSTree pointer instance</p>
+
+<b>Signature:</b>
+
+```go
+func NewBSTree[T any](rootData T, comparator lancetconstraints.Comparator) *BSTree[T]
+
+type BSTree[T any] struct {
+	root       *datastructure.TreeNode[T]
+	comparator lancetconstraints.Comparator
+}
+
+type TreeNode[T any] struct {
+	Value T
+	Left  *TreeNode[T]
+	Right *TreeNode[T]
+}
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    fmt.Println(bstree) //
+}
+```
+
+
+
+
+### <span id="BSTree_Insert">Insert</span>
+<p>Insert value into binary search tree</p>
+
+<b>Signature:</b>
+
+```go
+func (t *BSTree[T]) Insert(data T)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+    fmt.Println(bstree.PreOrderTraverse()) //6, 5, 2, 4, 7
+}
+```
+
+
+
+
+### <span id="BSTree_Delete">Delete</span>
+<p>Delete value of binary search tree</p>
+
+<b>Signature:</b>
+
+```go
+func (t *BSTree[T]) Delete(data T)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+    bstree.Delete(4)
+
+    fmt.Println(bstree.PreOrderTraverse()) //2, 5, 6, 7
+}
+```
+
+
+
+
+### <span id="BSTree_PreOrderTraverse">PreOrderTraverse</span>
+<p>Traverse tree nodes in pre order</p>
+
+<b>Signature:</b>
+
+```go
+func (t *BSTree[T]) PreOrderTraverse() []T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+    fmt.Println(bstree.PreOrderTraverse()) //6, 5, 2, 4, 7
+}
+```
+
+
+
+
+### <span id="BSTree_InOrderTraverse">InOrderTraverse</span>
+<p>Traverse tree nodes in middle order</p>
+
+<b>Signature:</b>
+
+```go
+func (t *BSTree[T]) InOrderTraverse() []T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+    fmt.Println(bstree.InOrderTraverse()) //2, 4, 5, 6, 7
+}
+```
+
+
+
+
+### <span id="BSTree_PostOrderTraverse">PostOrderTraverse</span>
+<p>Traverse tree nodes in post order</p>
+
+<b>Signature:</b>
+
+```go
+func (t *BSTree[T]) PostOrderTraverse() []T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+    fmt.Println(bstree.PostOrderTraverse()) //5, 2, 4, 7, 6
+}
+```
+
+
+
+
+### <span id="BSTree_LevelOrderTraverse">LevelOrderTraverse</span>
+<p>Traverse tree nodes in node level order</p>
+
+<b>Signature:</b>
+
+```go
+func (t *BSTree[T]) LevelOrderTraverse() []T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+    fmt.Println(bstree.LevelOrderTraverse()) //6, 5, 7, 2, 4
+}
+```
+
+
+
+
+### <span id="BSTree_Depth">Depth</span>
+<p>Get the depth of a binary saerch tree</p>
+
+<b>Signature:</b>
+
+```go
+func (t *BSTree[T]) Depth() int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+    fmt.Println(bstree.Depth()) //4
+}
+```
+
+
+
+
+### <span id="BSTree_HasSubTree">HasSubTree</span>
+<p>Check if the given tree is sub tree of origin tree or not</p>
+
+<b>Signature:</b>
+
+```go
+func (t *BSTree[T]) HasSubTree(subTree *BSTree[T]) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    superTree := tree.NewBSTree(8, &intComparator{})
+	superTree.Insert(4)
+	superTree.Insert(5)
+	superTree.Insert(6)
+	superTree.Insert(9)
+	superTree.Insert(4)
+
+    subTree := tree.NewBSTree(5, &intComparator{})
+	subTree.Insert(4)
+	subTree.Insert(6)
+
+    fmt.Println(superTree.HasSubTree(subTree)) //true
+    fmt.Println(subTree.HasSubTree(superTree)) //false
+}
+```
+
+
+
+
+### <span id="BSTree_Print">Print</span>
+<p>Print the structure of binary saerch tree</p>
+
+<b>Signature:</b>
+
+```go
+func (t *BSTree[T]) Print()
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+    fmt.Println(bstree.Print())
+//        6
+//       / \
+//      /   \
+//     /     \
+//    /       \
+//    5       7
+//   /
+//  /
+//  2
+//   \
+//    4
+}
+```
--- a/docs/datastructure/tree_zh-CN.md
+++ b/docs/datastructure/tree_zh-CN.md
@@ -0,0 +1,527 @@
+# Tree
+树是树节点的集合。 每个树节点都有一个值，一个指向左节点的左指针和一个指向右节点的右指针。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码
+
+- [https://github.com/duke-git/lancet/blob/main/datastructure/tree/bstree.go](https://github.com/duke-git/lancet/blob/main/datastructure/tree/bstree.go)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法
+```go
+import (
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+### 1. BSTree
+
+- [NewBSTree](#NewBSTree)
+- [Insert](#BSTree_Insert)
+- [Delete](#BSTree_Delete)
+- [PreOrderTraverse](#BSTree_PreOrderTraverse)
+- [InOrderTraverse](#BSTree_InOrderTraverse)
+- [PostOrderTraverse](#BSTree_PostOrderTraverse)
+  
+- [LevelOrderTraverse](#BSTree_LevelOrderTraverse)
+- [Depth](#BSTree_Depth)
+- [HasSubTree](#BSTree_HasSubTree)
+- [Print](#BSTree_Print)
+
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+## 1. BSTree
+BSTree是一种二叉搜索树数据结构，其中每个节点有两个孩子，分别称为左孩子和右孩子。 在 BSTree 中：leftNode < rootNode < rightNode。 T类型应该实现lancetconstraints.Comparator。
+
+### <span id="NewBSTree">NewBSTree</span>
+<p>返回BSTree指针实例</p>
+
+<b>函数签名:</b>
+
+```go
+func NewBSTree[T any](rootData T, comparator lancetconstraints.Comparator) *BSTree[T]
+
+type BSTree[T any] struct {
+	root       *datastructure.TreeNode[T]
+	comparator lancetconstraints.Comparator
+}
+
+type TreeNode[T any] struct {
+	Value T
+	Left  *TreeNode[T]
+	Right *TreeNode[T]
+}
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    fmt.Println(bstree) //
+}
+```
+
+
+
+
+### <span id="BSTree_Insert">Insert</span>
+<p>将值插入二叉搜索树</p>
+
+<b>函数签名:</b>
+
+```go
+func (t *BSTree[T]) Insert(data T)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+    fmt.Println(bstree.PreOrderTraverse()) //6, 5, 2, 4, 7
+}
+```
+
+
+
+
+### <span id="BSTree_Delete">Delete</span>
+<p>删除插入二叉搜索树中指定的值</p>
+
+<b>函数签名:</b>
+
+```go
+func (t *BSTree[T]) Delete(data T)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+    bstree.Delete(4)
+
+    fmt.Println(bstree.PreOrderTraverse()) //2, 5, 6, 7
+}
+```
+
+
+
+
+### <span id="BSTree_PreOrderTraverse">PreOrderTraverse</span>
+<p>按前序遍历树节点</p>
+
+<b>函数签名:</b>
+
+```go
+func (t *BSTree[T]) PreOrderTraverse() []T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+    fmt.Println(bstree.PreOrderTraverse()) //6, 5, 2, 4, 7
+}
+```
+
+
+
+
+### <span id="BSTree_InOrderTraverse">InOrderTraverse</span>
+<p>按中序遍历树节点</p>
+
+<b>函数签名:</b>
+
+```go
+func (t *BSTree[T]) InOrderTraverse() []T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+    fmt.Println(bstree.InOrderTraverse()) //2, 4, 5, 6, 7
+}
+```
+
+
+
+
+### <span id="BSTree_PostOrderTraverse">PostOrderTraverse</span>
+<p>按后序遍历树节点</p>
+
+<b>函数签名:</b>
+
+```go
+func (t *BSTree[T]) PostOrderTraverse() []T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+    fmt.Println(bstree.PostOrderTraverse()) //5, 2, 4, 7, 6
+}
+```
+
+
+
+
+### <span id="BSTree_LevelOrderTraverse">LevelOrderTraverse</span>
+<p>按节点层次遍历树节点</p>
+
+<b>函数签名:</b>
+
+```go
+func (t *BSTree[T]) LevelOrderTraverse() []T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+    fmt.Println(bstree.LevelOrderTraverse()) //6, 5, 7, 2, 4
+}
+```
+
+
+
+
+### <span id="BSTree_Depth">Depth</span>
+<p>获取树的深度</p>
+
+<b>函数签名:</b>
+
+```go
+func (t *BSTree[T]) Depth() int
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+    fmt.Println(bstree.Depth()) //4
+}
+```
+
+
+
+
+### <span id="BSTree_HasSubTree">HasSubTree</span>
+<p>判断给定树是否是子树</p>
+
+<b>函数签名:</b>
+
+```go
+func (t *BSTree[T]) HasSubTree(subTree *BSTree[T]) bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    superTree := tree.NewBSTree(8, &intComparator{})
+	superTree.Insert(4)
+	superTree.Insert(5)
+	superTree.Insert(6)
+	superTree.Insert(9)
+	superTree.Insert(4)
+
+    subTree := tree.NewBSTree(5, &intComparator{})
+	subTree.Insert(4)
+	subTree.Insert(6)
+
+    fmt.Println(superTree.HasSubTree(subTree)) //true
+    fmt.Println(subTree.HasSubTree(superTree)) //false
+}
+```
+
+
+
+
+### <span id="BSTree_Print">Print</span>
+<p>打印树结构</p>
+
+<b>函数签名:</b>
+
+```go
+func (t *BSTree[T]) Print()
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    tree "github.com/duke-git/lancet/v2/datastructure/tree"
+)
+
+type intComparator struct{}
+
+func (c *intComparator) Compare(v1, v2 any) int {
+	val1, _ := v1.(int)
+	val2, _ := v2.(int)
+
+	if val1 < val2 {
+		return -1
+	} else if val1 > val2 {
+		return 1
+	}
+	return 0
+}
+
+func main() {
+    bstree := tree.NewBSTree(6, &intComparator{})
+    bstree.Insert(7)
+	bstree.Insert(5)
+	bstree.Insert(2)
+	bstree.Insert(4)
+
+    fmt.Println(bstree.Print())
+//        6
+//       / \
+//      /   \
+//     /     \
+//    /       \
+//    5       7
+//   /
+//  /
+//  2
+//   \
+//    4
+}
+```
--- a/docs/datetime.md
+++ b/docs/datetime.md
@@ -5,14 +5,15 @@ Package datetime supports date and time format and compare.

 ## Source:

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

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

 ## Usage:
 ```go
 import (
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )
 ```

@@ -28,7 +29,6 @@ import (
 - [BeginOfWeek](#BeginOfWeek)
 - [BeginOfMonth](#BeginOfMonth)
 - [BeginOfYear](#BeginOfYear)
-
 - [EndOfMinute](#EndOfMinute)
 - [EndOfHour](#EndOfHour)
 - [EndOfDay](#EndOfDay)
@@ -41,9 +41,19 @@ import (
 - [GetZeroHourTimestamp](#GetZeroHourTimestamp)
 - [GetNightTimestamp](#GetNightTimestamp)
 - [FormatTimeToStr](#FormatTimeToStr)
-
 - [FormatStrToTime](#FormatStrToTime)

+- [NewUnixNow](#NewUnixNow)
+- [NewUnix](#NewUnix)
+- [NewFormat](#NewFormat)
+- [NewISO8601](#NewISO8601)
+- [ToUnix](#ToUnix)
+- [ToFormat](#ToFormat)
+- [ToFormatForTpl](#ToFormatForTpl)
+- [ToIso8601](#ToIso8601)
+
+
+
 <div STYLE="page-break-after: always;"></div>

 ## Documentation
@@ -86,7 +96,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -115,7 +125,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -143,7 +153,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -171,7 +181,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -197,7 +207,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -223,7 +233,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -251,7 +261,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -279,7 +289,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -306,7 +316,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -334,7 +344,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -360,7 +370,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -386,7 +396,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -414,7 +424,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -442,7 +452,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -469,7 +479,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -496,7 +506,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -523,7 +533,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -550,7 +560,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -577,7 +587,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -604,7 +614,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -630,7 +640,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -656,7 +666,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -667,3 +677,221 @@ func main() {



+### <span id="NewUnixNow">NewUnixNow</span>
+<p>Return unix timestamp of current time</p>
+
+<b>Signature:</b>
+
+```go
+type theTime struct {
+	unix int64
+}
+func NewUnixNow() *theTime
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    tm := datetime.NewUnixNow()
+    fmt.Println(tm) //&{1647597438}
+}
+```
+
+
+### <span id="NewUnix">NewUnix</span>
+<p>Return unix timestamp of specified int64 value.</p>
+
+<b>Signature:</b>
+
+```go
+type theTime struct {
+	unix int64
+}
+func NewUnix(unix int64) *theTime
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    tm := datetime.NewUnix(1647597438)
+    fmt.Println(tm) //&{1647597438}
+}
+```
+
+
+
+### <span id="NewFormat">NewFormat</span>
+<p>Return unix timestamp of specified time string, t should be "yyyy-mm-dd hh:mm:ss".</p>
+
+<b>Signature:</b>
+
+```go
+type theTime struct {
+	unix int64
+}
+func NewFormat(t string) (*theTime, error)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    tm, err := datetime.NewFormat("2022-03-18 17:04:05")
+    fmt.Println(tm) //&{1647594245}
+}
+```
+
+
+
+
+### <span id="NewISO8601">NewISO8601</span>
+<p>Return unix timestamp of specified iso8601 time string.</p>
+
+<b>Signature:</b>
+
+```go
+type theTime struct {
+	unix int64
+}
+func NewISO8601(iso8601 string) (*theTime, error)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    tm, err := datetime.NewISO8601("2006-01-02T15:04:05.999Z")
+    fmt.Println(tm) //&{1136214245}
+}
+```
+
+
+
+### <span id="ToUnix">ToUnix</span>
+<p>Return unix timestamp.</p>
+
+<b>Signature:</b>
+
+```go
+func (t *theTime) ToUnix() int64
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    tm := datetime.NewUnixNow()
+    fmt.Println(tm.ToUnix()) //1647597438
+}
+```
+
+
+
+### <span id="ToFormat">ToFormat</span>
+<p>Return time string 'yyyy-mm-dd hh:mm:ss'.</p>
+
+<b>Signature:</b>
+
+```go
+func (t *theTime) ToFormat() string
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    tm, _ := datetime.NewFormat("2022-03-18 17:04:05")
+    fmt.Println(tm.ToFormat()) //"2022-03-18 17:04:05"
+}
+```
+
+
+
+### <span id="ToFormatForTpl">ToFormatForTpl</span>
+<p>Return the time string which format is specified tpl.</p>
+
+<b>Signature:</b>
+
+```go
+func (t *theTime) ToFormatForTpl(tpl string) string
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    tm, _ := datetime.NewFormat("2022-03-18 17:04:05")
+    ts := tm.ToFormatForTpl("2006/01/02 15:04:05")
+    fmt.Println(ts) //"2022/03/18 17:04:05"
+}
+```
+
+
+### <span id="ToIso8601">ToIso8601</span>
+<p>Return iso8601 time string.</p>
+
+<b>Signature:</b>
+
+```go
+func (t *theTime) ToIso8601() string
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    tm, _ := datetime.NewISO8601("2006-01-02T15:04:05.999Z")
+    ts := tm.ToIso8601()
+    fmt.Println(ts) //"2006-01-02T23:04:05+08:00"
+}
+```
--- a/docs/datetime_zh-CN.md
+++ b/docs/datetime_zh-CN.md
@@ -5,14 +5,14 @@ datetime日期时间处理包，格式化日期，比较日期。

 ## 源码:

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

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

 ## 用法:
 ```go
 import (
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )
 ```

@@ -28,7 +28,6 @@ import (
 - [BeginOfWeek](#BeginOfWeek)
 - [BeginOfMonth](#BeginOfMonth)
 - [BeginOfYear](#BeginOfYear)
-
 - [EndOfMinute](#EndOfMinute)
 - [EndOfHour](#EndOfHour)
 - [EndOfDay](#EndOfDay)
@@ -43,6 +42,15 @@ import (
 - [FormatTimeToStr](#FormatTimeToStr)
 - [FormatStrToTime](#FormatStrToTime)

+- [NewUnixNow](#NewUnixNow)
+- [NewUnix](#NewUnix)
+- [NewFormat](#NewFormat)
+- [NewISO8601](#NewISO8601)
+- [ToUnix](#ToUnix)
+- [ToFormat](#ToFormat)
+- [ToFormatForTpl](#ToFormatForTpl)
+- [ToIso8601](#ToIso8601)
+
 <div STYLE="page-break-after: always;"></div>

 ## 文档
@@ -85,7 +93,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -114,7 +122,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -142,7 +150,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -170,7 +178,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -196,7 +204,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -222,7 +230,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -250,7 +258,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -278,7 +286,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -305,7 +313,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -333,7 +341,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -359,7 +367,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -385,7 +393,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -413,7 +421,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -441,7 +449,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -468,7 +476,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -495,7 +503,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -522,7 +530,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -549,7 +557,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -576,7 +584,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -603,7 +611,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -629,7 +637,7 @@ package main
 import (
    "fmt"
    "time"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -655,7 +663,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/datetime"
+    "github.com/duke-git/lancet/v2/datetime"
 )

 func main() {
@@ -665,4 +673,221 @@ func main() {
 ```


+### <span id="NewUnixNow">NewUnixNow</span>
+<p>创建一个当前时间的unix时间戳</p>

+<b>函数签名:</b>
+
+```go
+type theTime struct {
+	unix int64
+}
+func NewUnixNow() *theTime
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    tm := datetime.NewUnixNow()
+    fmt.Println(tm) //&{1647597438}
+}
+```
+
+
+### <span id="NewUnix">NewUnix</span>
+<p>创建一个unix时间戳</p>
+
+<b>函数签名:</b>
+
+```go
+type theTime struct {
+	unix int64
+}
+func NewUnix(unix int64) *theTime
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    tm := datetime.NewUnix(1647597438)
+    fmt.Println(tm) //&{1647597438}
+}
+```
+
+
+
+### <span id="NewFormat">NewFormat</span>
+<p>创建一个yyyy-mm-dd hh:mm:ss格式时间字符串的unix时间戳</p>
+
+<b>函数签名:</b>
+
+```go
+type theTime struct {
+	unix int64
+}
+func NewFormat(t string) (*theTime, error)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    tm, err := datetime.NewFormat("2022-03-18 17:04:05")
+    fmt.Println(tm) //&{1647594245}
+}
+```
+
+
+
+
+### <span id="NewISO8601">NewISO8601</span>
+<p>创建一个iso8601格式时间字符串的unix时间戳</p>
+
+<b>函数签名:</b>
+
+```go
+type theTime struct {
+	unix int64
+}
+func NewISO8601(iso8601 string) (*theTime, error)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    tm, err := datetime.NewISO8601("2006-01-02T15:04:05.999Z")
+    fmt.Println(tm) //&{1136214245}
+}
+```
+
+
+
+### <span id="ToUnix">ToUnix</span>
+<p>返回unix时间戳</p>
+
+<b>函数签名:</b>
+
+```go
+func (t *theTime) ToUnix() int64
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    tm := datetime.NewUnixNow()
+    fmt.Println(tm.ToUnix()) //1647597438
+}
+```
+
+
+
+### <span id="ToFormat">ToFormat</span>
+<p>返回格式'yyyy-mm-dd hh:mm:ss'的日期字符串</p>
+
+<b>函数签名:</b>
+
+```go
+func (t *theTime) ToFormat() string
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    tm, _ := datetime.NewFormat("2022-03-18 17:04:05")
+    fmt.Println(tm.ToFormat()) //"2022-03-18 17:04:05"
+}
+```
+
+
+
+### <span id="ToFormatForTpl">ToFormatForTpl</span>
+<p>返回tpl格式指定的日期字符串</p>
+
+<b>函数签名:</b>
+
+```go
+func (t *theTime) ToFormatForTpl(tpl string) string
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    tm, _ := datetime.NewFormat("2022-03-18 17:04:05")
+    ts := tm.ToFormatForTpl("2006/01/02 15:04:05")
+    fmt.Println(ts) //"2022/03/18 17:04:05"
+}
+```
+
+
+### <span id="ToIso8601">ToIso8601</span>
+<p>返回iso8601日期字符串</p>
+
+<b>函数签名:</b>
+
+```go
+func (t *theTime) ToIso8601() string
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    tm, _ := datetime.NewISO8601("2006-01-02T15:04:05.999Z")
+    ts := tm.ToIso8601()
+    fmt.Println(ts) //"2006-01-02T23:04:05+08:00"
+}
+```
--- a/docs/fileutil.md
+++ b/docs/fileutil.md
@@ -5,14 +5,14 @@ Package fileutil implements some basic functions for file operations.

 ## Source:

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

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

 ## Usage:
 ```go
 import (
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )
 ```

@@ -21,18 +21,20 @@ import (
 ## Index
 - [ClearFile](#ClearFile)
 - [CreateFile](#CreateFile)
+- [CreateDir](#CreateDir)
 - [CopyFile](#CopyFile)
 - [FileMode](#FileMode)
 - [MiMeType](#MiMeType)
 - [IsExist](#IsExist)
 - [IsLink](#IsLink)
 - [IsDir](#IsDir)
+
 - [ListFileNames](#ListFileNames)
 - [RemoveFile](#RemoveFile)
 - [ReadFileToString](#ReadFileToString)
 - [ReadFileByLine](#ReadFileByLine)
 - [Zip](#Zip)
-
+- [UnZip](#UnZip)
 - [UnZip](#UnZip)

 <div STYLE="page-break-after: always;"></div>
@@ -56,7 +58,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -82,7 +84,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -92,6 +94,32 @@ func main() {
 ```


+
+### <span id="CreateDir">CreateDir</span>
+<p>Create directory in absolute path. param `absPath` like /a/, /a/b/.</p>
+
+<b>Signature:</b>
+
+```go
+func CreateDir(absPath string) error
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    err := fileutil.CreateDir("/a/")
+    fmt.Println(err)
+}
+```
+
+
 ### <span id="CopyFile">CopyFile</span>
 <p>Copy src file to dest file. If dest file exist will overwrite it.</p>

@@ -107,7 +135,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -135,7 +163,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -155,7 +183,7 @@ func main() {
 <b>Signature:</b>

 ```go
-func MiMeType(file interface{}) string
+func MiMeType(file any) string
 ```
 <b>Example:</b>

@@ -165,7 +193,7 @@ package main
 import (
    "fmt"
    "os"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -196,7 +224,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -223,7 +251,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -249,7 +277,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -278,7 +306,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -304,7 +332,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -332,7 +360,7 @@ package main
 import (
    "fmt"
    "os"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -365,7 +393,7 @@ package main
 import (
    "fmt"
    "os"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -398,7 +426,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -427,7 +455,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
--- a/docs/fileutil_zh-CN.md
+++ b/docs/fileutil_zh-CN.md
@@ -5,14 +5,14 @@ fileutil包支持文件基本操作。

 ## 源码:

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

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

 ## 用法:
 ```go
 import (
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )
 ```

@@ -21,6 +21,7 @@ import (
 ## 目录
 - [ClearFile](#ClearFile)
 - [CreateFile](#CreateFile)
+- [CreateDir](#CreateDir)
 - [CopyFile](#CopyFile)
 - [FileMode](#FileMode)
 - [MiMeType](#MiMeType)
@@ -56,7 +57,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -82,7 +83,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -92,6 +93,32 @@ func main() {
 ```


+### <span id="CreateDir">CreateDir</span>
+<p>使用绝对路径创建嵌套目录，例如/a/, /a/b/</p>
+
+<b>函数签名:</b>
+
+```go
+func CreateDir(absPath string) error
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    err := fileutil.CreateDir("/a/")
+    fmt.Println(err)
+}
+```
+
+
+
 ### <span id="CopyFile">CopyFile</span>
 <p>拷贝文件，会覆盖原有的拷贝文件</p>

@@ -107,7 +134,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -135,7 +162,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -155,7 +182,7 @@ func main() {
 <b>函数签名:</b>

 ```go
-func MiMeType(file interface{}) string
+func MiMeType(file any) string
 ```
 <b>例子:</b>

@@ -165,7 +192,7 @@ package main
 import (
    "fmt"
    "os"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -196,7 +223,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -223,7 +250,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -249,7 +276,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -278,7 +305,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -304,7 +331,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -332,7 +359,7 @@ package main
 import (
    "fmt"
    "os"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -365,7 +392,7 @@ package main
 import (
    "fmt"
    "os"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -398,7 +425,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
@@ -427,7 +454,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )

 func main() {
--- a/docs/formatter.md
+++ b/docs/formatter.md
@@ -5,14 +5,14 @@ formatter contains some functions for data formatting.

 ## Source:

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

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

 ## Usage:
 ```go
 import (
-    "github.com/duke-git/lancet/formatter"
+    "github.com/duke-git/lancet/v2/formatter"
 )
 ```

@@ -34,7 +34,7 @@ Param should be number or numberic string.</p>
 <b>Signature:</b>

 ```go
-func Comma(v interface{}, symbol string) string
+func Comma(v any, symbol string) string
 ```
 <b>Example:</b>

@@ -43,7 +43,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/formatter"
+    "github.com/duke-git/lancet/v2/formatter"
 )

 func main() {
--- a/docs/formatter_zh-CN.md
+++ b/docs/formatter_zh-CN.md
@@ -5,14 +5,14 @@ formatter格式化器包含一些数据格式化处理方法。

 ## 源码:

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

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

 ## 用法:
 ```go
 import (
-    "github.com/duke-git/lancet/formatter"
+    "github.com/duke-git/lancet/v2/formatter"
 )
 ```

@@ -33,7 +33,7 @@ import (
 <b>函数签名:</b>

 ```go
-func Comma(v interface{}, symbol string) string
+func Comma(v any, symbol string) string
 ```
 <b>例子:</b>

@@ -42,7 +42,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/formatter"
+    "github.com/duke-git/lancet/v2/formatter"
 )

 func main() {
--- a/docs/function.md
+++ b/docs/function.md
@@ -5,15 +5,15 @@ Package function can control the flow of function execution and support part of

 ## Source:

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

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

 ## Usage:
 ```go
 import (
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )
 ```

@@ -40,7 +40,7 @@ import (
 <b>Signature:</b>

 ```go
-func After(n int, fn interface{}) func(args ...interface{}) []reflect.Value
+func After(n int, fn any) func(args ...any) []reflect.Value
 ```
 <b>Example:</b>

@@ -49,7 +49,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )

 func main() {
@@ -59,7 +59,7 @@ func main() {
 		return i
 	})

-	type cb func(args ...interface{}) []reflect.Value
+	type cb func(args ...any) []reflect.Value
 	print := func(i int, s string, fn cb) {
 		fmt.Printf("arr[%d] is %s \n", i, s)
 		fn(i)
@@ -87,7 +87,7 @@ func main() {
 <b>Signature:</b>

 ```go
-func Before(n int, fn interface{}) func(args ...interface{}) []reflect.Value
+func Before(n int, fn any) func(args ...any) []reflect.Value
 ```
 <b>Example:</b>

@@ -96,8 +96,8 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/function"
-    "github.com/duke-git/lancet/internal"
+    "github.com/duke-git/lancet/v2/function"
+    "github.com/duke-git/lancet/v2/internal"
 )

 func main() {
@@ -109,7 +109,7 @@ func main() {
 	})

 	var res []int64
-	type cb func(args ...interface{}) []reflect.Value
+	type cb func(args ...any) []reflect.Value
 	appendStr := func(i int, s string, fn cb) {
 		v := fn(i)
 		res = append(res, v[0].Int())
@@ -133,8 +133,8 @@ func main() {
 <b>Signature:</b>

 ```go
-type Fn func(...interface{}) interface{}
-func (f Fn) Curry(i interface{}) func(...interface{}) interface{}
+type Fn func(...any) any
+func (f Fn) Curry(i any) func(...any) any
 ```
 <b>Example:</b>

@@ -143,14 +143,14 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )

 func main() {
    add := func(a, b int) int {
 		return a + b
 	}
-	var addCurry function.Fn = func(values ...interface{}) interface{} {
+	var addCurry function.Fn = func(values ...any) any {
 		return add(values[0].(int), values[1].(int))
 	}
 	add1 := addCurry.Curry(1)
@@ -168,7 +168,7 @@ func main() {
 <b>Signature:</b>

 ```go
-func Compose(fnList ...func(...interface{}) interface{}) func(...interface{}) interface{}
+func Compose(fnList ...func(...any) any) func(...any) any
 ```
 <b>Example:</b>

@@ -177,14 +177,14 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )

 func main() {
-    add1 := func(v ...interface{}) interface{} {
+    add1 := func(v ...any) any {
 		return v[0].(int) + 1
 	}
-    add2 := func(v ...interface{}) interface{} {
+    add2 := func(v ...any) any {
 		return v[0].(int) + 2
 	}

@@ -213,7 +213,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )

 func main() {
@@ -246,7 +246,7 @@ func main() {
 <b>Signature:</b>

 ```go
-func Delay(delay time.Duration, fn interface{}, args ...interface{})
+func Delay(delay time.Duration, fn any, args ...any)
 ```
 <b>Example:</b>

@@ -255,7 +255,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )

 func main() {
@@ -275,7 +275,7 @@ func main() {
 <b>Signature:</b>

 ```go
-func Schedule(d time.Duration, fn interface{}, args ...interface{}) chan bool
+func Schedule(d time.Duration, fn any, args ...any) chan bool
 ```
 <b>Example:</b>

@@ -284,7 +284,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )

 func main() {
@@ -327,7 +327,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )

 func main() {
--- a/docs/function_zh-CN.md
+++ b/docs/function_zh-CN.md
@@ -5,15 +5,15 @@ function函数包控制函数执行流程，包含部分函数式编程。

 ## 源码:

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

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

 ## 用法:
 ```go
 import (
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )
 ```

@@ -40,7 +40,7 @@ import (
 <b>函数签名:</b>

 ```go
-func After(n int, fn interface{}) func(args ...interface{}) []reflect.Value
+func After(n int, fn any) func(args ...any) []reflect.Value
 ```
 <b>例子:</b>

@@ -49,7 +49,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )

 func main() {
@@ -59,7 +59,7 @@ func main() {
 		return i
 	})

-	type cb func(args ...interface{}) []reflect.Value
+	type cb func(args ...any) []reflect.Value
 	print := func(i int, s string, fn cb) {
 		fmt.Printf("arr[%d] is %s \n", i, s)
 		fn(i)
@@ -87,7 +87,7 @@ func main() {
 <b>函数签名:</b>

 ```go
-func Before(n int, fn interface{}) func(args ...interface{}) []reflect.Value
+func Before(n int, fn any) func(args ...any) []reflect.Value
 ```
 <b>例子:</b>

@@ -96,8 +96,8 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/function"
-    "github.com/duke-git/lancet/internal"
+    "github.com/duke-git/lancet/v2/function"
+    "github.com/duke-git/lancet/v2/internal"
 )

 func main() {
@@ -109,7 +109,7 @@ func main() {
 	})

 	var res []int64
-	type cb func(args ...interface{}) []reflect.Value
+	type cb func(args ...any) []reflect.Value
 	appendStr := func(i int, s string, fn cb) {
 		v := fn(i)
 		res = append(res, v[0].Int())
@@ -133,8 +133,8 @@ func main() {
 <b>函数签名:</b>

 ```go
-type Fn func(...interface{}) interface{}
-func (f Fn) Curry(i interface{}) func(...interface{}) interface{}
+type Fn func(...any) any
+func (f Fn) Curry(i any) func(...any) any
 ```
 <b>例子:</b>

@@ -143,14 +143,14 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )

 func main() {
 	add := func(a, b int) int {
 		return a + b
 	}
-	var addCurry function.Fn = func(values ...interface{}) interface{} {
+	var addCurry function.Fn = func(values ...any) any {
 		return add(values[0].(int), values[1].(int))
 	}
 	add1 := addCurry.Curry(1)
@@ -168,7 +168,7 @@ func main() {
 <b>函数签名:</b>

 ```go
-func Compose(fnList ...func(...interface{}) interface{}) func(...interface{}) interface{}
+func Compose(fnList ...func(...any) any) func(...any) any
 ```
 <b>例子:</b>

@@ -177,14 +177,14 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )

 func main() {
-	add1 := func(v ...interface{}) interface{} {
+	add1 := func(v ...any) any {
 		return v[0].(int) + 1
 	}
-	add2 := func(v ...interface{}) interface{} {
+	add2 := func(v ...any) any {
 		return v[0].(int) + 2
 	}

@@ -213,7 +213,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )

 func main() {
@@ -246,7 +246,7 @@ func main() {
 <b>函数签名:</b>

 ```go
-func Delay(delay time.Duration, fn interface{}, args ...interface{})
+func Delay(delay time.Duration, fn any, args ...any)
 ```
 <b>例子:</b>

@@ -255,7 +255,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )

 func main() {
@@ -275,7 +275,7 @@ func main() {
 <b>函数签名:</b>

 ```go
-func Schedule(d time.Duration, fn interface{}, args ...interface{}) chan bool
+func Schedule(d time.Duration, fn any, args ...any) chan bool
 ```
 <b>例子:</b>

@@ -284,7 +284,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )

 func main() {
@@ -327,7 +327,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )

 func main() {
--- a/docs/maputil.md
+++ b/docs/maputil.md
@@ -0,0 +1,304 @@
+# Maputil
+Package maputil includes some functions to manipulate map.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source:
+
+- [https://github.com/duke-git/lancet/blob/main/maputil/maputil.go](https://github.com/duke-git/lancet/blob/main/maputil/maputil.go)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## Example:
+```go
+import (
+    "github.com/duke-git/lancet/v2/maputil"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+- [ForEach](#ForEach)
+- [Filter](#Filter)
+- [Intersect](#Intersect)
+- [Keys](#Keys)
+- [Merge](#Merge)
+- [Minus](#Minus)
+- [Values](#Values)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+
+
+### <span id="ForEach">ForEach</span>
+<p>Executes iteratee funcation for every key and value pair in map.</p>
+
+<b>Signature:</b>
+
+```go
+func ForEach[K comparable, V any](m map[K]V, iteratee func(key K, value V))
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+	}
+
+	var sum int
+
+	maputil.ForEach(m, func(_ string, value int) {
+		sum += value
+	})
+	fmt.Println(sum) // 10
+}
+```
+
+
+
+
+### <span id="Filter">Filter</span>
+<p>Iterates over map, return a new map contains all key and value pairs pass the predicate function.</p>
+
+<b>Signature:</b>
+
+```go
+func Filter[K comparable, V any](m map[K]V, predicate func(key K, value V) bool) map[K]V
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+		"e": 5,
+	}
+	isEven := func(_ string, value int) bool {
+		return value%2 == 0
+	}
+
+	maputil.Filter(m, func(_ string, value int) {
+		sum += value
+	})
+	res := maputil.Filter(m, isEven)
+	fmt.Println(res) // map[string]int{"b": 2, "d": 4,}
+}
+```
+
+
+
+
+### <span id="Intersect">Intersect</span>
+<p>Iterates over maps, return a new map of key and value pairs in all given maps.</p>
+
+<b>Signature:</b>
+
+```go
+func Intersect[K comparable, V any](maps ...map[K]V) map[K]V
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+	m1 := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+	}
+
+	m2 := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 6,
+		"d": 7,
+	}
+
+	m3 := map[string]int{
+		"a": 1,
+		"b": 9,
+		"e": 9,
+	}
+
+	fmt.Println(maputil.Intersect(m1)) // map[string]int{"a": 1, "b": 2, "c": 3}
+
+	fmt.Println(maputil.Intersect(m1, m2)) // map[string]int{"a": 1, "b": 2}
+
+	fmt.Println(maputil.Intersect(m1, m2, m3)) // map[string]int{"a": 1}
+}
+```
+
+
+
+
+### <span id="Keys">Keys</span>
+<p>Returns a slice of the map's keys.</p>
+
+<b>Signature:</b>
+
+```go
+func Keys[K comparable, V any](m map[K]V) []K
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+	m := map[int]string{
+		1: "a",
+		2: "a",
+		3: "b",
+		4: "c",
+		5: "d",
+	}
+
+	keys := maputil.Keys(m)
+	sort.Ints(keys)
+	fmt.Println(keys) // []int{1, 2, 3, 4, 5}
+}
+```
+
+
+
+
+### <span id="Merge">Merge</span>
+<p>Merge maps, next key will overwrite previous key.</p>
+
+<b>Signature:</b>
+
+```go
+func Merge[K comparable, V any](maps ...map[K]V) map[K]V
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+	m1 := map[int]string{
+		1: "a",
+		2: "b",
+	}
+	m2 := map[int]string{
+		1: "1",
+		3: "2",
+	}
+	fmt.Println(maputil.Merge(m1, m2)) // map[int]string{1:"1", 2:"b", 3:"2",}
+}
+```
+
+
+
+
+### <span id="Minus">Minus</span>
+<p>Creates an map of whose key in mapA but not in mapB.</p>
+
+<b>Signature:</b>
+
+```go
+func Minus[K comparable, V any](mapA, mapB map[K]V) map[K]V
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+	m1 := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+	}
+
+	m2 := map[string]int{
+		"a": 11,
+		"b": 22,
+		"d": 33,
+	}
+
+	fmt.Println(maputil.Minus(m1, m2)) //map[string]int{"c": 3}
+}
+```
+
+
+
+### <span id="Values">Values</span>
+<p>Returns a slice of the map's values.</p>
+
+<b>Signature:</b>
+
+```go
+func Values[K comparable, V any](m map[K]V) []V
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+	m := map[int]string{
+		1: "a",
+		2: "a",
+		3: "b",
+		4: "c",
+		5: "d",
+	}
+
+	values := maputil.Values(m)
+	sort.Strings(values)
+
+	fmt.Println(values) // []string{"a", "a", "b", "c", "d"}
+}
+```
--- a/docs/maputil_zh-CN.md
+++ b/docs/maputil_zh-CN.md
@@ -0,0 +1,304 @@
+# Maputil
+maputil包包括一些操作map的函数。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+- [https://github.com/duke-git/lancet/blob/main/maputil/maputil.go](https://github.com/duke-git/lancet/blob/main/maputil/maputil.go)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+```go
+import (
+    "github.com/duke-git/lancet/v2/maputil"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录:
+- [ForEach](#ForEach)
+- [Filter](#Filter)
+- [Intersect](#Intersect)
+- [Keys](#Keys)
+- [Merge](#Merge)
+- [Minus](#Minus)
+- [Values](#Values)
+
+<div STYLE="page-break-after: always;"></div>
+
+## API文档:
+
+
+
+### <span id="ForEach">ForEach</span>
+<p>对map中的每对key和value执行iteratee函数</p>
+
+<b>函数签名:</b>
+
+```go
+func ForEach[K comparable, V any](m map[K]V, iteratee func(key K, value V))
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+	}
+
+	var sum int
+
+	maputil.ForEach(m, func(_ string, value int) {
+		sum += value
+	})
+	fmt.Println(sum) // 10
+}
+```
+
+
+
+
+### <span id="Filter">Filter</span>
+<p>迭代map中的每对key和value, 返回符合predicate函数的key, value</p>
+
+<b>函数签名:</b>
+
+```go
+func Filter[K comparable, V any](m map[K]V, predicate func(key K, value V) bool) map[K]V
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+	m := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+		"e": 5,
+	}
+	isEven := func(_ string, value int) bool {
+		return value%2 == 0
+	}
+
+	maputil.Filter(m, func(_ string, value int) {
+		sum += value
+	})
+	res := maputil.Filter(m, isEven)
+	fmt.Println(res) // map[string]int{"b": 2, "d": 4,}
+}
+```
+
+
+
+
+### <span id="Intersect">Intersect</span>
+<p>多个map的交集操作</p>
+
+<b>函数签名:</b>
+
+```go
+func Intersect[K comparable, V any](maps ...map[K]V) map[K]V
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+	m1 := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+	}
+
+	m2 := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 6,
+		"d": 7,
+	}
+
+	m3 := map[string]int{
+		"a": 1,
+		"b": 9,
+		"e": 9,
+	}
+
+	fmt.Println(maputil.Intersect(m1)) // map[string]int{"a": 1, "b": 2, "c": 3}
+
+	fmt.Println(maputil.Intersect(m1, m2)) // map[string]int{"a": 1, "b": 2}
+
+	fmt.Println(maputil.Intersect(m1, m2, m3)) // map[string]int{"a": 1}
+}
+```
+
+
+
+
+### <span id="Keys">Keys</span>
+<p>返回map中所有key的切片</p>
+
+<b>函数签名:</b>
+
+```go
+func Keys[K comparable, V any](m map[K]V) []K
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+	m := map[int]string{
+		1: "a",
+		2: "a",
+		3: "b",
+		4: "c",
+		5: "d",
+	}
+
+	keys := maputil.Keys(m)
+	sort.Ints(keys)
+	fmt.Println(keys) // []int{1, 2, 3, 4, 5}
+}
+```
+
+
+
+
+### <span id="Merge">Merge</span>
+<p>合并多个maps, 相同的key会被后来的key覆盖</p>
+
+<b>函数签名:</b>
+
+```go
+func Merge[K comparable, V any](maps ...map[K]V) map[K]V
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+	m1 := map[int]string{
+		1: "a",
+		2: "b",
+	}
+	m2 := map[int]string{
+		1: "1",
+		3: "2",
+	}
+	fmt.Println(maputil.Merge(m1, m2)) // map[int]string{1:"1", 2:"b", 3:"2",}
+}
+```
+
+
+
+
+### <span id="Minus">Minus</span>
+<p>返回一个map，其中的key存在于mapA，不存在于mapB.</p>
+
+<b>函数签名:</b>
+
+```go
+func Minus[K comparable, V any](mapA, mapB map[K]V) map[K]V
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+	m1 := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+	}
+
+	m2 := map[string]int{
+		"a": 11,
+		"b": 22,
+		"d": 33,
+	}
+
+	fmt.Println(maputil.Minus(m1, m2)) //map[string]int{"c": 3}
+}
+```
+
+
+
+### <span id="Values">Values</span>
+<p>返回map中所有value的切片</p>
+
+<b>函数签名:</b>
+
+```go
+func Values[K comparable, V any](m map[K]V) []V
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+	m := map[int]string{
+		1: "a",
+		2: "a",
+		3: "b",
+		4: "c",
+		5: "d",
+	}
+
+	values := maputil.Values(m)
+	sort.Strings(values)
+
+	fmt.Println(values) // []string{"a", "a", "b", "c", "d"}
+}
+```
--- a/docs/mathutil.md
+++ b/docs/mathutil.md
@@ -0,0 +1,400 @@
+# Mathutil
+Package mathutil implements some functions for math calculation.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source:
+
+- [https://github.com/duke-git/lancet/blob/main/mathutil/mathutil.go](https://github.com/duke-git/lancet/blob/main/mathutil/mathutil.go)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## Example:
+```go
+import (
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+- [Average](#Average)
+- [Exponent](#Exponent)
+- [Fibonacci](#Fibonacci)
+- [Factorial](#Factorial)
+- [Max](#Max)
+- [MaxBy](#MaxBy)
+- [Min](#Min)
+- [MinBy](#MaxBy)
+
+- [Percent](#Percent)
+- [RoundToFloat](#RoundToFloat)
+- [RoundToString](#RoundToString)
+- [TruncRound](#TruncRound)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+
+
+### <span id="Average">Average</span>
+<p>Return average value of numbers. Maybe call RoundToFloat to round result.</p>
+
+<b>Signature:</b>
+
+```go
+func Average[T lancetconstraints.Number](numbers ...T) T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.Average(0, 0)) //0
+	fmt.Println(mathutil.Average(1, 1)) //1
+	avg := mathutil.Average(1.2, 1.4) //1.2999999998
+	roundAvg := mmathutil.RoundToFloat(avg, 1) // 1.3
+}
+```
+
+
+
+### <span id="Exponent">Exponent</span>
+<p>Calculate x to the nth power.</p>
+
+<b>Signature:</b>
+
+```go
+func Exponent(x, n int64) int64
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.Exponent(10, 0)) //1
+	fmt.Println(mathutil.Exponent(10, 1)) //10
+	fmt.Println(mathutil.Exponent(10, 2)) //100
+}
+```
+
+
+
+### <span id="Fibonacci">Fibonacci</span>
+<p>Calculate the nth number of fibonacci sequence.</p>
+
+<b>Signature:</b>
+
+```go
+func Fibonacci(first, second, n int) int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.Fibonacci(1, 1, 1)) //1
+	fmt.Println(mathutil.Fibonacci(1, 1, 2)) //1
+	fmt.Println(mathutil.Fibonacci(1, 1, 3)) //2
+	fmt.Println(mathutil.Fibonacci(1, 1, 4)) //3
+	fmt.Println(mathutil.Fibonacci(1, 1, 5)) //5
+}
+```
+
+
+
+### <span id="Factorial">Factorial</span>
+<p>Calculate the factorial of x.</p>
+
+<b>Signature:</b>
+
+```go
+func Factorial(x uint) uint
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.Factorial(0)) //1
+	fmt.Println(mathutil.Factorial(1)) //1
+	fmt.Println(mathutil.Factorial(2)) //2
+	fmt.Println(mathutil.Factorial(3)) //6
+}
+```
+
+
+
+### <span id="Max">Max</span>
+<p>Return max value of numbers.</p>
+
+<b>Signature:</b>
+
+```go
+func Max[T lancetconstraints.Number](numbers ...T) T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.Max(0, 0)) //0
+	fmt.Println(mathutil.Max(1, 2, 3)) //3
+	fmt.Println(mathutil.Max(1.2, 1.4, 1.1, 1.4)) //1.4
+}
+```
+
+
+
+
+### <span id="MaxBy">MaxBy</span>
+<p>Return the maximum value of a slice using the given comparator function.</p>
+
+<b>Signature:</b>
+
+```go
+func MaxBy[T any](slice []T, comparator func(T, T) bool) T 
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	res1 := mathutil.MaxBy([]string{"a", "ab", "abc"}, func(v1, v2 string) bool {
+		return len(v1) > len(v2)
+	})
+	fmt.Println(res1) //abc
+
+	res2 := mathutil.MaxBy([]string{"abd", "abc", "ab"}, func(v1, v2 string) bool {
+		return len(v1) > len(v2)
+	})
+	fmt.Println(res2) //abd
+
+	res3 := mathutil.MaxBy([]string{}, func(v1, v2 string) bool {
+		return len(v1) > len(v2)
+	})
+	fmt.Println(res3) //“”
+}
+```
+
+
+
+### <span id="Min">Min</span>
+<p>Return min value of numbers.</p>
+
+<b>Signature:</b>
+
+```go
+func Min[T lancetconstraints.Number](numbers ...T) T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.Min(0, 0)) //0
+	fmt.Println(mathutil.Min(1, 2, 3)) //1
+	fmt.Println(mathutil.Min(1.2, 1.4, 1.1, 1.4)) //1.1
+}
+```
+
+
+
+### <span id="MinBy">MinBy</span>
+<p>Return the minimum value of a slice using the given comparator function.</p>
+
+<b>Signature:</b>
+
+```go
+func MinBy[T any](slice []T, comparator func(T, T) bool) T 
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	res1 := mathutil.MinBy([]string{"a", "ab", "abc"}, func(v1, v2 string) bool {
+		return len(v1) < len(v2)
+	})
+	fmt.Println(res1) //a
+
+	res2 := mathutil.MinBy([]string{"ab", "ac", "abc"}, func(v1, v2 string) bool {
+		return len(v1) < len(v2)
+	})
+	fmt.Println(res2) //ab
+
+	res3 := mathutil.MinBy([]string{}, func(v1, v2 string) bool {
+		return len(v1) < len(v2)
+	})
+	fmt.Println(res3) //“”
+}
+```
+
+
+
+
+### <span id="Percent">Percent</span>
+<p>calculate the percentage of val to total, retain n decimal places.</p>
+
+<b>Signature:</b>
+
+```go
+func Percent(val, total float64, n int) float64
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.Percent(1, 2, 2)) //1
+	fmt.Println(mathutil.Percent(0.1, 0.3, 2)) //33.33
+}
+```
+
+
+
+### <span id="RoundToFloat">RoundToFloat</span>
+<p>Round float up to n decimal places.</p>
+
+<b>Signature:</b>
+
+```go
+func RoundToFloat(x float64, n int) float64
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.RoundToFloat(0, 0)) //0
+	fmt.Println(mathutil.RoundToFloat(0, 1)) //0
+	fmt.Println(mathutil.RoundToFloat(0.124, 2)) //0.12
+	fmt.Println(mathutil.RoundToFloat(0.125, 2)) //0.13
+	fmt.Println(mathutil.RoundToFloat(0.125, 3)) //0.125
+}
+```
+
+
+
+
+### <span id="RoundToString">RoundToString</span>
+<p>Round float up to n decimal places. will return string.</p>
+
+<b>Signature:</b>
+
+```go
+func RoundToString(x float64, n int) string
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.RoundToString(0, 0)) //"0"
+	fmt.Println(mathutil.RoundToString(0, 1)) //"0.0:
+	fmt.Println(mathutil.RoundToString(0.124, 2)) //"0.12"
+	fmt.Println(mathutil.RoundToString(0.125, 2)) //"0.13"
+	fmt.Println(mathutil.RoundToString(0.125, 3)) //"0.125"
+}
+```
+
+
+
+### <span id="TruncRound">TruncRound</span>
+<p>Round float off n decimal places.</p>
+
+<b>Signature:</b>
+
+```go
+func TruncRound(x float64, n int) float64
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.TruncRound(0, 0)) //0
+	fmt.Println(mathutil.TruncRound(0, 1)) //0
+	fmt.Println(mathutil.TruncRound(0.124, 2)) //0.12
+	fmt.Println(mathutil.TruncRound(0.125, 2)) //0.12
+	fmt.Println(mathutil.TruncRound(0.125, 3)) //0.125
+}
+```
+
+
+
--- a/docs/mathutil_zh-CN.md
+++ b/docs/mathutil_zh-CN.md
@@ -0,0 +1,397 @@
+# Mathutil
+mathutil包实现了一些数学计算的函数.
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+- [https://github.com/duke-git/lancet/blob/main/mathutil/mathutil.go](https://github.com/duke-git/lancet/blob/main/mathutil/mathutil.go)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+```go
+import (
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+- [Average](#Average)
+- [Exponent](#Exponent)
+- [Fibonacci](#Fibonacci)
+- [Factorial](#Factorial)
+- [Max](#Max)
+- [MaxBy](#MaxBy)
+- [Min](#Min)
+- [MinBy](#MaxBy)
+  
+- [Percent](#Percent)
+- [RoundToFloat](#RoundToFloat)
+- [RoundToString](#RoundToString)
+- [TruncRound](#TruncRound)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+
+### <span id="Average">Average</span>
+<p>计算平均数. 可能需要对结果调用RoundToFloat方法四舍五入</p>
+
+<b>函数签名:</b>
+
+```go
+func Average[T lancetconstraints.Number](numbers ...T) T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.Average(0, 0)) //0
+	fmt.Println(mathutil.Average(1, 1)) //1
+	avg := mathutil.Average(1.2, 1.4) //1.2999999998
+	roundAvg := mmathutil.RoundToFloat(avg, 1) // 1.3
+}
+```
+
+
+### <span id="Exponent">Exponent</span>
+<p>指数计算（x的n次方）</p>
+
+<b>函数签名:</b>
+
+```go
+func Exponent(x, n int64) int64
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.Exponent(10, 0)) //1
+	fmt.Println(mathutil.Exponent(10, 1)) //10
+	fmt.Println(mathutil.Exponent(10, 2)) //100
+}
+```
+
+
+
+### <span id="Fibonacci">Fibonacci</span>
+<p>计算斐波那契数列的第n个数</p>
+
+<b>函数签名:</b>
+
+```go
+func Fibonacci(first, second, n int) int
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.Fibonacci(1, 1, 1)) //1
+	fmt.Println(mathutil.Fibonacci(1, 1, 2)) //1
+	fmt.Println(mathutil.Fibonacci(1, 1, 3)) //2
+	fmt.Println(mathutil.Fibonacci(1, 1, 4)) //3
+	fmt.Println(mathutil.Fibonacci(1, 1, 5)) //5
+}
+```
+
+
+
+### <span id="Factorial">Factorial</span>
+<p>计算阶乘</p>
+
+<b>函数签名:</b>
+
+```go
+func Factorial(x uint) uint
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.Factorial(0)) //1
+	fmt.Println(mathutil.Factorial(1)) //1
+	fmt.Println(mathutil.Factorial(2)) //2
+	fmt.Println(mathutil.Factorial(3)) //6
+}
+```
+
+
+### <span id="Max">Max</span>
+<p>返回参数中的最大数</p>
+
+<b>函数签名:</b>
+
+```go
+func Max[T lancetconstraints.Number](numbers ...T) T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.Max(0, 0)) //0
+	fmt.Println(mathutil.Max(1, 2, 3)) //3
+	fmt.Println(mathutil.Max(1.2, 1.4, 1.1, 1.4)) //1.4
+}
+```
+
+
+
+### <span id="MaxBy">MaxBy</span>
+<p>使用给定的比较器函数返回切片的最大值</p>
+
+<b>函数签名:</b>
+
+```go
+func MaxBy[T any](slice []T, comparator func(T, T) bool) T 
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	res1 := mathutil.MaxBy([]string{"a", "ab", "abc"}, func(v1, v2 string) bool {
+		return len(v1) > len(v2)
+	})
+	fmt.Println(res1) //abc
+
+	res2 := mathutil.MaxBy([]string{"abd", "abc", "ab"}, func(v1, v2 string) bool {
+		return len(v1) > len(v2)
+	})
+	fmt.Println(res2) //abd
+
+	res3 := mathutil.MaxBy([]string{}, func(v1, v2 string) bool {
+		return len(v1) > len(v2)
+	})
+	fmt.Println(res3) //“”
+}
+```
+
+
+
+
+### <span id="Min">Min</span>
+<p>返回参数中的最小数</p>
+
+<b>函数签名:</b>
+
+```go
+func Min[T lancetconstraints.Number](numbers ...T) T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.Min(0, 0)) //0
+	fmt.Println(mathutil.Min(1, 2, 3)) //1
+	fmt.Println(mathutil.Min(1.2, 1.4, 1.1, 1.4)) //1.1
+}
+```
+
+
+
+### <span id="MinBy">MinBy</span>
+<p>使用给定的比较器函数返回切片的最小值</p>
+
+<b>函数签名:</b>
+
+```go
+func MinBy[T any](slice []T, comparator func(T, T) bool) T 
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	res1 := mathutil.MinBy([]string{"a", "ab", "abc"}, func(v1, v2 string) bool {
+		return len(v1) < len(v2)
+	})
+	fmt.Println(res1) //a
+
+	res2 := mathutil.MinBy([]string{"ab", "ac", "abc"}, func(v1, v2 string) bool {
+		return len(v1) < len(v2)
+	})
+	fmt.Println(res2) //ab
+
+	res3 := mathutil.MinBy([]string{}, func(v1, v2 string) bool {
+		return len(v1) < len(v2)
+	})
+	fmt.Println(res3) //“”
+}
+```
+
+
+
+
+### <span id="Percent">Percent</span>
+<p>计算百分比，保留n位小数</p>
+
+<b>函数签名:</b>
+
+```go
+func Percent(val, total float64, n int) float64
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.Percent(1, 2, 2)) //1
+	fmt.Println(mathutil.Percent(0.1, 0.3, 2)) //33.33
+}
+```
+
+
+
+### <span id="RoundToFloat">RoundToFloat</span>
+<p>四舍五入，保留n位小数</p>
+
+<b>函数签名:</b>
+
+```go
+func RoundToFloat(x float64, n int) float64
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.RoundToFloat(0, 0)) //0
+	fmt.Println(mathutil.RoundToFloat(0, 1)) //0
+	fmt.Println(mathutil.RoundToFloat(0.124, 2)) //0.12
+	fmt.Println(mathutil.RoundToFloat(0.125, 2)) //0.13
+	fmt.Println(mathutil.RoundToFloat(0.125, 3)) //0.125
+}
+```
+
+
+
+
+### <span id="RoundToString">RoundToString</span>
+<p>四舍五入，保留n位小数，返回字符串</p>
+
+<b>函数签名:</b>
+
+```go
+func RoundToString(x float64, n int) string
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.RoundToString(0, 0)) //"0"
+	fmt.Println(mathutil.RoundToString(0, 1)) //"0.0:
+	fmt.Println(mathutil.RoundToString(0.124, 2)) //"0.12"
+	fmt.Println(mathutil.RoundToString(0.125, 2)) //"0.13"
+	fmt.Println(mathutil.RoundToString(0.125, 3)) //"0.125"
+}
+```
+
+
+
+### <span id="TruncRound">TruncRound</span>
+<p>截短n位小数（不进行四舍五入）</p>
+
+<b>函数签名:</b>
+
+```go
+func TruncRound(x float64, n int) float64
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+	fmt.Println(mathutil.TruncRound(0, 0)) //0
+	fmt.Println(mathutil.TruncRound(0, 1)) //0
+	fmt.Println(mathutil.TruncRound(0.124, 2)) //0.12
+	fmt.Println(mathutil.TruncRound(0.125, 2)) //0.12
+	fmt.Println(mathutil.TruncRound(0.125, 3)) //0.125
+}
+```
+
+
+
--- a/docs/netutil.md
+++ b/docs/netutil.md
@@ -5,16 +5,16 @@ Package netutil contains functions to get net information and send http request.

 ## Source:

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

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

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

 ## Usage:
 ```go
 import (
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 ```

@@ -46,7 +46,7 @@ import (
 <b>Signature:</b>

 ```go
-func ConvertMapToQueryString(param map[string]interface{}) string
+func ConvertMapToQueryString(param map[string]any) string
 ```
 <b>Example:</b>

@@ -55,11 +55,11 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
-	var m = map[string]interface{}{
+	var m = map[string]any{
 		"c": 3,
 		"a": 1,
 		"b": 2,
@@ -88,7 +88,7 @@ package main
 import (
    "fmt"
 	"net"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -117,7 +117,7 @@ package main
 import (
    "fmt"
 	"net"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -144,7 +144,7 @@ package main
 import (
    "fmt"
 	"net"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -184,7 +184,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -215,7 +215,7 @@ package main
 import (
    "fmt"
 	"net"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -237,10 +237,10 @@ func main() {

 ```go
 // params[0] is header which type should be http.Header or map[string]string,
-// params[1] is query param which type should be url.Values or map[string]interface{},
+// params[1] is query param which type should be url.Values or map[string]any,
 // params[2] is post body which type should be []byte.
 // params[3] is http client which type should be http.Client.
-func HttpGet(url string, params ...interface{}) (*http.Response, error)
+func HttpGet(url string, params ...any) (*http.Response, error)
 ```
 <b>Example:</b>

@@ -251,7 +251,7 @@ import (
    "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -279,10 +279,10 @@ func main() {

 ```go
 // params[0] is header which type should be http.Header or map[string]string,
-// params[1] is query param which type should be url.Values or map[string]interface{},
+// params[1] is query param which type should be url.Values or map[string]any,
 // params[2] is post body which type should be []byte.
 // params[3] is http client which type should be http.Client.
-func HttpPost(url string, params ...interface{}) (*http.Response, error)
+func HttpPost(url string, params ...any) (*http.Response, error)
 ```
 <b>Example:</b>

@@ -294,7 +294,7 @@ import (
    "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -328,10 +328,10 @@ func main() {

 ```go
 // params[0] is header which type should be http.Header or map[string]string,
-// params[1] is query param which type should be url.Values or map[string]interface{},
+// params[1] is query param which type should be url.Values or map[string]any,
 // params[2] is post body which type should be []byte.
 // params[3] is http client which type should be http.Client.
-func HttpPut(url string, params ...interface{}) (*http.Response, error)
+func HttpPut(url string, params ...any) (*http.Response, error)
 ```
 <b>Example:</b>

@@ -343,7 +343,7 @@ import (
    "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -378,10 +378,10 @@ func main() {

 ```go
 // params[0] is header which type should be http.Header or map[string]string,
-// params[1] is query param which type should be url.Values or map[string]interface{},
+// params[1] is query param which type should be url.Values or map[string]any,
 // params[2] is post body which type should be []byte.
 // params[3] is http client which type should be http.Client.
-func HttpDelete(url string, params ...interface{}) (*http.Response, error)
+func HttpDelete(url string, params ...any) (*http.Response, error)
 ```
 <b>Example:</b>

@@ -393,7 +393,7 @@ import (
    "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -417,10 +417,10 @@ func main() {

 ```go
 // params[0] is header which type should be http.Header or map[string]string,
-// params[1] is query param which type should be url.Values or map[string]interface{},
+// params[1] is query param which type should be url.Values or map[string]any,
 // params[2] is post body which type should be []byte.
 // params[3] is http client which type should be http.Client.
-func HttpPatch(url string, params ...interface{}) (*http.Response, error)
+func HttpPatch(url string, params ...any) (*http.Response, error)
 ```
 <b>Example:</b>

@@ -432,7 +432,7 @@ import (
    "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -466,7 +466,7 @@ func main() {
 <b>Signature:</b>

 ```go
-func ParseHttpResponse(resp *http.Response, obj interface{}) error
+func ParseHttpResponse(resp *http.Response, obj any) error
 ```
 <b>Example:</b>

@@ -478,7 +478,7 @@ import (
    "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
--- a/docs/netutil_zh-CN.md
+++ b/docs/netutil_zh-CN.md
@@ -5,16 +5,15 @@ netutil网络包支持获取ip地址，发送http请求。

 ## 源码:

-[https://github.com/duke-git/lancet/blob/main/netutil/net.go](https://github.com/duke-git/lancet/blob/main/netutil/net.go)
-
-[https://github.com/duke-git/lancet/blob/main/netutil/http.go](https://github.com/duke-git/lancet/blob/main/netutil/http.go)
+- [https://github.com/duke-git/lancet/blob/main/netutil/net.go](https://github.com/duke-git/lancet/blob/main/netutil/net.go)
+- [https://github.com/duke-git/lancet/blob/main/netutil/http.go](https://github.com/duke-git/lancet/blob/main/netutil/http.go)

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

 ## 用法:
 ```go
 import (
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 ```

@@ -46,7 +45,7 @@ import (
 <b>函数签名:</b>

 ```go
-func ConvertMapToQueryString(param map[string]interface{}) string
+func ConvertMapToQueryString(param map[string]any) string
 ```
 <b>例子:</b>

@@ -55,11 +54,11 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
-	var m = map[string]interface{}{
+	var m = map[string]any{
 		"c": 3,
 		"a": 1,
 		"b": 2,
@@ -88,7 +87,7 @@ package main
 import (
    "fmt"
 	"net"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -116,7 +115,7 @@ package main
 import (
    "fmt"
 	"net"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -143,7 +142,7 @@ package main
 import (
    "fmt"
 	"net"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -183,7 +182,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -214,7 +213,7 @@ package main
 import (
    "fmt"
 	"net"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -236,10 +235,10 @@ func main() {

 ```go
 // params[0] http请求header，类型必须是http.Header或者map[string]string
-// params[1] http查询字符串，类型必须是url.Values或者map[string]interface{}
+// params[1] http查询字符串，类型必须是url.Values或者map[string]any
 // params[2] post请求体，类型必须是[]byte
 // params[3] http client，类型必须是http.Client
-func HttpGet(url string, params ...interface{}) (*http.Response, error)
+func HttpGet(url string, params ...any) (*http.Response, error)
 ```
 <b>例子:</b>

@@ -250,7 +249,7 @@ import (
    "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -278,10 +277,10 @@ func main() {

 ```go
 // params[0] http请求header，类型必须是http.Header或者map[string]string
-// params[1] http查询字符串，类型必须是url.Values或者map[string]interface{}
+// params[1] http查询字符串，类型必须是url.Values或者map[string]any
 // params[2] post请求体，类型必须是[]byte
 // params[3] http client，类型必须是http.Client
-func HttpPost(url string, params ...interface{}) (*http.Response, error)
+func HttpPost(url string, params ...any) (*http.Response, error)
 ```
 <b>例子:</b>

@@ -293,7 +292,7 @@ import (
    "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -327,10 +326,10 @@ func main() {

 ```go
 // params[0] http请求header，类型必须是http.Header或者map[string]string
-// params[1] http查询字符串，类型必须是url.Values或者map[string]interface{}
+// params[1] http查询字符串，类型必须是url.Values或者map[string]any
 // params[2] post请求体，类型必须是[]byte
 // params[3] http client，类型必须是http.Client
-func HttpPut(url string, params ...interface{}) (*http.Response, error)
+func HttpPut(url string, params ...any) (*http.Response, error)
 ```
 <b>Example:</b>

@@ -342,7 +341,7 @@ import (
    "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -377,10 +376,10 @@ func main() {

 ```go
 // params[0] http请求header，类型必须是http.Header或者map[string]string
-// params[1] http查询字符串，类型必须是url.Values或者map[string]interface{}
+// params[1] http查询字符串，类型必须是url.Values或者map[string]any
 // params[2] post请求体，类型必须是[]byte
 // params[3] http client，类型必须是http.Client
-func HttpDelete(url string, params ...interface{}) (*http.Response, error)
+func HttpDelete(url string, params ...any) (*http.Response, error)
 ```
 <b>例子:</b>

@@ -392,7 +391,7 @@ import (
    "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -416,10 +415,10 @@ func main() {

 ```go
 // params[0] http请求header，类型必须是http.Header或者map[string]string
-// params[1] http查询字符串，类型必须是url.Values或者map[string]interface{}
+// params[1] http查询字符串，类型必须是url.Values或者map[string]any
 // params[2] post请求体，类型必须是[]byte
 // params[3] http client，类型必须是http.Client
-func HttpPatch(url string, params ...interface{}) (*http.Response, error)
+func HttpPatch(url string, params ...any) (*http.Response, error)
 ```
 <b>例子:</b>

@@ -431,7 +430,7 @@ import (
    "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
@@ -465,7 +464,7 @@ func main() {
 <b>函数签名:</b>

 ```go
-func ParseHttpResponse(resp *http.Response, obj interface{}) error
+func ParseHttpResponse(resp *http.Response, obj any) error
 ```
 <b>例子:</b>

@@ -477,7 +476,7 @@ import (
    "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )

 func main() {
--- a/docs/random.md
+++ b/docs/random.md
@@ -5,7 +5,7 @@ Package random implements some basic functions to generate random int and string

 ## Source:

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


 <div STYLE="page-break-after: always;"></div>
@@ -13,7 +13,7 @@ Package random implements some basic functions to generate random int and string
 ## Usage:
 ```go
 import (
-    "github.com/duke-git/lancet/random"
+    "github.com/duke-git/lancet/v2/random"
 )
 ```

@@ -45,7 +45,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/random"
+    "github.com/duke-git/lancet/v2/random"
 )

 func main() {
@@ -70,7 +70,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/random"
+    "github.com/duke-git/lancet/v2/random"
 )

 func main() {
@@ -96,7 +96,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/random"
+    "github.com/duke-git/lancet/v2/random"
 )

 func main() {
@@ -123,7 +123,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/random"
+    "github.com/duke-git/lancet/v2/random"
 )

 func main() {
--- a/docs/random_zh-CN.md
+++ b/docs/random_zh-CN.md
@@ -5,7 +5,7 @@ random随机数生成器包，可以生成随机[]bytes, int, string。

 ## 源码:

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


 <div STYLE="page-break-after: always;"></div>
@@ -13,7 +13,7 @@ random随机数生成器包，可以生成随机[]bytes, int, string。
 ## 用法:
 ```go
 import (
-    "github.com/duke-git/lancet/random"
+    "github.com/duke-git/lancet/v2/random"
 )
 ```

@@ -46,7 +46,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/random"
+    "github.com/duke-git/lancet/v2/random"
 )

 func main() {
@@ -71,7 +71,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/random"
+    "github.com/duke-git/lancet/v2/random"
 )

 func main() {
@@ -97,7 +97,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/random"
+    "github.com/duke-git/lancet/v2/random"
 )

 func main() {
@@ -123,7 +123,7 @@ package main

 import (
    "fmt"
-    "github.com/duke-git/lancet/random"
+    "github.com/duke-git/lancet/v2/random"
 )

 func main() {
--- a/docs/retry.md
+++ b/docs/retry.md
@@ -5,7 +5,7 @@ Package retry is for executing a function repeatedly until it was successful or

 ## Source:

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


 <div STYLE="page-break-after: always;"></div>
@@ -13,7 +13,7 @@ Package retry is for executing a function repeatedly until it was successful or
 ## Usage:
 ```go
 import (
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )
 ```

@@ -46,7 +46,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/duke-git/lancet/retry"
+	"github.com/duke-git/lancet/v2/retry"
 	"time"
 )

@@ -92,7 +92,7 @@ import (
    "fmt"
    "errors"
    "log"
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )

 func main() {
@@ -134,7 +134,7 @@ import (
    "fmt"
    "errors"
    "log"
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )

 func main() {
@@ -173,7 +173,7 @@ import (
    "fmt"
    "errors"
    "log"
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )

 func main() {
@@ -213,7 +213,7 @@ import (
    "fmt"
    "errors"
    "log"
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )

 func main() {
--- a/docs/retry_zh-CN.md
+++ b/docs/retry_zh-CN.md
@@ -5,7 +5,7 @@ retry重试执行函数直到函数运行成功或被context cancel。

 ## 源码:

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


 <div STYLE="page-break-after: always;"></div>
@@ -13,7 +13,7 @@ retry重试执行函数直到函数运行成功或被context cancel。
 ## 用法:
 ```go
 import (
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )
 ```

@@ -94,7 +94,7 @@ import (
    "fmt"
    "errors"
    "log"
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )

 func main() {
@@ -136,7 +136,7 @@ import (
    "fmt"
    "errors"
    "log"
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )

 func main() {
@@ -175,7 +175,7 @@ import (
    "fmt"
    "errors"
    "log"
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )

 func main() {
@@ -215,7 +215,7 @@ import (
    "fmt"
    "errors"
    "log"
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )

 func main() {
--- a/docs/slice.md
+++ b/docs/slice.md
@@ -5,7 +5,7 @@ Package slice implements some functions to manipulate slice.

 ## Source:

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


 <div STYLE="page-break-after: always;"></div>
@@ -13,7 +13,7 @@ Package slice implements some functions to manipulate slice.
 ## Usage:
 ```go
 import (
-    "github.com/duke-git/lancet/slice"
+    "github.com/duke-git/lancet/v2/slice"
 )
 ```

@@ -28,53 +28,58 @@ import (
 - [Count](#Count)
 - [Difference](#Difference)
 - [DifferenceBy](#DifferenceBy)
- [DeleteByIndex](#DeleteByIndex)
+- [DifferenceWith](#DifferenceWith)
+- [DeleteAt](#DeleteAt)
 - [Drop](#Drop)
+- [Equal](#Equal)
+- [EqualWith](#EqualWith)
 - [Every](#Every)
 - [Filter](#Filter)
 - [Find](#Find)
 - [FindLast](#FindLast)
 - [FlattenDeep](#FlattenDeep)
 - [ForEach](#ForEach)
-  
+
 - [GroupBy](#GroupBy)
+- [GroupWith](#GroupWith)
 - [IntSlice](#IntSlice)
 - [InterfaceSlice](#InterfaceSlice)
 - [Intersection](#Intersection)
- [InsertByIndex](#InsertByIndex)
+- [InsertAt](#InsertAt)
+- [IndexOf](#IndexOf)
+- [LastIndexOf](#LastIndexOf)
 - [Map](#Map)
- [ReverseSlice](#ReverseSlice)
+- [Reverse](#Reverse)
 - [Reduce](#Reduce)
 - [Shuffle](#Shuffle)
 - [SortByField](#SortByField)
 - [Some](#Some)
 - [StringSlice](#StringSlice)
+- [SymmetricDifference](#SymmetricDifference)
 - [Unique](#Unique)
+- [UniqueBy](#UniqueBy)
 - [Union](#Union)
- [UpdateByIndex](#UpdateByIndex)
+- [UpdateAt](#UpdateAt)
 - [Without](#Without)

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

 ## Documentation

-## Note:
-1. param which type is interface{} in below functions should be slice.
-
 ### <span id="Contain">Contain</span>
-<p>Check if the value is in the slice or not. iterableType param can be string, map or slice.</p>
+<p>Check if the value is in the slice or not.</p>

 <b>Signature:</b>

 ```go
-func Contain(iterableType interface{}, value interface{}) bool
+func Contain[T any](slice []T, value T) bool
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -90,14 +95,14 @@ func main() {
 <b>Signature:</b>

 ```go
-func ContainSubSlice(slice interface{}, subslice interface{}) bool
+func ContainSubSlice[T any](slice, subslice []T) bool
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -115,20 +120,20 @@ func main() {
 <b>Signature:</b>

 ```go
-func Chunk(slice []interface{}, size int) [][]interface{}
+func Chunk[T any](slice []T, size int) [][]T
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
 	arr := []string{"a", "b", "c", "d", "e"}
 	res := slice.Chunk(InterfaceSlice(arr), 3)
-	fmt.Println(res) //[][]interface{}{{"a", "b", "c"}, {"d", "e"}}
+	fmt.Println(res) //[][]any{{"a", "b", "c"}, {"d", "e"}}
 }
 ```

@@ -140,14 +145,14 @@ func main() {
 <b>Signature:</b>

 ```go
-func Compact(slice interface{}) interface{}
+func Compact[T any](slice []T) []T
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -163,14 +168,14 @@ func main() {
 <b>Signature:</b>

 ```go
-func Concat(slice interface{}, values ...interface{}) interface{}
+func Concat[T any](slice []T, values ...[]T) []T
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -185,19 +190,19 @@ func main() {


 ### <span id="Count">Count</span>
-<p>Count iterates over elements of slice, returns a count of all matched elements. The function signature should be func(index int, value interface{}) bool.</p>
+<p>Count iterates over elements of slice, returns a count of all matched elements.</p>

 <b>Signature:</b>

 ```go
-func Count(slice, function interface{}) int
+func Count[T any](slice []T, predicate func(index int, t T) bool) int
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -220,14 +225,14 @@ func main() {
 <b>Signature:</b>

 ```go
-func Difference(slice1, slice2 interface{}) interface{}
+func Difference[T comparable](slice, comparedSlice []T) []T
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -248,14 +253,14 @@ func main() {
 <b>Signature:</b>

 ```go
-func DifferenceBy(slice interface{}, comparedSlice interface{}, iterateeFn interface{}) interface{}
+func DifferenceBy[T any](slice []T, comparedSlice []T, iteratee func(index int, item T) T) []T
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -271,29 +276,55 @@ func main() {
 ```


-
-
-### <span id="DeleteByIndex">DeleteByIndex</span>
-<p>Delete the element of slice from start index to end index - 1.</p>
+### <span id="DifferenceWith">DifferenceWith</span>
+<p>DifferenceWith accepts comparator which is invoked to compare elements of slice to values. The order and references of result values are determined by the first slice.</p>

 <b>Signature:</b>

 ```go
-func DeleteByIndex(slice interface{}, start int, end ...int) (interface{}, error)
+func DifferenceWith[T any](slice []T, comparedSlice []T, comparator func(value, otherValue T) bool) []T
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
-	res1 := slice.DeleteByIndex([]string{"a", "b", "c", "d", "e"}, 3)
+	s1 := []int{1, 2, 3, 4, 5}
+	s2 := []int{4, 5, 6, 7, 8}
+	isDouble := func(v1, v2 int) bool {
+		return v2 == 2*v1
+	}
+
+	res := slice.DifferenceWith(s1, s2, isDouble)
+	fmt.Println(res) //[]int{1, 5}
+}
+```
+
+### <span id="DeleteAt">DeleteAt</span>
+<p>Delete the element of slice from start index to end index - 1.</p>
+
+<b>Signature:</b>
+
+```go
+func DeleteAt[T any](slice []T, start int, end ...int)
+```
+<b>Example:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	res1 := slice.DeleteAt([]string{"a", "b", "c", "d", "e"}, 3)
 	fmt.Println(res1) //[]string{"a", "b", "c", "e"}

-	res2 := slice.DeleteByIndex([]string{"a", "b", "c", "d", "e"}, 0, 2)
+	res2 := slice.DeleteAt([]string{"a", "b", "c", "d", "e"}, 0, 2)
 	fmt.Println(res2) //[]string{"c", "d", "e"}

 }
@@ -308,14 +339,14 @@ func main() {
 <b>Signature:</b>

 ```go
-func Drop(slice interface{}, n int) interface{}
+func Drop[T any](slice []T, n int) []T
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -332,21 +363,83 @@ func main() {



-
-### <span id="Every">Every</span>
-<p>Return true if all of the values in the slice pass the predicate function. The function signature should be func(index int, value interface{}) bool.</p>
+### <span id="Equal">Equal</span>
+<p>Check if two slices are equal: the same length and all elements' order and value are equal.</p>

 <b>Signature:</b>

 ```go
-func Every(slice, function interface{}) bool
+func Equal[T comparable](slice1, slice2 []T) bool
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	slice1 := []int{1, 2, 3}
+	slice2 := []int{1, 2, 3}
+	slice3 := []int{3, 2, 1}
+
+	res1 := slice.Equal(slice1, slice2)
+	res2 := slice.Equal(slice1, slice3)
+
+	fmt.Println(res1) //true
+	fmt.Println(res2) //false
+}
+```
+
+
+
+### <span id="EqualWith">EqualWith</span>
+<p>Check if two slices are equal with comparator func.</p>
+
+<b>Signature:</b>
+
+```go
+func EqualWith[T, U any](slice1 []T, slice2 []U, comparator func(T, U) bool) bool
+```
+<b>Example:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	slice1 := []int{1, 2, 3}
+	slice2 := []int{2, 4, 6}
+
+	isDouble := func(a, b int) bool {
+		return b == a*2
+	}
+
+	res := slice.EqualWith(slice1, slice2, isDouble)
+
+	fmt.Println(res) //true
+}
+```
+
+
+
+### <span id="Every">Every</span>
+<p>Return true if all of the values in the slice pass the predicate function.</p>
+
+<b>Signature:</b>
+
+```go
+func Every[T any](slice []T, predicate func(index int, item T) bool) bool
+```
+<b>Example:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -364,19 +457,19 @@ func main() {


 ### <span id="Filter">Filter</span>
-<p>Return all elements which match the function. Function signature should be func(index int, value interface{}) bool.</p>
+<p>Return all elements which match the function.</p>

 <b>Signature:</b>

 ```go
-func Filter(slice, function interface{}) interface{}
+func Filter[T any](slice []T, predicate func(index int, item T) bool) []T
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -393,19 +486,19 @@ func main() {


 ### <span id="Find">Find</span>
-<p>Iterates over elements of slice, returning the first one that passes a truth test on function.function signature should be func(index int, value interface{}) bool.</p>
+<p>Iterates over elements of slice, returning the first one that passes a truth test on function.</p>

 <b>Signature:</b>

 ```go
-func Find(slice, function interface{}) (interface{}, bool)
+func Find[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -424,19 +517,19 @@ func main() {


 ### <span id="FindLast">FindLast</span>
-<p>iterates over elements of slice from end to begin, returning the last one that passes a truth test on function. The function signature should be func(index int, value interface{}) bool.</p>
+<p>iterates over elements of slice from end to begin, returning the last one that passes a truth test on function.</p>

 <b>Signature:</b>

 ```go
-func FindLast(slice, function interface{}) (interface{}, bool)
+func FindLast[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -459,14 +552,14 @@ func main() {
 <b>Signature:</b>

 ```go
-func FlattenDeep(slice interface{}) interface{}
+func FlattenDeep(slice any) any
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -481,19 +574,19 @@ func main() {


 ### <span id="ForEach">ForEach</span>
-<p>Iterates over elements of slice and invokes function for each element, function signature should be func(index int, value interface{}).</p>
+<p>Iterates over elements of slice and invokes function for each element.</p>

 <b>Signature:</b>

 ```go
-func ForEach(slice, function interface{})
+func ForEach[T any](slice []T, iteratee func(index int, item T))
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -510,19 +603,19 @@ func main() {


 ### <span id="GroupBy">GroupBy</span>
-<p>Iterates over elements of the slice, each element will be group by criteria, returns two slices. The function signature should be func(index int, value interface{}) bool.</p>
+<p>Iterates over elements of the slice, each element will be group by criteria, returns two slices.</p>

 <b>Signature:</b>

 ```go
-func GroupBy(slice, function interface{}) (interface{}, interface{})
+func GroupBy[T any](slice []T, groupFn func(index int, item T) bool) ([]T, []T)
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -540,24 +633,52 @@ func main() {



-### <span id="IntSlice">IntSlice</span>
-<p>Convert interface slice to int slice.</p>
+### <span id="GroupWith">GroupWith</span>
+<p>Return a map composed of keys generated from the results of running each element of slice thru iteratee.</p>

 <b>Signature:</b>

 ```go
-func IntSlice(slice interface{}) []int
+func GroupWith[T any, U comparable](slice []T, iteratee func(T) U) map[U][]T 
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
-	var nums = []interface{}{1, 2, 3}
+	nums := []float64{6.1, 4.2, 6.3}
+	floor := func(num float64) float64 {
+		return math.Floor(num)
+	}
+	res := slice.GroupWith(nums, floor)
+	fmt.Println(res) //map[float64][]float64{ 4: {4.2}, 6: {6.1, 6.3},}
+}
+```
+
+
+
+### <span id="IntSlice">IntSlice</span>
+<p>Convert interface slice to int slice.</p>
+
+<b>Signature:</b>
+
+```go
+func IntSlice(slice any) []int
+```
+<b>Example:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	var nums = []any{1, 2, 3}
 	res := slice.IntSlice(nums)
 	fmt.Println(res) //[]int{1, 2, 3}
 }
@@ -572,20 +693,20 @@ func main() {
 <b>Signature:</b>

 ```go
-func InterfaceSlice(slice interface{}) []interface{}
+func InterfaceSlice(slice any) []any
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
 	var nums = []int{}{1, 2, 3}
 	res := slice.InterfaceSlice(nums)
-	fmt.Println(res) //[]interface{}{1, 2, 3}
+	fmt.Println(res) //[]any{1, 2, 3}
 }
 ```

@@ -598,14 +719,14 @@ func main() {
 <b>Signature:</b>

 ```go
-func Intersection(slices ...interface{}) interface{}
+func Intersection[T any](slices ...[]T) []T
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -620,29 +741,29 @@ func main() {



-### <span id="InsertByIndex">InsertByIndex</span>
+### <span id="InsertAt">InsertAt</span>
 <p>insert the element into slice at index.</p>

 <b>Signature:</b>

 ```go
-func InsertByIndex(slice interface{}, index int, value interface{}) (interface{}, error)
+func InsertAt[T any](slice []T, index int, value any) []T
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
 	s := []string{"a", "b", "c"}
 	
-	res1, _ := slice.InsertByIndex(s, 0, "1")
+	res1, _ := slice.InsertAt(s, 0, "1")
 	fmt.Println(res1) //[]string{"1", "a", "b", "c"}

-	res2, _ := slice.InsertByIndex(s, 3, []string{"1", "2", "3"})
+	res2, _ := slice.InsertAt(s, 3, []string{"1", "2", "3"})
 	fmt.Println(res2) //[]string{"a", "b", "c", "1", "2", "3"}
 }
 ```
@@ -650,20 +771,77 @@ func main() {



-### <span id="Map">Map</span>
-<p>Creates an slice of values by running each element in slice thru function, function signature should be func(index int, value interface{}) interface{}.</p>
+### <span id="IndexOf">IndexOf</span>
+<p>Returns the index at which the first occurrence of a value is found in a slice or return -1 if the value cannot be found.</p>

 <b>Signature:</b>

 ```go
-func Map(slice, function interface{}) interface{}
+func IndexOf[T any](slice []T, value T) int
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	arr := []string{"a", "a", "b", "c"}
+	res1 := slice.IndexOf(arr, "a")
+	fmt.Println(res1) //0
+
+	res2 := slice.IndexOf(arr, "d")
+	fmt.Println(res2) //-1
+}
+```
+
+
+
+### <span id="LastIndexOf">LastIndexOf</span>
+<p>Returns the index at which the last occurrence of a value is found in a slice or return -1 if the value cannot be found.</p>
+
+<b>Signature:</b>
+
+```go
+func LastIndexOf[T any](slice []T, value T) int
+```
+<b>Example:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	arr := []string{"a", "a", "b", "c"}
+	res1 := slice.LastIndexOf(arr, "a")
+	fmt.Println(res1) //1
+
+	res2 := slice.LastIndexOf(arr, "d")
+	fmt.Println(res2) //-1
+}
+```
+
+
+
+
+### <span id="Map">Map</span>
+<p>Creates an slice of values by running each element in slice thru function.</p>
+
+<b>Signature:</b>
+
+```go
+func Map[T any, U any](slice []T, iteratee func(index int, item T) U) []U
+```
+<b>Example:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -679,25 +857,25 @@ func main() {



-### <span id="ReverseSlice">ReverseSlice</span>
+### <span id="Reverse">Reverse</span>
 <p>Reverse the elements order in slice.</p>

 <b>Signature:</b>

 ```go
-func ReverseSlice(slice interface{})
+func Reverse[T any](slice []T)
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
 	nums := []int{1, 2, 3, 4}
-	slice.ReverseSlice(nums)
+	slice.Reverse(nums)
 	fmt.Println(res) //[]int{4, 3, 2, 1}
 }
 ```
@@ -705,19 +883,19 @@ func main() {


 ### <span id="Reduce">Reduce</span>
-<p>Reduce slice, function signature should be func(index int, value1, value2 interface{}) interface{}.</p>
+<p>Reduce slice.</p>

 <b>Signature:</b>

 ```go
-func Reduce(slice, function, zero interface{}) interface{}
+func Reduce[T any](slice []T, iteratee func(index int, item1, item2 T) T, initial T) T
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -739,14 +917,14 @@ func main() {
 <b>Signature:</b>

 ```go
-func Shuffle(slice interface{}) interface{}
+func Shuffle[T any](slice []T) []T
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -764,14 +942,14 @@ func main() {
 <b>Signature:</b>

 ```go
-func SortByField(slice interface{}, field string, sortType ...string) error
+func SortByField(slice any, field string, sortType ...string) error
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -802,19 +980,19 @@ func main() {


 ### <span id="Some">Some</span>
-<p>Return true if any of the values in the list pass the predicate function, function signature should be func(index int, value interface{}) bool.</p>
+<p>Return true if any of the values in the list pass the predicate function.</p>

 <b>Signature:</b>

 ```go
-func Some(slice, function interface{}) bool
+func Some[T any](slice []T, predicate func(index int, item T) bool) bool
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -836,18 +1014,18 @@ func main() {
 <b>Signature:</b>

 ```go
-func StringSlice(slice interface{}) []string
+func StringSlice(slice any) []string
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
-	var s = []interface{}{"a", "b", "c"}
+	var s = []any{"a", "b", "c"}
 	res := slice.StringSlice(s)
 	fmt.Println(res) //[]string{"a", "b", "c"}
 }
@@ -856,20 +1034,49 @@ func main() {



+### <span id="SymmetricDifference">SymmetricDifference</span>
+<p>Create a slice whose element is in given slices, but not in both slices.</p>
+
+<b>Signature:</b>
+
+```go
+func SymmetricDifference[T any](slices ...[]T) []T
+```
+<b>Example:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	s1 := []int{1, 2, 3}
+	s2 := []int{1, 2, 4}
+	s3 := []int{1, 2, 3, 5}
+
+	fmt.Println(slice.SymmetricDifference(s1)) //[]int{1, 2, 3}
+	fmt.Println(slice.SymmetricDifference(s1, s2)) //[]int{3, 4}
+	fmt.Println(slice.SymmetricDifference(s1, s2, s3)) //[]int{3, 4, 5}
+}
+```
+
+
+
 ### <span id="Unique">Unique</span>
 <p>Remove duplicate elements in slice.</p>

 <b>Signature:</b>

 ```go
-func Unique(slice interface{}) interface{}
+func Unique[T any](slice []T) []T
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -880,13 +1087,13 @@ func main() {



-### <span id="Union">Unique</span>
-<p>Creates a slice of unique values, in order, from all given slices. using == for equality comparisons.</p>
+### <span id="UniqueBy">UniqueBy</span>
+<p>Call iteratee func with every item of slice, then remove duplicated.</p>

 <b>Signature:</b>

 ```go
-func Union(slices ...interface{}) interface{}
+func UniqueBy[T any](slice []T, iteratee func(item T) T) []T
 ```
 <b>Example:</b>

@@ -896,6 +1103,32 @@ import (
 	"github.com/duke-git/lancet/slice"
 )

+func main() {
+	res := slice.UniqueBy([]int{1, 2, 3, 4, 5, 6}, func(val int) int {
+		return val % 4
+	})
+	fmt.Println(res) //[]int{1, 2, 3, 0}
+}
+```
+
+
+
+### <span id="Union">Union</span>
+<p>Creates a slice of unique values, in order, from all given slices. using == for equality comparisons.</p>
+
+<b>Signature:</b>
+
+```go
+func Union[T any](slices ...[]T) []T
+```
+<b>Example:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
 func main() {
 	s1 := []int{1, 3, 4, 6}
 	s2 := []int{1, 2, 5, 6}
@@ -907,26 +1140,26 @@ func main() {



-### <span id="UpdateByIndex">UpdateByIndex</span>
+### <span id="UpdateAt">UpdateAt</span>
 <p>Update the slice element at index. if param index < 0 or index >= len(slice), will return error. </p>

 <b>Signature:</b>

 ```go
-func UpdateByIndex(slice interface{}, index int, value interface{}) (interface{}, error)
+func UpdateAt[T any](slice []T, index int, value T) []T
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
 	s := []string{"a", "b", "c"}
 	
-	res1, _ := slice.UpdateByIndex(s, 0, "1")
+	res1, _ := slice.UpdateAt(s, 0, "1")
 	fmt.Println(res1) //[]string{"1", "b", "c"}
 }
 ```
@@ -940,14 +1173,14 @@ func main() {
 <b>Signature:</b>

 ```go
-func Without(slice interface{}, values ...interface{}) interface{}
+func Without[T any](slice []T, values ...T) []T
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
--- a/docs/slice_zh-CN.md
+++ b/docs/slice_zh-CN.md
@@ -5,7 +5,7 @@ slice包包含操作切片的方法集合。

 ## 源码:

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


 <div STYLE="page-break-after: always;"></div>
@@ -13,7 +13,7 @@ slice包包含操作切片的方法集合。
 ## 用法:
 ```go
 import (
-    "github.com/duke-git/lancet/slice"
+    "github.com/duke-git/lancet/v2/slice"
 )
 ```

@@ -28,9 +28,12 @@ import (
 - [Count](#Count)
 - [Difference](#Difference)
 - [DifferenceBy](#DifferenceBy)
- [DeleteByIndex](#DeleteByIndex)
+- [DifferenceWith](#DifferenceWith)
+- [DeleteAt](#DeleteAt)
 - [Drop](#Drop)
 - [Every](#Every)
+- [Equal](#Equal)
+- [EqualWith](#EqualWith)
 - [Filter](#Filter)
 - [Find](#Find)
 - [FindLast](#FindLast)
@@ -38,20 +41,25 @@ import (
 - [ForEach](#ForEach)
  
 - [GroupBy](#GroupBy)
+- [GroupWith](#GroupWith)
 - [IntSlice](#IntSlice)
 - [InterfaceSlice](#InterfaceSlice)
 - [Intersection](#Intersection)
- [InsertByIndex](#InsertByIndex)
+- [InsertAt](#InsertAt)
+- [IndexOf](#IndexOf)
+- [LastIndexOf](#LastIndexOf)
 - [Map](#Map)
- [ReverseSlice](#ReverseSlice)
+- [Reverse](#Reverse)
 - [Reduce](#Reduce)
 - [Shuffle](#Shuffle)
 - [SortByField](#SortByField)
 - [Some](#Some)
 - [StringSlice](#StringSlice)
+- [SymmetricDifference](#SymmetricDifference)
 - [Unique](#Unique)
+- [UniqueBy](#UniqueBy)
 - [Union](#Union)
- [UpdateByIndex](#UpdateByIndex)
+- [UpdateAt](#UpdateAt)
 - [Without](#Without)

 <div STYLE="page-break-after: always;"></div>
@@ -64,14 +72,14 @@ import (
 <b>函数签名:</b>

 ```go
-func Contain(iterableType interface{}, value interface{}) bool
+func Contain[T any](slice []T, value T) bool
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -87,14 +95,14 @@ func main() {
 <b>函数签名:</b>

 ```go
-func ContainSubSlice(slice interface{}, subslice interface{}) bool
+func ContainSubSlice[T any](slice, subslice []T) bool
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -112,20 +120,20 @@ func main() {
 <b>函数签名:</b>

 ```go
-func Chunk(slice []interface{}, size int) [][]interface{}
+func Chunk[T any](slice []T, size int) [][]T
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
 	arr := []string{"a", "b", "c", "d", "e"}
 	res := slice.Chunk(InterfaceSlice(arr), 3)
-	fmt.Println(res) //[][]interface{}{{"a", "b", "c"}, {"d", "e"}}
+	fmt.Println(res) //[][]any{{"a", "b", "c"}, {"d", "e"}}
 }
 ```

@@ -137,14 +145,14 @@ func main() {
 <b>函数签名:</b>

 ```go
-func Compact(slice interface{}) interface{}
+func Compact[T any](slice []T) []T
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -160,14 +168,14 @@ func main() {
 <b>函数签名:</b>

 ```go
-func Concat(slice interface{}, values ...interface{}) interface{}
+func Concat[T any](slice []T, values ...[]T) []T
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -182,19 +190,19 @@ func main() {


 ### <span id="Count">Count</span>
-<p>遍历切片，对每个元素执行函数function. 返回符合函数返回值为true的元素的个数，函数签名必须是func(index int, value interface{}) bool</p>
+<p>遍历切片，对每个元素执行函数function. 返回符合函数返回值为true的元素的个数</p>

 <b>函数签名:</b>

 ```go
-func Count(slice, function interface{}) int
+func Count[T any](slice []T, predicate func(index int, t T) bool) int
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -217,14 +225,14 @@ func main() {
 <b>函数签名:</b>

 ```go
-func Difference(slice1, slice2 interface{}) interface{}
+func Difference[T comparable](slice, comparedSlice []T) []T
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -245,14 +253,14 @@ func main() {
 <b>函数签名:</b>

 ```go
-func DifferenceBy(slice interface{}, comparedSlice interface{}, iterateeFn interface{}) interface{}
+func DifferenceBy[T any](slice []T, comparedSlice []T, iteratee func(index int, item T) T) []T
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -269,28 +277,56 @@ func main() {



-
-### <span id="DeleteByIndex">DeleteByIndex</span>
-<p>删除切片中从开始索引到结束索引-1的元素</p>
+### <span id="DifferenceWith">DifferenceWith</span>
+<p>DifferenceWith 接受比较器，该比较器被调用以将切片的元素与值进行比较。 结果值的顺序和引用由第一个切片确定</p>

 <b>函数签名:</b>

 ```go
-func DeleteByIndex(slice interface{}, start int, end ...int) (interface{}, error)
+func DifferenceWith[T any](slice []T, comparedSlice []T, comparator func(value, otherValue T) bool) []T
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
-	res1 := slice.DeleteByIndex([]string{"a", "b", "c", "d", "e"}, 3)
+	s1 := []int{1, 2, 3, 4, 5}
+	s2 := []int{4, 5, 6, 7, 8}
+	isDouble := func(v1, v2 int) bool {
+		return v2 == 2*v1
+	}
+
+	res := slice.DifferenceWith(s1, s2, isDouble)
+	fmt.Println(res) //[]int{1, 5}
+}
+```
+
+
+### <span id="DeleteAt">DeleteAt</span>
+<p>删除切片中从开始索引到结束索引-1的元素</p>
+
+<b>函数签名:</b>
+
+```go
+func DeleteAt[T any](slice []T, start int, end ...int)
+```
+<b>例子:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	res1 := slice.DeleteAt([]string{"a", "b", "c", "d", "e"}, 3)
 	fmt.Println(res1) //[]string{"a", "b", "c", "e"}

-	res2 := slice.DeleteByIndex([]string{"a", "b", "c", "d", "e"}, 0, 2)
+	res2 := slice.DeleteAt([]string{"a", "b", "c", "d", "e"}, 0, 2)
 	fmt.Println(res2) //[]string{"c", "d", "e"}

 }
@@ -305,14 +341,14 @@ func main() {
 <b>函数签名:</b>

 ```go
-func Drop(slice interface{}, n int) interface{}
+func Drop[T any](slice []T, n int) []T
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -331,19 +367,19 @@ func main() {


 ### <span id="Every">Every</span>
-<p>如果切片中的所有值都通过谓词函数，则返回true。 函数签名应该是func(index int, value interface{}) bool</p>
+<p>如果切片中的所有值都通过谓词函数，则返回true。 函数签名应该是func(index int, value any) bool</p>

 <b>函数签名:</b>

 ```go
-func Every(slice, function interface{}) bool
+func Every[T any](slice []T, predicate func(index int, item T) bool) bool
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -360,20 +396,83 @@ func main() {



-### <span id="Filter">Filter</span>
-<p>返回与函数匹配的所有元素。 函数签名应该是 func(index int, value interface{}) bool</p>
+### <span id="Equal">Equal</span>
+<p>检查两个切片是否相等，相等条件：切片长度相同，元素顺序和值都相同</p>

 <b>函数签名:</b>

 ```go
-func Filter(slice, function interface{}) interface{}
+func Equal[T comparable](slice1, slice2 []T) bool
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	slice1 := []int{1, 2, 3}
+	slice2 := []int{1, 2, 3}
+	slice3 := []int{3, 2, 1}
+
+	res1 := slice.Equal(slice1, slice2)
+	res2 := slice.Equal(slice1, slice3)
+
+	fmt.Println(res1) //true
+	fmt.Println(res2) //false
+}
+```
+
+
+
+### <span id="EqualWith">EqualWith</span>
+<p>检查两个切片是否相等，相等条件：对两个切片的元素调用比较函数comparator，返回true</p>
+
+<b>函数签名:</b>
+
+```go
+func EqualWith[T, U any](slice1 []T, slice2 []U, comparator func(T, U) bool) bool
+```
+<b>例子:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	slice1 := []int{1, 2, 3}
+	slice2 := []int{2, 4, 6}
+
+	isDouble := func(a, b int) bool {
+		return b == a*2
+	}
+
+	res := slice.EqualWith(slice1, slice2, isDouble)
+
+	fmt.Println(res) //true
+}
+```
+
+
+
+### <span id="Filter">Filter</span>
+<p>返回切片中通过predicate函数真值测试的所有元素</p>
+
+<b>函数签名:</b>
+
+```go
+func Filter[T any](slice []T, predicate func(index int, item T) bool) []T
+```
+<b>例子:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -390,19 +489,19 @@ func main() {


 ### <span id="Find">Find</span>
-<p>遍历slice的元素，返回第一个通过function真值测试的元素。函数签名应该是 func(index int, value interface{}) bool</p>
+<p>遍历切片的元素，返回第一个通过predicate函数真值测试的元素</p>

 <b>函数签名:</b>

 ```go
-func Find(slice, function interface{}) (interface{}, bool)
+func Find[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -421,19 +520,19 @@ func main() {


 ### <span id="FindLast">FindLast</span>
-<p>从头到尾遍历 slice 的元素，返回最后一个通过函数真值测试的元素。 函数签名应该是 func(index int, value interface{}) bool。</p>
+<p>从头到尾遍历slice的元素，返回最后一个通过predicate函数真值测试的元素。</p>

 <b>函数签名:</b>

 ```go
-func FindLast(slice, function interface{}) (interface{}, bool)
+func FindLast[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -456,14 +555,14 @@ func main() {
 <b>函数签名:</b>

 ```go
-func FlattenDeep(slice interface{}) interface{}
+func FlattenDeep(slice any) any
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -478,19 +577,19 @@ func main() {


 ### <span id="ForEach">ForEach</span>
-<p>遍历slice的元素并为每个元素调用函数，函数签名应该是func(index int, value interface{})</p>
+<p>遍历切片的元素并为每个元素调用iteratee函数</p>

 <b>函数签名:</b>

 ```go
-func ForEach(slice, function interface{})
+func ForEach[T any](slice []T, iteratee func(index int, item T))
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -507,19 +606,19 @@ func main() {


 ### <span id="GroupBy">GroupBy</span>
-<p>迭代切片的元素，每个元素将按条件分组，返回两个切片。 函数签名应该是func(index int, value interface{}) bool</p>
+<p>迭代切片的元素，每个元素将按条件分组，返回两个切片</p>

 <b>函数签名:</b>

 ```go
-func GroupBy(slice, function interface{}) (interface{}, interface{})
+func GroupBy[T any](slice []T, groupFn func(index int, item T) bool) ([]T, []T)
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -536,6 +635,32 @@ func main() {



+### <span id="GroupWith">GroupWith</span>
+<p>创建一个map，key是iteratee遍历slice中的每个元素返回的结果。 分组值的顺序是由他们出现在slice中的顺序确定的。每个键对应的值负责生成key的元素组成的数组。iteratee调用1个参数： (value)</p>
+
+<b>函数签名:</b>
+
+```go
+func GroupWith[T any, U comparable](slice []T, iteratee func(T) U) map[U][]T 
+```
+<b>例子:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	nums := []float64{6.1, 4.2, 6.3}
+	floor := func(num float64) float64 {
+		return math.Floor(num)
+	}
+	res := slice.GroupWith(nums, floor)
+	fmt.Println(res) //map[float64][]float64{ 4: {4.2}, 6: {6.1, 6.3},}
+}
+```
+

 ### <span id="IntSlice">IntSlice</span>
 <p>将接口切片转换为int切片</p>
@@ -543,18 +668,18 @@ func main() {
 <b>函数签名:</b>

 ```go
-func IntSlice(slice interface{}) []int
+func IntSlice(slice any) []int
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
-	var nums = []interface{}{1, 2, 3}
+	var nums = []any{1, 2, 3}
 	res := slice.IntSlice(nums)
 	fmt.Println(res) //[]int{1, 2, 3}
 }
@@ -569,20 +694,20 @@ func main() {
 <b>函数签名:</b>

 ```go
-func InterfaceSlice(slice interface{}) []interface{}
+func InterfaceSlice(slice any) []any
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
 	var nums = []int{}{1, 2, 3}
 	res := slice.InterfaceSlice(nums)
-	fmt.Println(res) //[]interface{}{1, 2, 3}
+	fmt.Println(res) //[]any{1, 2, 3}
 }
 ```

@@ -595,14 +720,14 @@ func main() {
 <b>函数签名:</b>

 ```go
-func Intersection(slices ...interface{}) interface{}
+func Intersection[T any](slices ...[]T) []T
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -617,29 +742,29 @@ func main() {



-### <span id="InsertByIndex">InsertByIndex</span>
+### <span id="InsertAt">InsertAt</span>
 <p>将元素插入到索引处的切片中</p>

 <b>函数签名:</b>

 ```go
-func InsertByIndex(slice interface{}, index int, value interface{}) (interface{}, error)
+func InsertAt[T any](slice []T, index int, value any) []T
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
 	s := []string{"a", "b", "c"}
 	
-	res1, _ := slice.InsertByIndex(s, 0, "1")
+	res1, _ := slice.InsertAt(s, 0, "1")
 	fmt.Println(res1) //[]string{"1", "a", "b", "c"}

-	res2, _ := slice.InsertByIndex(s, 3, []string{"1", "2", "3"})
+	res2, _ := slice.InsertAt(s, 3, []string{"1", "2", "3"})
 	fmt.Println(res2) //[]string{"a", "b", "c", "1", "2", "3"}
 }
 ```
@@ -647,20 +772,76 @@ func main() {



-### <span id="Map">Map</span>
-<p>通过运行函数slice中的每个元素来创建一个值切片，函数签名应该是func(index int, value interface{}) interface{}。</p>
+### <span id="IndexOf">IndexOf</span>
+<p>返回在切片中找到值的第一个匹配项的索引，如果找不到值，则返回-1</p>

 <b>函数签名:</b>

 ```go
-func Map(slice, function interface{}) interface{}
+func IndexOf[T any](slice []T, value T) int
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	arr := []string{"a", "a", "b", "c"}
+	res1 := slice.IndexOf(arr, "a")
+	fmt.Println(res1) //0
+
+	res2 := slice.IndexOf(arr, "d")
+	fmt.Println(res2) //-1
+}
+```
+
+
+
+### <span id="LastIndexOf">LastIndexOf</span>
+<p>返回在切片中找到最后一个值的索引，如果找不到该值，则返回-1</p>
+
+<b>函数签名:</b>
+
+```go
+func LastIndexOf[T any](slice []T, value T) int
+```
+<b>例子:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	arr := []string{"a", "a", "b", "c"}
+	res1 := slice.LastIndexOf(arr, "a")
+	fmt.Println(res1) //1
+
+	res2 := slice.LastIndexOf(arr, "d")
+	fmt.Println(res2) //-1
+}
+```
+
+
+
+### <span id="Map">Map</span>
+<p>通过运行函数slice中的每个元素来创建一个新切片</p>
+
+<b>函数签名:</b>
+
+```go
+func Map[T any, U any](slice []T, iteratee func(index int, item T) U) []U
+```
+<b>例子:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -676,25 +857,25 @@ func main() {



-### <span id="ReverseSlice">ReverseSlice</span>
+### <span id="Reverse">Reverse</span>
 <p>反转切片中的元素顺序</p>

 <b>函数签名:</b>

 ```go
-func ReverseSlice(slice interface{})
+func Reverse[T any](slice []T)
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
 	nums := []int{1, 2, 3, 4}
-	slice.ReverseSlice(nums)
+	slice.Reverse(nums)
 	fmt.Println(res) //[]int{4, 3, 2, 1}
 }
 ```
@@ -702,19 +883,19 @@ func main() {


 ### <span id="Reduce">Reduce</span>
-<p>将slice中的元素运行函数，返回运行结果。函数签名应该是func(index int, value1, value2 interface{}) interface{}。</p>
+<p>将切片中的元素依次运行iteratee函数，返回运行结果</p>

 <b>函数签名:</b>

 ```go
-func Reduce(slice, function, zero interface{}) interface{}
+func Reduce[T any](slice []T, iteratee func(index int, item1, item2 T) T, initial T) T
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -736,14 +917,14 @@ func main() {
 <b>函数签名:</b>

 ```go
-func Shuffle(slice interface{}) interface{}
+func Shuffle[T any](slice []T) []T
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -761,14 +942,14 @@ func main() {
 <b>函数签名:</b>

 ```go
-func SortByField(slice interface{}, field string, sortType ...string) error
+func SortByField(slice any, field string, sortType ...string) error
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -799,19 +980,19 @@ func main() {


 ### <span id="Some">Some</span>
-<p>如果列表中的任何值通过谓词函数，则返回true，函数签名应该是func(index int, value interface{}) bool .</p>
+<p>如果列表中的任何值通过谓词函数，则返回true</p>

 <b>函数签名:</b>

 ```go
-func Some(slice, function interface{}) bool
+func Some[T any](slice []T, predicate func(index int, item T) bool) bool
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -833,18 +1014,18 @@ func main() {
 <b>函数签名:</b>

 ```go
-func StringSlice(slice interface{}) []string
+func StringSlice(slice any) []string
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
-	var s = []interface{}{"a", "b", "c"}
+	var s = []any{"a", "b", "c"}
 	res := slice.StringSlice(s)
 	fmt.Println(res) //[]string{"a", "b", "c"}
 }
@@ -853,20 +1034,48 @@ func main() {



-### <span id="Unique">Unique</span>
-<p>删除切片中的重复元素</p>
+### <span id="SymmetricDifference">SymmetricDifference</span>
+<p>返回一个切片，其中的元素存在于参数切片中，但不同时存储在于参数切片中（交集取反）</p>

 <b>函数签名:</b>

 ```go
-func Unique(slice interface{}) interface{}
+func SymmetricDifference[T any](slices ...[]T) []T
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	s1 := []int{1, 2, 3}
+	s2 := []int{1, 2, 4}
+	s3 := []int{1, 2, 3, 5}
+
+	fmt.Println(slice.SymmetricDifference(s1)) //[]int{1, 2, 3}
+	fmt.Println(slice.SymmetricDifference(s1, s2)) //[]int{3, 4}
+	fmt.Println(slice.SymmetricDifference(s1, s2, s3)) //[]int{3, 4, 5}
+}
+```
+
+
+### <span id="Unique">Unique</span>
+<p>删除切片中的重复元素</p>
+
+<b>函数签名:</b>
+
+```go
+func Unique[T any](slice []T) []T
+```
+<b>例子:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
@@ -877,13 +1086,13 @@ func main() {



-### <span id="Union">Unique</span>
-<p>从所有给定的切片按顺序创建一个唯一值切片。 使用 == 进行相等比较。</p>
+### <span id="UniqueBy">UniqueBy</span>
+<p>对切片的每个元素调用iteratee函数，然后删除重复元素</p>

 <b>函数签名:</b>

 ```go
-func Union(slices ...interface{}) interface{}
+func UniqueBy[T any](slice []T, iteratee func(item T) T) []T
 ```
 <b>例子:</b>

@@ -893,6 +1102,32 @@ import (
 	"github.com/duke-git/lancet/slice"
 )

+func main() {
+	res := slice.UniqueBy([]int{1, 2, 3, 4, 5, 6}, func(val int) int {
+		return val % 4
+	})
+	fmt.Println(res) //[]int{1, 2, 3, 0}
+}
+```
+
+
+
+### <span id="Union">Union</span>
+<p>从所有给定的切片按顺序创建一个唯一值切片，使用==进行相等比较</p>
+
+<b>函数签名:</b>
+
+```go
+func Union[T any](slices ...[]T) []T
+```
+<b>例子:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
 func main() {
 	s1 := []int{1, 3, 4, 6}
 	s2 := []int{1, 2, 5, 6}
@@ -904,26 +1139,26 @@ func main() {



-### <span id="UpdateByIndex">UpdateByIndex</span>
-<p>更新索引处的切片元素。 如果 param index < 0 或 index >= len(slice)，将返回错误</p>
+### <span id="UpdateAt">UpdateAt</span>
+<p>更新索引处的切片元素。 如果index < 0或 index >= len(slice)，将返回错误</p>

 <b>函数签名:</b>

 ```go
-func UpdateByIndex(slice interface{}, index int, value interface{}) (interface{}, error)
+func UpdateAt[T any](slice []T, index int, value T) []T
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
 	s := []string{"a", "b", "c"}
 	
-	res1, _ := slice.UpdateByIndex(s, 0, "1")
+	res1, _ := slice.UpdateAt(s, 0, "1")
 	fmt.Println(res1) //[]string{"1", "b", "c"}
 }
 ```
@@ -937,14 +1172,14 @@ func main() {
 <b>函数签名:</b>

 ```go
-func Without(slice interface{}, values ...interface{}) interface{}
+func Without[T any](slice []T, values ...T) []T
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/slice"
+	"github.com/duke-git/lancet/v2/slice"
 )

 func main() {
--- a/docs/strutil.md
+++ b/docs/strutil.md
@@ -5,7 +5,7 @@ Package strutil contains some functions to manipulate string.

 ## Source:

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


 <div STYLE="page-break-after: always;"></div>
@@ -13,7 +13,7 @@ Package strutil contains some functions to manipulate string.
 ## Usage:
 ```go
 import (
-    "github.com/duke-git/lancet/strutil"
+    "github.com/duke-git/lancet/v2/strutil"
 )
 ```

@@ -34,6 +34,7 @@ import (
 - [PadStart](#PadStart)
 - [ReverseStr](#ReverseStr)
 - [SnakeCase](#SnakeCase)
+- [SplitEx](#SplitEx)
 - [Wrap](#Wrap)
  
 - [Unwrap](#Unwrap)
@@ -57,7 +58,7 @@ func After(s, char string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -87,7 +88,7 @@ func AfterLast(s, char string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -118,7 +119,7 @@ func Before(s, char string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -149,7 +150,7 @@ func BeforeLast(s, char string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -180,7 +181,7 @@ func CamelCase(s string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -214,7 +215,7 @@ func Capitalize(s string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -237,14 +238,14 @@ func main() {
 <b>Signature:</b>

 ```go
-func IsString(v interface{}) bool
+func IsString(v any) bool
 ```
 <b>Example:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -272,7 +273,7 @@ func KebabCase(s string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -306,7 +307,7 @@ func LowerFirst(s string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -340,7 +341,7 @@ func UpperFirst(s string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -374,7 +375,7 @@ func PadEnd(source string, size int, padStr string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -408,7 +409,7 @@ func PadStart(source string, size int, padStr string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -442,7 +443,7 @@ func ReverseStr(s string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -469,7 +470,7 @@ func SnakeCase(s string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -493,6 +494,43 @@ func main() {



+### <span id="SplitEx">SplitEx</span>
+<p>Split a given string whether the result contains empty string.</p>
+
+<b>Signature:</b>
+
+```go
+func SplitEx(s, sep string, removeEmptyString bool) []string
+```
+<b>Example:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+	arr1 := strutil.SplitEx(" a b c ", "", true)
+	fmt.Println(arr1) //[]string{}
+
+	arr2 := strutil.SplitEx(" a b c ", " ", false)
+	fmt.Println(arr2) //[]string{"", "a", "b", "c", ""}
+
+	arr3 := strutil.SplitEx(" a b c ", " ", true)
+	fmt.Println(arr3) //[]string{"a", "b", "c"}
+
+	arr4 := strutil.SplitEx(" a = b = c = ", " = ", false)
+	fmt.Println(arr4) //[]string{" a", "b", "c", ""}
+
+	arr5 := strutil.SplitEx(" a = b = c = ", " = ", true)
+	fmt.Println(arr5) //[]string{" a", "b", "c"}
+}
+```
+
+
+
+
 ### <span id="Wrap">Wrap</span>
 <p>Wrap a string with another string.</p>

@@ -506,7 +544,7 @@ func Wrap(str string, wrapWith string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -543,7 +581,7 @@ func Unwrap(str string, wrapToken string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
--- a/docs/strutil_zh-CN.md
+++ b/docs/strutil_zh-CN.md
@@ -5,7 +5,7 @@ strutil包含处理字符串的相关函数。

 ## 源码:

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


 <div STYLE="page-break-after: always;"></div>
@@ -13,7 +13,7 @@ strutil包含处理字符串的相关函数。
 ## 用法:
 ```go
 import (
-    "github.com/duke-git/lancet/strutil"
+    "github.com/duke-git/lancet/v2/strutil"
 )
 ```

@@ -34,6 +34,7 @@ import (
 - [PadStart](#PadStart)
 - [ReverseStr](#ReverseStr)
 - [SnakeCase](#SnakeCase)
+- [SplitEx](#SplitEx)
 - [Wrap](#Wrap)
  
 - [Unwrap](#Unwrap)
@@ -58,7 +59,7 @@ func After(s, char string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -88,7 +89,7 @@ func AfterLast(s, char string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -119,7 +120,7 @@ func Before(s, char string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -150,7 +151,7 @@ func BeforeLast(s, char string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -181,7 +182,7 @@ func CamelCase(s string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -215,7 +216,7 @@ func Capitalize(s string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -238,14 +239,14 @@ func main() {
 <b>函数签名:</b>

 ```go
-func IsString(v interface{}) bool
+func IsString(v any) bool
 ```
 <b>例子:</b>

 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -273,7 +274,7 @@ func KebabCase(s string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -307,7 +308,7 @@ func LowerFirst(s string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -341,7 +342,7 @@ func UpperFirst(s string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -375,7 +376,7 @@ func PadEnd(source string, size int, padStr string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -409,7 +410,7 @@ func PadStart(source string, size int, padStr string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -443,7 +444,7 @@ func ReverseStr(s string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -470,7 +471,7 @@ func SnakeCase(s string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -493,6 +494,41 @@ func main() {



+### <span id="SplitEx">SplitEx</span>
+<p>分割字符串为切片，removeEmptyString参数指定是否去除空字符串</p>
+
+<b>函数签名:</b>
+
+```go
+func SplitEx(s, sep string, removeEmptyString bool) []string
+```
+<b>例子:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+	arr1 := strutil.SplitEx(" a b c ", "", true)
+	fmt.Println(arr1) //[]string{}
+
+	arr2 := strutil.SplitEx(" a b c ", " ", false)
+	fmt.Println(arr2) //[]string{"", "a", "b", "c", ""}
+
+	arr3 := strutil.SplitEx(" a b c ", " ", true)
+	fmt.Println(arr3) //[]string{"a", "b", "c"}
+
+	arr4 := strutil.SplitEx(" a = b = c = ", " = ", false)
+	fmt.Println(arr4) //[]string{" a", "b", "c", ""}
+
+	arr5 := strutil.SplitEx(" a = b = c = ", " = ", true)
+	fmt.Println(arr5) //[]string{" a", "b", "c"}
+}
+```
+
+

 ### <span id="Wrap">Wrap</span>
 <p>用另一个字符串包裹一个字符串</p>
@@ -507,7 +543,7 @@ func Wrap(str string, wrapWith string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
@@ -544,7 +580,7 @@ func Unwrap(str string, wrapToken string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/strutil"
+	"github.com/duke-git/lancet/v2/strutil"
 )

 func main() {
--- a/docs/system.md
+++ b/docs/system.md
@@ -5,7 +5,7 @@ Package system contains some functions about os, runtime, shell command.

 ## Source:

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


 <div STYLE="page-break-after: always;"></div>
@@ -13,7 +13,7 @@ Package system contains some functions about os, runtime, shell command.
 ## Usage:
 ```go
 import (
-    "github.com/duke-git/lancet/system"
+    "github.com/duke-git/lancet/v2/system"
 )
 ```

@@ -48,7 +48,7 @@ func IsWindows() bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/system"
+	"github.com/duke-git/lancet/v2/system"
 )

 func main() {
@@ -73,7 +73,7 @@ func IsLinux() bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/system"
+	"github.com/duke-git/lancet/v2/system"
 )

 func main() {
@@ -97,7 +97,7 @@ func IsMac() bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/system"
+	"github.com/duke-git/lancet/v2/system"
 )

 func main() {
@@ -121,7 +121,7 @@ func GetOsEnv(key string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/system"
+	"github.com/duke-git/lancet/v2/system"
 )

 func main() {
@@ -145,7 +145,7 @@ func SetOsEnv(key, value string) error
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/system"
+	"github.com/duke-git/lancet/v2/system"
 )

 func main() {
@@ -170,7 +170,7 @@ func RemoveOsEnv(key string) error
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/system"
+	"github.com/duke-git/lancet/v2/system"
 )

 func main() {
@@ -196,7 +196,7 @@ func CompareOsEnv(key, comparedEnv string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/system"
+	"github.com/duke-git/lancet/v2/system"
 )

 func main() {
@@ -222,7 +222,7 @@ func ExecCommand(command string) (stdout, stderr string, err error)
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/system"
+	"github.com/duke-git/lancet/v2/system"
 )

 func main() {
--- a/docs/system_zh-CN.md
+++ b/docs/system_zh-CN.md
@@ -5,7 +5,7 @@ system包含os, runtime, shell command相关函数。

 ## 源码:

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


 <div STYLE="page-break-after: always;"></div>
@@ -13,7 +13,7 @@ system包含os, runtime, shell command相关函数。
 ## 用法:
 ```go
 import (
-    "github.com/duke-git/lancet/system"
+    "github.com/duke-git/lancet/v2/system"
 )
 ```

@@ -48,7 +48,7 @@ func IsWindows() bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/system"
+	"github.com/duke-git/lancet/v2/system"
 )

 func main() {
@@ -73,7 +73,7 @@ func IsLinux() bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/system"
+	"github.com/duke-git/lancet/v2/system"
 )

 func main() {
@@ -97,7 +97,7 @@ func IsMac() bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/system"
+	"github.com/duke-git/lancet/v2/system"
 )

 func main() {
@@ -121,7 +121,7 @@ func GetOsEnv(key string) string
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/system"
+	"github.com/duke-git/lancet/v2/system"
 )

 func main() {
@@ -145,7 +145,7 @@ func SetOsEnv(key, value string) error
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/system"
+	"github.com/duke-git/lancet/v2/system"
 )

 func main() {
@@ -170,7 +170,7 @@ func RemoveOsEnv(key string) error
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/system"
+	"github.com/duke-git/lancet/v2/system"
 )

 func main() {
@@ -196,7 +196,7 @@ func CompareOsEnv(key, comparedEnv string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/system"
+	"github.com/duke-git/lancet/v2/system"
 )

 func main() {
@@ -209,7 +209,7 @@ func main() {



-### <span id="ExecCommand">CompareOsEnv</span>
+### <span id="ExecCommand">ExecCommand</span>
 <p>使用shell /bin/bash -c(linux) 或 cmd (windows) 执行shell命令</p>

 <b>Signature:</b>
@@ -222,7 +222,7 @@ func ExecCommand(command string) (stdout, stderr string, err error)
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/system"
+	"github.com/duke-git/lancet/v2/system"
 )

 func main() {
--- a/docs/validator.md
+++ b/docs/validator.md
@@ -5,7 +5,7 @@ Package validator contains some functions for data validation.

 ## Source:

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


 <div STYLE="page-break-after: always;"></div>
@@ -13,7 +13,7 @@ Package validator contains some functions for data validation.
 ## Usage:
 ```go
 import (
-    "github.com/duke-git/lancet/validator"
+    "github.com/duke-git/lancet/v2/validator"
 )
 ```

@@ -67,7 +67,7 @@ func ContainChinese(s string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -97,7 +97,7 @@ func ContainLetter(str string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -128,7 +128,7 @@ func ContainLower(str string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -159,7 +159,7 @@ func ContainUpper(str string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -190,7 +190,7 @@ func IsAlpha(s string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -218,7 +218,7 @@ func IsAllUpper(str string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -246,7 +246,7 @@ func IsAllLower(str string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -274,7 +274,7 @@ func IsBase64(base64 string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -302,7 +302,7 @@ func IsChineseMobile(mobileNum string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -329,7 +329,7 @@ func IsChineseIdNum(id string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -357,7 +357,7 @@ func IsChinesePhone(phone string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -385,7 +385,7 @@ func IsCreditCard(creditCart string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -413,7 +413,7 @@ func IsDns(dns string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -444,7 +444,7 @@ func IsEmail(email string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -473,7 +473,7 @@ func IsEmptyString(s string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -501,7 +501,7 @@ func IsFloatStr(s string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -530,7 +530,7 @@ func IsNumberStr(s string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -559,7 +559,7 @@ func IsJSON(str string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -588,7 +588,7 @@ func IsRegexMatch(s, regex string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -614,7 +614,7 @@ func IsIntStr(s string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -641,7 +641,7 @@ func IsIp(ipstr string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -668,7 +668,7 @@ func IsIpV4(ipstr string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -695,7 +695,7 @@ func IsIpV6(ipstr string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -722,7 +722,7 @@ func IsStrongPassword(password string, length int) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -750,7 +750,7 @@ func IsUrl(str string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -778,7 +778,7 @@ func IsWeakPassword(password string, length int) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
--- a/docs/validator_zh-CN.md
+++ b/docs/validator_zh-CN.md
@@ -5,7 +5,7 @@ validator验证器包，包含常用字符串格式验证函数。

 ## 源码:

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


 <div STYLE="page-break-after: always;"></div>
@@ -13,7 +13,7 @@ validator验证器包，包含常用字符串格式验证函数。
 ## 用法:
 ```go
 import (
-    "github.com/duke-git/lancet/validator"
+    "github.com/duke-git/lancet/v2/validator"
 )
 ```

@@ -67,7 +67,7 @@ func ContainChinese(s string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -97,7 +97,7 @@ func ContainLetter(str string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -128,7 +128,7 @@ func ContainLower(str string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -159,7 +159,7 @@ func ContainUpper(str string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -190,7 +190,7 @@ func IsAlpha(s string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -218,7 +218,7 @@ func IsAllUpper(str string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -246,7 +246,7 @@ func IsAllLower(str string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -274,7 +274,7 @@ func IsBase64(base64 string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -302,7 +302,7 @@ func IsChineseMobile(mobileNum string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -329,7 +329,7 @@ func IsChineseIdNum(id string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -357,7 +357,7 @@ func IsChinesePhone(phone string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -385,7 +385,7 @@ func IsCreditCard(creditCart string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -413,7 +413,7 @@ func IsDns(dns string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -444,7 +444,7 @@ func IsEmail(email string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -473,7 +473,7 @@ func IsEmptyString(s string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -501,7 +501,7 @@ func IsFloatStr(s string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -530,7 +530,7 @@ func IsNumberStr(s string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -559,7 +559,7 @@ func IsJSON(str string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -588,7 +588,7 @@ func IsRegexMatch(s, regex string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -614,7 +614,7 @@ func IsIntStr(s string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -641,7 +641,7 @@ func IsIp(ipstr string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -668,7 +668,7 @@ func IsIpV4(ipstr string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -695,7 +695,7 @@ func IsIpV6(ipstr string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -722,7 +722,7 @@ func IsStrongPassword(password string, length int) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -750,7 +750,7 @@ func IsUrl(str string) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
@@ -778,7 +778,7 @@ func IsWeakPassword(password string, length int) bool
 ```go
 import (
 	"fmt"
-	"github.com/duke-git/lancet/validator"
+	"github.com/duke-git/lancet/v2/validator"
 )

 func main() {
--- a/docs/xerror.md
+++ b/docs/xerror.md
@@ -0,0 +1,57 @@
+# Xerror
+Package xerror implements helpers for errors.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source:
+
+- [https://github.com/duke-git/lancet/blob/main/xerror/xerror.go](https://github.com/duke-git/lancet/blob/main/xerror/xerror.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage:
+```go
+import (
+    "github.com/duke-git/lancet/v2/xerror"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+- [Unwrap](#Unwrap)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+
+
+### <span id="Unwrap">Unwrap</span>
+<p>Unwrap if err is nil then it returns a valid value. If err is not nil, Unwrap panics with err.</p>
+
+<b>Signature:</b>
+
+```go
+func Unwrap[T any](val T, err error) T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/xerror"
+)
+
+func main() {
+    _, err := strconv.Atoi("4o2")
+	defer func() {
+		v := recover()
+		fmt.Println(err.Error()) // err.Error() == v.(*strconv.NumError).Error()
+	}()
+
+	xerror.Unwrap(strconv.Atoi("4o2"))
+}
+```
--- a/docs/xerror_zh-CN.md
+++ b/docs/xerror_zh-CN.md
@@ -0,0 +1,57 @@
+# Xerror
+xerror错误处理逻辑封装
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+- [https://github.com/duke-git/lancet/blob/main/xerror/xerror.go](https://github.com/duke-git/lancet/blob/main/xerror/xerror.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+```go
+import (
+    "github.com/duke-git/lancet/v2/xerror"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+- [Unwrap](#Unwrap)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+
+
+### <span id="Unwrap">Unwrap</span>
+<p>如果err为nil则展开，则它返回一个有效值。 如果err不是nil则Unwrap使用err发生恐慌。</p>
+
+<b>函数签名:</b>
+
+```go
+func Unwrap[T any](val T, err error) T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/xerror"
+)
+
+func main() {
+    _, err := strconv.Atoi("4o2")
+	defer func() {
+		v := recover()
+		fmt.Println(err.Error()) // err.Error() == v.(*strconv.NumError).Error()
+	}()
+
+	xerror.Unwrap(strconv.Atoi("4o2"))
+}
+```
--- a/fileutil/file.go
+++ b/fileutil/file.go
@@ -13,6 +13,7 @@ import (
 	"io/ioutil"
 	"net/http"
 	"os"
+	"path"
 	"path/filepath"
 	"strings"
 )
@@ -40,6 +41,11 @@ func CreateFile(path string) bool {
 	return true
 }

+// CreateDir create directory in absolute path. param `absPath` like /a/, /a/b/
+func CreateDir(absPath string) error {
+	return os.MkdirAll(path.Dir(absPath), os.ModePerm)
+}
+
 // IsDir checks if the path is directory or not
 func IsDir(path string) bool {
 	file, err := os.Stat(path)
@@ -263,7 +269,7 @@ func FileMode(path string) (fs.FileMode, error) {

 // MiMeType return file mime type
 // param `file` should be string(file path) or *os.File
-func MiMeType(file interface{}) string {
+func MiMeType(file any) string {
 	var mediatype string

 	readBuffer := func(f *os.File) ([]byte, error) {
--- a/fileutil/file_test.go
+++ b/fileutil/file_test.go
@@ -4,7 +4,7 @@ import (
 	"os"
 	"testing"

-	"github.com/duke-git/lancet/internal"
+	"github.com/duke-git/lancet/v2/internal"
 )

 func TestIsExist(t *testing.T) {
@@ -33,6 +33,27 @@ func TestCreateFile(t *testing.T) {
 	os.Remove(f)
 }

+func TestCreateDir(t *testing.T) {
+	assert := internal.NewAssert(t, "TestCreateDir")
+
+	pwd, err := os.Getwd()
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	dirPath := pwd + "/a/"
+	err = CreateDir(dirPath)
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	assert.Equal(true, IsExist(dirPath))
+	os.Remove(dirPath)
+	assert.Equal(false, IsExist(dirPath))
+}
+
 func TestIsDir(t *testing.T) {
 	assert := internal.NewAssert(t, "TestIsDir")

@@ -76,10 +97,10 @@ func TestCopyFile(t *testing.T) {
 func TestListFileNames(t *testing.T) {
 	assert := internal.NewAssert(t, "TestListFileNames")

-	filesInPath, err := ListFileNames("../datetime/")
+	filesInPath, err := ListFileNames("./")
 	assert.IsNil(err)

-	expected := []string{"datetime.go", "datetime_test.go"}
+	expected := []string{"file.go", "file_test.go"}
 	assert.Equal(expected, filesInPath)
 }

--- a/formatter/formatter.go
+++ b/formatter/formatter.go
@@ -7,7 +7,7 @@ package formatter
 import "strings"

 // Comma add comma to number by every 3 numbers from right. ahead by symbol char
-func Comma(v interface{}, symbol string) string {
+func Comma(v any, symbol string) string {
 	s := numString(v)
 	dotIndex := strings.Index(s, ".")
 	if dotIndex != -1 {
--- a/formatter/formatter_internal.go
+++ b/formatter/formatter_internal.go
@@ -14,7 +14,7 @@ func commaString(s string) string {
 	return commaString(s[:len(s)-3]) + "," + commaString(s[len(s)-3:])
 }

-func numString(value interface{}) string {
+func numString(value any) string {
 	switch reflect.TypeOf(value).Kind() {
 	case reflect.Int, reflect.Int64, reflect.Float32, reflect.Float64:
 		return fmt.Sprintf("%v", value)
--- a/formatter/formatter_test.go
+++ b/formatter/formatter_test.go
@@ -3,7 +3,7 @@ package formatter
 import (
 	"testing"

-	"github.com/duke-git/lancet/internal"
+	"github.com/duke-git/lancet/v2/internal"
 )

 func TestComma(t *testing.T) {
--- a/function/function.go
+++ b/function/function.go
@@ -10,11 +10,11 @@ import (
 )

 // After creates a function that invokes func once it's called n or more times
-func After(n int, fn interface{}) func(args ...interface{}) []reflect.Value {
+func After(n int, fn any) func(args ...any) []reflect.Value {
 	// Catch programming error while constructing the closure
 	mustBeFunction(fn)
-	
-	return func(args ...interface{}) []reflect.Value {
+
+	return func(args ...any) []reflect.Value {
 		n--
 		if n < 1 {
 			return unsafeInvokeFunc(fn, args...)
@@ -24,11 +24,11 @@ func After(n int, fn interface{}) func(args ...interface{}) []reflect.Value {
 }

 // Before creates a function that invokes func once it's called less than n times
-func Before(n int, fn interface{}) func(args ...interface{}) []reflect.Value {
+func Before(n int, fn any) func(args ...any) []reflect.Value {
 	// Catch programming error while constructing the closure
 	mustBeFunction(fn)
 	var res []reflect.Value
-	return func(args ...interface{}) []reflect.Value {
+	return func(args ...any) []reflect.Value {
 		if n > 0 {
 			res = unsafeInvokeFunc(fn, args...)
 		}
@@ -40,20 +40,20 @@ func Before(n int, fn interface{}) func(args ...interface{}) []reflect.Value {
 	}
 }

-// Fn is for curry function which is func(...interface{}) interface{}
-type Fn func(...interface{}) interface{}
+// Fn is for curry function which is func(...any) any
+type Fn func(...any) any

 // Curry make a curry function
-func (f Fn) Curry(i interface{}) func(...interface{}) interface{} {
-	return func(values ...interface{}) interface{} {
-		v := append([]interface{}{i}, values...)
+func (f Fn) Curry(i any) func(...any) any {
+	return func(values ...any) any {
+		v := append([]any{i}, values...)
 		return f(v...)
 	}
 }

 // Compose compose the functions from right to left
-func Compose(fnList ...func(...interface{}) interface{}) func(...interface{}) interface{} {
-	return func(s ...interface{}) interface{} {
+func Compose(fnList ...func(...any) any) func(...any) any {
+	return func(s ...any) any {
 		f := fnList[0]
 		restFn := fnList[1:]

@@ -66,7 +66,7 @@ func Compose(fnList ...func(...interface{}) interface{}) func(...interface{}) in
 }

 // Delay make the function execution after delayed time
-func Delay(delay time.Duration, fn interface{}, args ...interface{}) {
+func Delay(delay time.Duration, fn any, args ...any) {
 	// Catch programming error while constructing the closure
 	mustBeFunction(fn)

@@ -95,7 +95,7 @@ func Debounced(fn func(), duration time.Duration) func() {
 }

 // Schedule invoke function every duration time, util close the returned bool chan
-func Schedule(d time.Duration, fn interface{}, args ...interface{}) chan bool {
+func Schedule(d time.Duration, fn any, args ...any) chan bool {
 	// Catch programming error while constructing the closure
 	mustBeFunction(fn)

--- a/function/function_internal.go
+++ b/function/function_internal.go
@@ -5,7 +5,7 @@ import (
 	"reflect"
 )

-func invokeFunc(fn interface{}, args ...interface{}) []reflect.Value {
+func invokeFunc(fn any, args ...any) []reflect.Value {
 	fv := functionValue(fn)
 	params := make([]reflect.Value, len(args))
 	for i, item := range args {
@@ -14,7 +14,7 @@ func invokeFunc(fn interface{}, args ...interface{}) []reflect.Value {
 	return fv.Call(params)
 }

-func unsafeInvokeFunc(fn interface{}, args ...interface{}) []reflect.Value {
+func unsafeInvokeFunc(fn any, args ...any) []reflect.Value {
 	fv := reflect.ValueOf(fn)
 	params := make([]reflect.Value, len(args))
 	for i, item := range args {
@@ -23,7 +23,7 @@ func unsafeInvokeFunc(fn interface{}, args ...interface{}) []reflect.Value {
 	return fv.Call(params)
 }

-func functionValue(function interface{}) reflect.Value {
+func functionValue(function any) reflect.Value {
 	v := reflect.ValueOf(function)
 	if v.Kind() != reflect.Func {
 		panic(fmt.Sprintf("Invalid function type, value of type %T", function))
@@ -31,7 +31,7 @@ func functionValue(function interface{}) reflect.Value {
 	return v
 }

-func mustBeFunction(function interface{}) {
+func mustBeFunction(function any) {
 	v := reflect.ValueOf(function)
 	if v.Kind() != reflect.Func {
 		panic(fmt.Sprintf("Invalid function type, value of type %T", function))
--- a/Show More
+++ b/Show More