release v2.1.7

* feat:(slice add AppendIfAbsent function)

* feat:(slice add TernaryOperator function)

Co-authored-by: george.zheng <george.zheng@ambergroup.io>

.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

.gitignore

@@ -6,4 +6,5 @@ fileutil/*.txt
 fileutil/*.zip
 fileutil/*.link
 fileutil/unzip/*
+slice/testdata/*
 cryptor/*.pem

README.md

@@ -1,16 +1,15 @@
 <div align=center>
-<img src="./logo.png" width="200" height="200"/>
+<a href="https://uvdream.github.io/lancet-docs/en/"><img src="./logo.png" width="200" height="200"/></a>
 
 <br/>
 
-![Go version](https://img.shields.io/badge/go-%3E%3D1.16<recommend>-9cf)
-[![Release](https://img.shields.io/badge/release-1.2.6-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)
+![Go version](https://img.shields.io/badge/go-%3E%3Dv1.18-9cf)
+[![Release](https://img.shields.io/badge/release-2.1.7-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.2. </b>
+```go
+go get github.com/duke-git/lancet@v1.3.2 // below go1.18, install latest version of v1.x.x
 ```
 
 ## Usage
@@ -39,33 +45,87 @@ 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
 
-Here takes the string function ReverseStr (reverse order string) as an example, and the strutil package needs to be imported.
+Here takes the string function Reverse (reverse order string) as an example, and the strutil package needs to be imported.
 
 ```go
 package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/strutil"
+    "github.com/duke-git/lancet/v2/strutil"
 )
 
 func main() {
     s := "hello"
-    rs := strutil.ReverseStr(s)
+    rs := strutil.Reverse(s)
     fmt.Println(rs) //olleh
 }
 ```
 
 ## API Documentation
-### Convertor package contains some functions for data convertion.
+## [lancet API doc](https://uvdream.github.io/lancet-docs/) Thanks [@UvDream](https://github.com/UvDream) for contributing.
+### 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. Condition package contains some functions for conditional judgment. eg. And, Or, TernaryOperator...
+
+```go
+import "github.com/duke-git/lancet/v2/condition"
+```
+#### Function list:
+- [Bool](https://github.com/duke-git/lancet/blob/main/docs/condition.md#Bool)
+- [And](https://github.com/duke-git/lancet/blob/main/docs/condition.md#And)
+- [Or](https://github.com/duke-git/lancet/blob/main/docs/condition.md#Or)
+- [Xor](https://github.com/duke-git/lancet/blob/main/docs/condition.md#Xor)
+- [Nor](https://github.com/duke-git/lancet/blob/main/docs/condition.md#Nor)
+- [Nand](https://github.com/duke-git/lancet/blob/main/docs/condition.md#Nand)
+- [TernaryOperator](https://github.com/duke-git/lancet/blob/main/docs/condition.md#TernaryOperator)
+  
+### 4. 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)
@@ -73,15 +133,22 @@ import "github.com/duke-git/lancet/convertor"
 - [ToBool](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToBool)
 - [ToBytes](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToBytes)
 - [ToChar](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToChar)
+- [ToChannel](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToChannel)
+- [ToFloat](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToFloat)
 - [ToInt](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToInt)
 - [ToJson](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToJson)
+- [ToMap](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToMap)
+- [ToPointer](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToPointer)
 - [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)
+- [MapToSlice](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#MapToSlice)
+- [EncodeByte](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#EncodeByte)
+- [DecodeByte](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#DecodeByte)
   
-### Cryptor package is for data encryption and decryption.
+### 5. 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 +185,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.
+### 6. 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 +214,52 @@ 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)
+
+
+
+### 7. 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"
+import heap "github.com/duke-git/lancet/v2/datastructure/heap"
+import hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+```
+#### 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)
+- [Heap](https://github.com/duke-git/lancet/blob/main/docs/datastructure/heap.md)
+- [HashMap](https://github.com/duke-git/lancet/blob/main/docs/datastructure/hashmap.md)
+
+
+### 8. 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 +273,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.
+### 9. 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
+### 10. 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:
@@ -195,46 +297,77 @@ import "github.com/duke-git/lancet/function"
 - [Watcher](https://github.com/duke-git/lancet/blob/main/docs/function.md#Watcher)
 
 
-### Mathutil package implements some functions for math calculation.
+### 11. Maputil package includes some functions to manipulate map.
 
 ```go
-import "github.com/duke-git/lancet/mathutil"
+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)
+- [IsDisjoint](https://github.com/duke-git/lancet/blob/main/docs/maputil.md#IsDisjoint)
+
+
+### 12. 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)
 
 
-### Netutil package contains functions to get net information and send http request.
+### 13. Netutil package contains functions to get net information and send http request.
 
 ```go
-import "github.com/duke-git/lancet/netutil"
+import "github.com/duke-git/lancet/v2/netutil"
 ```
 
 #### Function list:
 - [ConvertMapToQueryString](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#ConvertMapToQueryString)
+- [EncodeUrl](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#EncodeUrl)
 - [GetInternalIp](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#GetInternalIp)
 - [GetIps](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#GetIps)
 - [GetMacAddrs](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#GetMacAddrs)
 - [GetPublicIpInfo](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#GetPublicIpInfo)
+- [GetRequestPublicIp](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#GetRequestPublicIp)
 - [IsPublicIP](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#IsPublicIP)
-- [HttpGet](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#HttpGet)
-- [HttpDelete](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#HttpDelete)
-- [HttpPost](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#HttpPost)
-- [HttpPut](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#HttpPut)
-- [HttpPatch](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#HttpPatch)
+- [IsInternalIP](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#IsInternalIP)
+- [HttpRequest](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#HttpRequest)
+- [HttpClient](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#HttpClient)
+- [SendRequest](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#SendRequest)
+- [DecodeResponse](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#DecodeResponse)
+- [StructToUrlValues](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#StructToUrlValues)
+
+- [HttpGet<sup>Deprecated</sup>](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#HttpGet)
+- [HttpDelete<sup>Deprecated</sup>](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#HttpDelete)
+- [HttpPost<sup>Deprecated</sup>](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#HttpPost)
+- [HttpPut<sup>Deprecated</sup>](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#HttpPut)
+- [HttpPatch<sup>Deprecated</sup>](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.
+### 14. 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:
@@ -243,10 +376,10 @@ import "github.com/duke-git/lancet/random"
 - [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.
+### 15. 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:
@@ -256,13 +389,14 @@ 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.
+### 16. 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:
+- [AppendIfAbsent](https://github.com/duke-git/lancet/blob/main/docs/slice.md#AppendIfAbsent)
 - [Contain](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Contain)
 - [ContainSubSlice](https://github.com/duke-git/lancet/blob/main/docs/slice.md#ContainSubSlice)
 - [Chunk](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Chunk)
@@ -271,35 +405,45 @@ 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)
 - [FindLast](https://github.com/duke-git/lancet/blob/main/docs/slice.md#FindLast)
-- [FlattenDeep](#FlattenDeep)
+- [Flatten](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Flatten)
+- [FlattenDeep](https://github.com/duke-git/lancet/blob/main/docs/slice.md#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)
+- [ToSlice](https://github.com/duke-git/lancet/blob/main/docs/slice.md#ToSlice)
+- [ToSlicePointer](https://github.com/duke-git/lancet/blob/main/docs/slice.md#ToSlicePointer)
 - [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.
-
+### 17. 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:
@@ -316,17 +460,17 @@ import "github.com/duke-git/lancet/strutil"
 - [UpperFirst](https://github.com/duke-git/lancet/blob/main/docs/strutil.md#UpperFirst)
 - [PadEnd](https://github.com/duke-git/lancet/blob/main/docs/strutil.md#PadEnd)
 - [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)
+- [Reverse](https://github.com/duke-git/lancet/blob/main/docs/strutil.md#Reverse)
 - [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.
+### 19. 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)
@@ -336,12 +480,14 @@ import "github.com/duke-git/lancet/system"
 - [RemoveOsEnv](https://github.com/duke-git/lancet/blob/main/docs/system.md#RemoveOsEnv)
 - [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)
+- [GetOsBits](https://github.com/duke-git/lancet/blob/main/docs/system.md#GetOsBits)
 
-### Validator package contains some functions for data validation.
+### 19. 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)
@@ -370,6 +516,14 @@ import "github.com/duke-git/lancet/validator"
 - [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)
+- [IsZeroValue](https://github.com/duke-git/lancet/blob/main/docs/validator.md#IsZeroValue)
+### 20. 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
@@ -380,4 +534,4 @@ I really appreciate any code commits which make lancet lib powerful. Please foll
 2. Create your feature branch.
 3. Commit your changes.
 4. Push to the branch
-5. Create new pull request.
+5. Create new pull request.

README_zh-CN.md

@@ -1,16 +1,15 @@
 <div align=center>
-<img src="./logo.png" width="200" height="200"/>
+<a href="https://uvdream.github.io/lancet-docs/"><img src="./logo.png" width="200" height="200"/><a/>
 
 <br/>
 
-![Go version](https://img.shields.io/badge/go-%3E%3D1.16<recommend>-9cf)
-[![Release](https://img.shields.io/badge/release-1.2.6-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)
+![Go version](https://img.shields.io/badge/go-%3E%3Dv1.18-9cf)
+[![Release](https://img.shields.io/badge/release-2.1.7-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.2。</b>
+```go
+go get github.com/duke-git/lancet@v1.3.2 // 使用go1.18以下版本, 必须安装v1.x.x版本
 ```
 
 ## 用法
@@ -39,33 +45,86 @@ 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"
 ```
 
 ## 例子
 
-此处以字符串工具函数ReverseStr（逆序字符串）为例，需要导入strutil包:
+此处以字符串工具函数Reverse（逆序字符串）为例，需要导入strutil包:
 
 ```go
 package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/strutil"
+    "github.com/duke-git/lancet/v2/strutil"
 )
 
 func main() {
     s := "hello"
-    rs := strutil.ReverseStr(s)
+    rs := strutil.Reverse(s)
     fmt.Println(rs) //olleh
 }
 ```
 
 ## API文档
-### convertor转换器包支持一些常见的数据类型转换。
+## [lancet API doc](https://uvdream.github.io/lancet-docs/) 感谢[@UvDream](https://github.com/UvDream)整理
+### 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. concurrency并发包包含一些支持并发编程的功能。例如：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. condition条件包含一些用于条件判断的函数。eg. And, Or, TernaryOperator...
+
+```go
+import "github.com/duke-git/lancet/v2/condition"
+```
+#### Function list:
+- [Bool](https://github.com/duke-git/lancet/blob/main/docs/condition_zh-CN.md#Bool)
+- [And](https://github.com/duke-git/lancet/blob/main/docs/condition_zh-CN.md#And)
+- [Or](https://github.com/duke-git/lancet/blob/main/docs/condition_zh-CN.md#Or)
+- [Xor](https://github.com/duke-git/lancet/blob/main/docs/condition_zh-CN.md#Xor)
+- [Nor](https://github.com/duke-git/lancet/blob/main/docs/condition_zh-CN.md#Nor)
+- [Nand](https://github.com/duke-git/lancet/blob/main/docs/condition_zh-CN.md#Nand)
+- [TernaryOperator](https://github.com/duke-git/lancet/blob/main/docs/condition_zh-CN.md#TernaryOperator)
+  
+### 4. 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)
@@ -73,15 +132,22 @@ import "github.com/duke-git/lancet/convertor"
 - [ToBool](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToBool)
 - [ToBytes](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToBytes)
 - [ToChar](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToChar)
+- [ToChannel](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToChannel)
+- [ToFloat](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToFloat)
 - [ToInt](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToInt)
 - [ToJson](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToJson)
+- [ToMap](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToMap)
+- [ToPointer](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToPointer)
 - [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)
+- [MapToSlice](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#MapToSlice)
+- [EncodeByte](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#EncodeByte)
+- [DecodeByte](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#DecodeByte)
   
-### cryptor加密包支持数据加密和解密，获取md5，hash值。支持base64, md5, hmac, aes, des, rsa。
+### 5. cryptor加密包支持数据加密和解密，获取md5，hash值。支持base64, md5, hmac, aes, des, rsa。
 
 ```go
-import "github.com/duke-git/lancet/cryptor"
+import "github.com/duke-git/lancet/v2/cryptor"
 ```
 
 #### 函数列表:
@@ -118,11 +184,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日期时间处理包，格式化日期，比较日期。
+### 6. 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 +213,51 @@ 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)
+
+
+### 7. 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"
+import heap "github.com/duke-git/lancet/v2/datastructure/heap"
+import hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+```
+#### 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)
+- [Heap](https://github.com/duke-git/lancet/blob/main/docs/datastructure/heap.md)
+- [HashMap](https://github.com/duke-git/lancet/blob/main/docs/datastructure/hashmap.md)
+
+
+### 8. 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 +271,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格式化器包含一些数据格式化处理方法。
+### 9. 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函数包控制函数执行流程，包含部分函数式编程。
+### 10. function函数包控制函数执行流程，包含部分函数式编程。
 
 ```go
-import "github.com/duke-git/lancet/function"
+import "github.com/duke-git/lancet/v2/function"
 ```
 
 #### 函数列表:
@@ -195,45 +295,76 @@ import "github.com/duke-git/lancet/function"
 - [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)
 
-### mathutil包实现了一些数学计算的函数。
+
+### 11. maputil包包括一些操作map的函数.
 
 ```go
-import "github.com/duke-git/lancet/mathutil"
+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)
+- [IsDisjoint](https://github.com/duke-git/lancet/blob/main/docs/maputil_zh-CN.md#IsDisjoint)
+
+### 12. 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)
 
-### netutil网络包支持获取ip地址，发送http请求。
+### 13. netutil网络包支持获取ip地址，发送http请求。
 
 ```go
-import "github.com/duke-git/lancet/netutil"
+import "github.com/duke-git/lancet/v2/netutil"
 ```
 
 #### 函数列表:
 - [ConvertMapToQueryString](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#ConvertMapToQueryString)
 - [GetInternalIp](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#GetInternalIp)
+- [EncodeUrl](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#EncodeUrl)
 - [GetIps](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#GetIps)
 - [GetMacAddrs](https://github.com/duke-git/lancet/blob/main/docs/netutil.md#GetMacAddrs)
 - [GetPublicIpInfo](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#GetPublicIpInfo)
+- [GetRequestPublicIp](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#GetRequestPublicIp)
 - [IsPublicIP](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#IsPublicIP)
-- [HttpGet](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#HttpGet)
-- [HttpDelete](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#HttpDelete)
-- [HttpPost](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#HttpPost)
-- [HttpPut](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#HttpPut)
-- [HttpPatch](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#HttpPatch)
+- [IsInternalIP](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#IsInternalIP)
+- [HttpRequest](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#HttpRequest)
+- [HttpClient](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#HttpClient)
+- [SendRequest](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#SendRequest)
+- [DecodeResponse](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#DecodeResponse)
+- [StructToUrlValues](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#StructToUrlValues)
+
+- [HttpGet<sup>Deprecated</sup>](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#HttpGet)
+- [HttpDelete<sup>Deprecated</sup>](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#HttpDelete)
+- [HttpPost<sup>Deprecated</sup>](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#HttpPost)
+- [HttpPut<sup>Deprecated</sup>](https://github.com/duke-git/lancet/blob/main/docs/netutil_zh-CN.md#HttpPut)
+- [HttpPatch<sup>Deprecated</sup>](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。
+### 14. random随机数生成器包，可以生成随机[]bytes, int, string。
 
 ```go
-import "github.com/duke-git/lancet/random"
+import "github.com/duke-git/lancet/v2/random"
 ```
 
 #### 函数列表:
@@ -241,10 +372,10 @@ import "github.com/duke-git/lancet/random"
 - [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)
 - [UUIdV4](https://github.com/duke-git/lancet/blob/main/docs/random.md#UUIdV4)
-### retry重试执行函数直到函数运行成功或被context cancel。
+### 15. retry重试执行函数直到函数运行成功或被context cancel。
 
 ```go
-import "github.com/duke-git/lancet/retry"
+import "github.com/duke-git/lancet/v2/retry"
 ```
 
 #### 函数列表:
@@ -255,13 +386,14 @@ import "github.com/duke-git/lancet/retry"
 - [RetryTimes](https://github.com/duke-git/lancet/blob/main/docs/retry_zh-CN.md#RetryTimes)
 
 
-### slice包包含操作切片的方法集合。
+### 16. slice包包含操作切片的方法集合。
 
 ```go
-import "github.com/duke-git/lancet/slice"
+import "github.com/duke-git/lancet/v2/slice"
 ```
 
 #### 函数列表:
+- [AppendIfAbsent](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#AppendIfAbsent)
 - [Contain](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Contain)
 - [ContainSubSlice](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#ContainSubSlice)
 - [Chunk](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Chunk)
@@ -270,36 +402,45 @@ 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)
 - [Find](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Find)
 - [FindLast](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#FindLast)
-- [FlattenDeep](#FlattenDeep)
+- [Flatten](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Flatten)
+- [FlattenDeep](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#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)
+- [ToSlice](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#ToSlice)
+- [ToSlicePointer](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#ToSlicePointer)
 - [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包含处理字符串的相关函数。
+### 17. strutil包含处理字符串的相关函数。
 
 ```go
-import "github.com/duke-git/lancet/strutil"
+import "github.com/duke-git/lancet/v2/strutil"
 ```
 
 #### 函数列表:
@@ -316,16 +457,17 @@ import "github.com/duke-git/lancet/strutil"
 - [UpperFirst](https://github.com/duke-git/lancet/blob/main/docs/strutil_zh-CN.md#UpperFirst)
 - [PadEnd](https://github.com/duke-git/lancet/blob/main/docs/strutil_zh-CN.md#PadEnd)
 - [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)
+- [Reverse](https://github.com/duke-git/lancet/blob/main/docs/strutil_zh-CN.md#Reverse)
 - [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相关函数。
+### 18. system包含os, runtime, shell command相关函数。
 
 ```go
-import "github.com/duke-git/lancet/system"
+import "github.com/duke-git/lancet/v2/system"
 ```
 
 #### 函数列表:
@@ -337,11 +479,12 @@ import "github.com/duke-git/lancet/system"
 - [RemoveOsEnv](https://github.com/duke-git/lancet/blob/main/docs/system_zh-CN.md#RemoveOsEnv)
 - [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)
+- [GetOsBits](https://github.com/duke-git/lancet/blob/main/docs/system_zh-CN.md#GetOsBits)
 
-### validator验证器包，包含常用字符串格式验证函数。
+### 19. validator验证器包，包含常用字符串格式验证函数。
 
 ```go
-import "github.com/duke-git/lancet/validator"
+import "github.com/duke-git/lancet/v2/validator"
 ```
 #### 函数列表:
 
@@ -371,7 +514,15 @@ import "github.com/duke-git/lancet/validator"
 - [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)
+- [IsZeroValue](https://github.com/duke-git/lancet/blob/main/docs/validator_zh-CN.md#IsZeroValue)
 
+### 20. 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)
 
 ## 如何贡献代码
 
@@ -381,4 +532,4 @@ import "github.com/duke-git/lancet/validator"
 2. 创建自己的特性分支。
 3. 提交变更。
 4. Push分支。
-5. 创建新的pull request。
+5. 创建新的pull request。

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

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

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

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

algorithm/sort.go

@@ -0,0 +1,192 @@
+// 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, comparator lancetconstraints.Comparator) {
+	quickSort(slice, 0, len(slice)-1, comparator)
+}
+
+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]
+}

algorithm/sort_test.go

@@ -0,0 +1,208 @@
+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
+}
+
+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
+}
+
+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, 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)
+}

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

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

condition/condition.go

@@ -0,0 +1,77 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package condition contains some functions for conditional judgment. eg. And, Or, TernaryOperator ...
+// The implementation of this package refers to the implementation of carlmjohnson's truthy package, you may find more
+// useful information in truthy(https://github.com/carlmjohnson/truthy), thanks carlmjohnson.
+package condition
+
+import "reflect"
+
+// Bool returns the truthy value of anything.
+// If the value's type has a Bool() bool method, the method is called and returned.
+// If the type has an IsZero() bool method, the opposite value is returned.
+// Slices and maps are truthy if they have a length greater than zero.
+// All other types are truthy if they are not their zero value.
+func Bool[T any](value T) bool {
+	switch m := any(value).(type) {
+	case interface{ Bool() bool }:
+		return m.Bool()
+	case interface{ IsZero() bool }:
+		return !m.IsZero()
+	}
+	return reflectValue(&value)
+}
+
+func reflectValue(vp any) bool {
+	switch rv := reflect.ValueOf(vp).Elem(); rv.Kind() {
+	case reflect.Map, reflect.Slice:
+		return rv.Len() != 0
+	default:
+		is := rv.IsZero()
+		return !is
+	}
+}
+
+// And returns true if both a and b are truthy.
+func And[T, U any](a T, b U) bool {
+	return Bool(a) && Bool(b)
+}
+
+// Or returns false iff neither a nor b is truthy.
+func Or[T, U any](a T, b U) bool {
+	return Bool(a) || Bool(b)
+}
+
+// Xor returns true iff a or b but not both is truthy.
+func Xor[T, U any](a T, b U) bool {
+	valA := Bool(a)
+	valB := Bool(b)
+	return (valA || valB) && valA != valB
+}
+
+// Nor returns true iff neither a nor b is truthy.
+func Nor[T, U any](a T, b U) bool {
+	return !(Bool(a) || Bool(b))
+}
+
+// Xnor returns true iff both a and b or neither a nor b are truthy.
+func Xnor[T, U any](a T, b U) bool {
+	valA := Bool(a)
+	valB := Bool(b)
+	return (valA && valB) || (!valA && !valB)
+}
+
+// Nand returns false iff both a and b are truthy.
+func Nand[T, U any](a T, b U) bool {
+	return !Bool(a) || !Bool(b)
+}
+
+// TernaryOperator checks the value of param `isTrue`, if true return ifValue else return elseValue
+func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U {
+	if Bool(isTrue) {
+		return ifValue
+	} else {
+		return elseValue
+	}
+}

condition/condition_test.go

@@ -0,0 +1,119 @@
+package condition
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+type TestStruct struct{}
+
+func TestBool(t *testing.T) {
+	assert := internal.NewAssert(t, "TestBool")
+
+	// bool
+	assert.Equal(false, Bool(false))
+	assert.Equal(true, Bool(true))
+
+	// integer
+	assert.Equal(false, Bool(0))
+	assert.Equal(true, Bool(1))
+
+	// float
+	assert.Equal(false, Bool(0.0))
+	assert.Equal(true, Bool(0.1))
+
+	// string
+	assert.Equal(false, Bool(""))
+	assert.Equal(true, Bool(" "))
+	assert.Equal(true, Bool("0"))
+
+	// slice
+	var nums [2]int
+	assert.Equal(false, Bool(nums))
+	nums = [2]int{0, 1}
+	assert.Equal(true, Bool(nums))
+
+	// map
+	assert.Equal(false, Bool(map[string]string{}))
+	assert.Equal(true, Bool(map[string]string{"a": "a"}))
+
+	// channel
+	var ch chan int
+	assert.Equal(false, Bool(ch))
+	ch = make(chan int)
+	assert.Equal(true, Bool(ch))
+
+	//  interface
+	var err error
+	assert.Equal(false, Bool(err))
+	err = errors.New("error message")
+	assert.Equal(true, Bool(err))
+
+	// struct
+	assert.Equal(false, Bool(struct{}{}))
+	assert.Equal(true, Bool(time.Now()))
+
+	// struct pointer
+	ts := TestStruct{}
+	assert.Equal(false, Bool(ts))
+	assert.Equal(true, Bool(&ts))
+}
+
+func TestAnd(t *testing.T) {
+	assert := internal.NewAssert(t, "TestAnd")
+	assert.Equal(false, And(0, 1))
+	assert.Equal(false, And(0, ""))
+	assert.Equal(false, And(0, "0"))
+	assert.Equal(true, And(1, "0"))
+}
+
+func TestOr(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOr")
+	assert.Equal(false, Or(0, ""))
+	assert.Equal(true, Or(0, 1))
+	assert.Equal(true, Or(0, "0"))
+	assert.Equal(true, Or(1, "0"))
+}
+
+func TestXor(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOr")
+	assert.Equal(false, Xor(0, 0))
+	assert.Equal(true, Xor(0, 1))
+	assert.Equal(true, Xor(1, 0))
+	assert.Equal(false, Xor(1, 1))
+}
+
+func TestNor(t *testing.T) {
+	assert := internal.NewAssert(t, "TestNor")
+	assert.Equal(true, Nor(0, 0))
+	assert.Equal(false, Nor(0, 1))
+	assert.Equal(false, Nor(1, 0))
+	assert.Equal(false, Nor(1, 1))
+}
+
+func TestXnor(t *testing.T) {
+	assert := internal.NewAssert(t, "TestXnor")
+	assert.Equal(true, Xnor(0, 0))
+	assert.Equal(false, Xnor(0, 1))
+	assert.Equal(false, Xnor(1, 0))
+	assert.Equal(true, Xnor(1, 1))
+}
+
+func TestNand(t *testing.T) {
+	assert := internal.NewAssert(t, "TestNand")
+	assert.Equal(true, Nand(0, 0))
+	assert.Equal(true, Nand(0, 1))
+	assert.Equal(true, Nand(1, 0))
+	assert.Equal(false, Nand(1, 1))
+}
+
+func TestTernaryOperator(t *testing.T) {
+	assert := internal.NewAssert(t, "TernaryOperator")
+	trueValue := "1"
+	falseValue := "0"
+
+	assert.Equal(trueValue, TernaryOperator(true, trueValue, falseValue))
+}

convertor/convertor.go

@@ -6,9 +6,11 @@ package convertor
 
 import (
 	"bytes"
+	"encoding/binary"
 	"encoding/gob"
 	"encoding/json"
 	"fmt"
+	"math"
 	"reflect"
 	"regexp"
 	"strconv"
@@ -21,14 +23,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
@@ -43,105 +75,135 @@ func ToChar(s string) []string {
 	return c
 }
 
+// ToChannel convert a array of elements to a read-only channels
+func ToChannel[T any](array []T) <-chan T {
+	ch := make(chan T)
+
+	go func() {
+		for _, item := range array {
+			ch <- item
+		}
+		close(ch)
+	}()
+
+	return ch
+}
+
 // ToString convert value to string
-func ToString(value interface{}) string {
-	res := ""
+func ToString(value any) string {
+	result := ""
 	if value == nil {
-		return res
+		return result
 	}
 
 	v := reflect.ValueOf(value)
 
 	switch value.(type) {
 	case float32, float64:
-		res = strconv.FormatFloat(v.Float(), 'f', -1, 64)
-		return res
+		result = strconv.FormatFloat(v.Float(), 'f', -1, 64)
+		return result
 	case int, int8, int16, int32, int64:
-		res = strconv.FormatInt(v.Int(), 10)
-		return res
+		result = strconv.FormatInt(v.Int(), 10)
+		return result
 	case uint, uint8, uint16, uint32, uint64:
-		res = strconv.FormatUint(v.Uint(), 10)
-		return res
+		result = strconv.FormatUint(v.Uint(), 10)
+		return result
 	case string:
-		res = v.String()
-		return res
+		result = v.String()
+		return result
 	case []byte:
-		res = string(v.Bytes())
-		return res
+		result = string(v.Bytes())
+		return result
 	default:
 		newValue, _ := json.Marshal(value)
-		res = string(newValue)
-		return res
+		result = string(newValue)
+		return result
 	}
 }
 
 // ToJson convert value to a valid json string
-func ToJson(value interface{}) (string, error) {
-	res, err := json.Marshal(value)
+func ToJson(value any) (string, error) {
+	result, err := json.Marshal(value)
 	if err != nil {
 		return "", err
 	}
 
-	return string(res), nil
+	return string(result), nil
 }
 
 // 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
+	result := 0.0
 	err := fmt.Errorf("ToInt: unvalid interface type %T", value)
 	switch value.(type) {
 	case int, int8, int16, int32, int64:
-		res = float64(v.Int())
-		return res, nil
+		result = float64(v.Int())
+		return result, nil
 	case uint, uint8, uint16, uint32, uint64:
-		res = float64(v.Uint())
-		return res, nil
+		result = float64(v.Uint())
+		return result, nil
 	case float32, float64:
-		res = v.Float()
-		return res, nil
+		result = v.Float()
+		return result, nil
 	case string:
-		res, err = strconv.ParseFloat(v.String(), 64)
+		result, err = strconv.ParseFloat(v.String(), 64)
 		if err != nil {
-			res = 0.0
+			result = 0.0
 		}
-		return res, err
+		return result, err
 	default:
-		return res, err
+		return result, err
 	}
 }
 
 // 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
+	var result int64
 	err := fmt.Errorf("ToInt: invalid interface type %T", value)
 	switch value.(type) {
 	case int, int8, int16, int32, int64:
-		res = v.Int()
-		return res, nil
+		result = v.Int()
+		return result, nil
 	case uint, uint8, uint16, uint32, uint64:
-		res = int64(v.Uint())
-		return res, nil
+		result = int64(v.Uint())
+		return result, nil
 	case float32, float64:
-		res = int64(v.Float())
-		return res, nil
+		result = int64(v.Float())
+		return result, nil
 	case string:
-		res, err = strconv.ParseInt(v.String(), 0, 64)
+		result, err = strconv.ParseInt(v.String(), 0, 64)
 		if err != nil {
-			res = 0
+			result = 0
 		}
-		return res, err
+		return result, err
 	default:
-		return res, err
+		return result, err
 	}
 }
 
+// ToPointer returns a pointer to this value
+func ToPointer[T any](value T) *T {
+	return &value
+}
+
+// ToMap convert a slice or an array of structs to a map based on iteratee function
+func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K]V {
+	result := make(map[K]V, len(array))
+	for _, item := range array {
+		k, v := iteratee(item)
+		result[k] = v
+	}
+
+	return result
+}
+
 // 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 +214,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{})
+	result := make(map[string]any)
 
 	fieldNum := t.NumField()
 	pattern := `^[A-Z]`
@@ -161,12 +223,23 @@ func StructToMap(value interface{}) (map[string]interface{}, error) {
 		name := t.Field(i).Name
 		tag := t.Field(i).Tag.Get("json")
 		if regex.MatchString(name) && tag != "" {
-			//res[name] = v.Field(i).Interface()
-			res[tag] = v.Field(i).Interface()
+			//result[name] = v.Field(i).Interface()
+			result[tag] = v.Field(i).Interface()
 		}
 	}
 
-	return res, nil
+	return result, nil
+}
+
+// MapToSlice convert a map to a slice based on iteratee function
+func MapToSlice[T any, K comparable, V any](aMap map[K]V, iteratee func(K, V) T) []T {
+	result := make([]T, 0, len(aMap))
+
+	for k, v := range aMap {
+		result = append(result, iteratee(k, v))
+	}
+
+	return result
 }
 
 // ColorHexToRGB convert hex color to rgb color
@@ -198,3 +271,21 @@ func ColorRGBToHex(red, green, blue int) string {
 
 	return "#" + r + g + b
 }
+
+// EncodeByte encode data to byte
+func EncodeByte(data any) ([]byte, error) {
+	buffer := bytes.NewBuffer(nil)
+	encoder := gob.NewEncoder(buffer)
+	err := encoder.Encode(data)
+	if err != nil {
+		return nil, err
+	}
+	return buffer.Bytes(), nil
+}
+
+// DecodeByte decode byte data to target object
+func DecodeByte(data []byte, target any) error {
+	buffer := bytes.NewBuffer(data)
+	decoder := gob.NewDecoder(buffer)
+	return decoder.Decode(target)
+}

convertor/convertor_test.go

@@ -2,9 +2,11 @@ package convertor
 
 import (
 	"fmt"
+	"strconv"
 	"testing"
 
-	"github.com/duke-git/lancet/internal"
+	"github.com/duke-git/lancet/v2/internal"
+	"github.com/duke-git/lancet/v2/slice"
 )
 
 func TestToChar(t *testing.T) {
@@ -21,6 +23,23 @@ func TestToChar(t *testing.T) {
 	}
 }
 
+func TestToChannel(t *testing.T) {
+	assert := internal.NewAssert(t, "TestToChannel")
+
+	ch := ToChannel([]int{1, 2, 3})
+	val1, _ := <-ch
+	assert.Equal(1, val1)
+
+	val2, _ := <-ch
+	assert.Equal(2, val2)
+
+	val3, _ := <-ch
+	assert.Equal(3, val3)
+
+	_, ok := <-ch
+	assert.Equal(false, ok)
+}
+
 func TestToBool(t *testing.T) {
 	assert := internal.NewAssert(t, "TestToBool")
 
@@ -36,26 +55,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 +97,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 +125,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),
@@ -135,6 +161,25 @@ func TestToJson(t *testing.T) {
 	assert.Equal("{\"Name\":\"TestStruct\"}", structJsonStr)
 }
 
+func TestToMap(t *testing.T) {
+	assert := internal.NewAssert(t, "TestToMap")
+
+	type Message struct {
+		name string
+		code int
+	}
+	messages := []Message{
+		{name: "Hello", code: 100},
+		{name: "Hi", code: 101},
+	}
+	result := ToMap(messages, func(msg Message) (int, string) {
+		return msg.code, msg.name
+	})
+	expected := map[int]string{100: "Hello", 101: "Hi"}
+
+	assert.Equal(expected, result)
+}
+
 func TestStructToMap(t *testing.T) {
 	assert := internal.NewAssert(t, "TestStructToMap")
 
@@ -147,10 +192,25 @@ func TestStructToMap(t *testing.T) {
 		100,
 	}
 	pm, _ := StructToMap(p)
-	var expected = map[string]interface{}{"name": "test"}
+
+	expected := map[string]any{"name": "test"}
 	assert.Equal(expected, pm)
 }
 
+func TestMapToSlice(t *testing.T) {
+	assert := internal.NewAssert(t, "TestMapToSlice")
+
+	aMap := map[string]int{"a": 1, "b": 2, "c": 3}
+	result := MapToSlice(aMap, func(key string, value int) string {
+		return key + ":" + strconv.Itoa(value)
+	})
+
+	assert.Equal(3, len(result))
+	assert.Equal(true, slice.Contain(result, "a:1"))
+	assert.Equal(true, slice.Contain(result, "b:2"))
+	assert.Equal(true, slice.Contain(result, "c:3"))
+}
+
 func TestColorHexToRGB(t *testing.T) {
 	colorHex := "#003366"
 	r, g, b := ColorHexToRGB(colorHex)
@@ -171,3 +231,28 @@ func TestColorRGBToHex(t *testing.T) {
 	assert := internal.NewAssert(t, "TestColorRGBToHex")
 	assert.Equal(expected, colorHex)
 }
+
+func TestToPointer(t *testing.T) {
+	assert := internal.NewAssert(t, "TestToPointer")
+	result := ToPointer(123)
+
+	assert.Equal(*result, 123)
+}
+
+func TestEncodeByte(t *testing.T) {
+	assert := internal.NewAssert(t, "TestEncodeByte")
+
+	byteData, _ := EncodeByte("abc")
+	expected := []byte{6, 12, 0, 3, 97, 98, 99}
+
+	assert.Equal(expected, byteData)
+}
+
+func TestDecodeByte(t *testing.T) {
+	assert := internal.NewAssert(t, "TestDecodeByte")
+
+	var obj string
+	byteData := []byte{6, 12, 0, 3, 97, 98, 99}
+	DecodeByte(byteData, &obj)
+	assert.Equal("abc", obj)
+}

cryptor/aes.go

@@ -38,7 +38,7 @@ func AesEcbEncrypt(data, key []byte) []byte {
 func AesEcbDecrypt(encrypted, key []byte) []byte {
 	cipher, _ := aes.NewCipher(generateAesKey(key))
 	decrypted := make([]byte, len(encrypted))
-	//
+
 	for bs, be := 0, cipher.BlockSize(); bs < len(encrypted); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
 		cipher.Decrypt(decrypted[bs:be], encrypted[bs:be])
 	}
@@ -54,14 +54,18 @@ func AesEcbDecrypt(encrypted, key []byte) []byte {
 // AesCbcEncrypt encrypt data with key use AES CBC algorithm
 // len(key) should be 16, 24 or 32
 func AesCbcEncrypt(data, key []byte) []byte {
-	// len(key) should be 16, 24 or 32
 	block, _ := aes.NewCipher(key)
-	blockSize := block.BlockSize()
-	data = pkcs7Padding(data, blockSize)
-	blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])
+	data = pkcs7Padding(data, block.BlockSize())
+
+	encrypted := make([]byte, aes.BlockSize+len(data))
+	iv := encrypted[:aes.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic(err)
+	}
+
+	mode := cipher.NewCBCEncrypter(block, iv)
+	mode.CryptBlocks(encrypted[aes.BlockSize:], data)
 
-	encrypted := make([]byte, len(data))
-	blockMode.CryptBlocks(encrypted, data)
 	return encrypted
 }
 
@@ -69,12 +73,14 @@ func AesCbcEncrypt(data, key []byte) []byte {
 // len(key) should be 16, 24 or 32
 func AesCbcDecrypt(encrypted, key []byte) []byte {
 	block, _ := aes.NewCipher(key)
-	blockSize := block.BlockSize()
-	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])
 
-	decrypted := make([]byte, len(encrypted))
-	blockMode.CryptBlocks(decrypted, encrypted)
-	decrypted = pkcs7UnPadding(decrypted)
+	iv := encrypted[:aes.BlockSize]
+	encrypted = encrypted[aes.BlockSize:]
+
+	mode := cipher.NewCBCDecrypter(block, iv)
+	mode.CryptBlocks(encrypted, encrypted)
+
+	decrypted := pkcs7UnPadding(encrypted)
 	return decrypted
 }
 

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

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

cryptor/des.go

@@ -55,12 +55,16 @@ func DesEcbDecrypt(encrypted, key []byte) []byte {
 // len(key) should be 8
 func DesCbcEncrypt(data, key []byte) []byte {
 	block, _ := des.NewCipher(key)
-	blockSize := block.BlockSize()
-	data = pkcs7Padding(data, blockSize)
-	blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])
+	data = pkcs7Padding(data, block.BlockSize())
 
-	encrypted := make([]byte, len(data))
-	blockMode.CryptBlocks(encrypted, data)
+	encrypted := make([]byte, des.BlockSize+len(data))
+	iv := encrypted[:des.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic(err)
+	}
+
+	mode := cipher.NewCBCEncrypter(block, iv)
+	mode.CryptBlocks(encrypted[des.BlockSize:], data)
 
 	return encrypted
 }
@@ -69,13 +73,14 @@ func DesCbcEncrypt(data, key []byte) []byte {
 // len(key) should be 8
 func DesCbcDecrypt(encrypted, key []byte) []byte {
 	block, _ := des.NewCipher(key)
-	blockSize := block.BlockSize()
-	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])
 
-	decrypted := make([]byte, len(encrypted))
-	blockMode.CryptBlocks(decrypted, encrypted)
-	decrypted = pkcs7UnPadding(decrypted)
+	iv := encrypted[:des.BlockSize]
+	encrypted = encrypted[des.BlockSize:]
 
+	mode := cipher.NewCBCDecrypter(block, iv)
+	mode.CryptBlocks(encrypted, encrypted)
+
+	decrypted := pkcs7UnPadding(encrypted)
 	return decrypted
 }
 

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

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

datastructure/hashmap/hashmap.go

@@ -0,0 +1,175 @@
+// 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 (
+	"fmt"
+	"hash/fnv"
+)
+
+var defaultMapCapacity uint64 = 1 << 10
+
+type mapNode struct {
+	key   any
+	value any
+	next  *mapNode
+}
+
+//HashMap implements a hash map
+type HashMap struct {
+	capacity uint64
+	size     uint64
+	table    []*mapNode
+}
+
+// NewHashMap return a HashMap instance
+func NewHashMap() *HashMap {
+	return &HashMap{
+		capacity: defaultMapCapacity,
+		table:    make([]*mapNode, defaultMapCapacity),
+	}
+}
+
+// NewHashMapWithCapacity return a HashMap instance with given size and capacity
+func NewHashMapWithCapacity(size, capacity uint64) *HashMap {
+	return &HashMap{
+		size:     size,
+		capacity: capacity,
+		table:    make([]*mapNode, capacity),
+	}
+}
+
+// Get return the value of given key in hashmap
+func (hm *HashMap) Get(key any) any {
+	hashValue := hm.hash(key)
+	node := hm.table[hashValue]
+	if node != nil {
+		return node.value
+	}
+
+	return nil
+}
+
+// Put new key value in hashmap
+func (hm *HashMap) Put(key any, value any) {
+	hm.putValue(hm.hash(key), key, value)
+}
+
+func (hm *HashMap) putValue(hash uint64, key, value any) {
+	if hm.capacity == 0 {
+		hm.capacity = defaultMapCapacity
+		hm.table = make([]*mapNode, defaultMapCapacity)
+	}
+
+	node := hm.table[hash]
+	if node == nil {
+		hm.table[hash] = newMapNode(key, value)
+	} else if node.key == key {
+		hm.table[hash] = newMapNodeWithNext(key, value, node)
+	} else {
+		hm.resize()
+		hm.putValue(hash, value, value)
+	}
+	hm.size++
+}
+
+// Delete item by given key in hashmap
+func (hm *HashMap) Delete(key any) {
+	hash := hm.hash(key)
+	node := hm.table[hash]
+	if node == nil {
+		return
+	}
+
+	hm.table = append(hm.table[:hash], hm.table[hash+1:]...)
+	hm.size--
+}
+
+// Contains checks if given key is in hashmap or not
+func (hm *HashMap) Contains(key any) bool {
+	node := hm.table[hm.hash(key)]
+	return node != nil
+}
+
+// Iterate executes iteratee funcation for every key and value pair of hashmap (random order)
+func (hm *HashMap) Iterate(iteratee func(key, value any)) {
+	if hm.size > 0 {
+		for i := 0; i < len(hm.table); i++ {
+			item := hm.table[i]
+			if item != nil {
+				iteratee(item.key, item.value)
+			}
+		}
+	}
+}
+
+// Keys returns a slice of the hashmap's keys (random order)
+func (hm *HashMap) Keys() []any {
+	keys := make([]any, int(hm.size))
+	index := 0
+	if hm.size > 0 {
+		hm.Iterate(func(key, value any) {
+			keys[index] = key
+			index++
+		})
+	}
+
+	return keys
+}
+
+// Values returns a slice of the hashmap's keys (random order)
+func (hm *HashMap) Values() []any {
+	values := make([]any, int(hm.size))
+	index := 0
+	if hm.size > 0 {
+		hm.Iterate(func(key, value any) {
+			values[index] = value
+			index++
+		})
+	}
+
+	return values
+}
+
+func (hm *HashMap) resize() {
+	hm.capacity <<= 1
+
+	tempTable := hm.table
+
+	hm.table = make([]*mapNode, hm.capacity)
+
+	for i := 0; i < len(tempTable); i++ {
+		node := tempTable[i]
+		if node == nil {
+			continue
+		}
+
+		hm.table[hm.hash(node.key)] = node
+	}
+}
+
+func (hm *HashMap) hash(key any) uint64 {
+	h := fnv.New64a()
+	_, _ = h.Write([]byte(fmt.Sprintf("%v", key)))
+
+	hashValue := h.Sum64()
+
+	return (hm.capacity - 1) & (hashValue ^ (hashValue >> 16))
+}
+
+func newMapNode(key, value any) *mapNode {
+	return &mapNode{
+		key:   key,
+		value: value,
+	}
+}
+
+func newMapNodeWithNext(key, value any, next *mapNode) *mapNode {
+	return &mapNode{
+		key:   key,
+		value: value,
+		next:  next,
+	}
+}

datastructure/hashmap/hashmap_test.go

@@ -0,0 +1,71 @@
+package datastructure
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestHashMap_PutAndGet(t *testing.T) {
+	assert := internal.NewAssert(t, "TestHashMap_PutAndGet")
+
+	hm := NewHashMap()
+
+	hm.Put("abc", 3)
+	assert.Equal(3, hm.Get("abc"))
+	assert.IsNil(hm.Get("abcd"))
+
+	hm.Put("abc", 4)
+	assert.Equal(4, hm.Get("abc"))
+}
+
+func TestHashMap_Resize(t *testing.T) {
+	assert := internal.NewAssert(t, "TestHashMap_Resize")
+
+	hm := NewHashMapWithCapacity(3, 3)
+
+	for i := 0; i < 20; i++ {
+		hm.Put(i, 10)
+	}
+
+	assert.Equal(10, hm.Get(5))
+}
+
+func TestHashMap_Delete(t *testing.T) {
+	assert := internal.NewAssert(t, "TestHashMap_Delete")
+
+	hm := NewHashMap()
+
+	hm.Put("abc", 3)
+	assert.Equal(3, hm.Get("abc"))
+
+	hm.Delete("abc")
+	assert.IsNil(hm.Get("abc"))
+}
+
+func TestHashMap_Contains(t *testing.T) {
+	assert := internal.NewAssert(t, "TestHashMap_Contains")
+
+	hm := NewHashMap()
+	assert.Equal(false, hm.Contains("abc"))
+
+	hm.Put("abc", 3)
+	assert.Equal(true, hm.Contains("abc"))
+}
+
+func TestHashMap_KeysValues(t *testing.T) {
+	assert := internal.NewAssert(t, "TestHashMap_KeysValues")
+
+	hm := NewHashMap()
+
+	hm.Put("a", 1)
+	hm.Put("b", 2)
+	hm.Put("c", 3)
+
+	keys := hm.Keys()
+	values := hm.Values()
+	t.Log(keys, values)
+
+	assert.Equal(3, len(values))
+	assert.Equal(3, len(keys))
+}

datastructure/heap/maxheap.go

@@ -0,0 +1,203 @@
+// 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 (
+	"fmt"
+
+	"github.com/duke-git/lancet/v2/lancetconstraints"
+)
+
+// MaxHeap implements a binary max heap
+// type T should implements Compare function in lancetconstraints.Comparator interface.
+type MaxHeap[T any] struct {
+	data       []T
+	comparator lancetconstraints.Comparator
+}
+
+// NewMaxHeap returns a MaxHeap instance with the given comparator.
+func NewMaxHeap[T any](comparator lancetconstraints.Comparator) *MaxHeap[T] {
+	return &MaxHeap[T]{
+		data:       make([]T, 0),
+		comparator: comparator,
+	}
+}
+
+// BuildMaxHeap builds a MaxHeap instance with data and given comparator.
+func BuildMaxHeap[T any](data []T, comparator lancetconstraints.Comparator) *MaxHeap[T] {
+	heap := &MaxHeap[T]{
+		data:       make([]T, 0, len(data)),
+		comparator: comparator,
+	}
+
+	for _, v := range data {
+		heap.Push(v)
+	}
+
+	return heap
+}
+
+// Push value into the heap
+func (h *MaxHeap[T]) Push(value T) {
+	h.data = append(h.data, value)
+	h.heapifyUp(len(h.data) - 1)
+}
+
+// heapifyUp heapify the data from bottom to top
+func (h *MaxHeap[T]) heapifyUp(i int) {
+	for h.comparator.Compare(h.data[parentIndex(i)], h.data[i]) < 0 {
+		h.swap(parentIndex(i), i)
+		i = parentIndex(i)
+	}
+}
+
+// Pop return the largest value, and remove it from the heap
+// if heap is empty, return zero value and fasle
+func (h *MaxHeap[T]) Pop() (T, bool) {
+	var val T
+	if h.Size() == 0 {
+		return val, false
+	}
+
+	val = h.data[0]
+	l := len(h.data) - 1
+
+	h.data[0] = h.data[l]
+	h.data = h.data[:l]
+	h.heapifyDown(0)
+
+	return val, true
+}
+
+// heapifyDown heapify the data from top to bottom
+func (h *MaxHeap[T]) heapifyDown(i int) {
+	lastIndex := len(h.data) - 1
+	l, r := leftChildIndex(i), rightChildIndex(i)
+	childToCompare := 0
+
+	for l <= lastIndex {
+		if l == lastIndex {
+			childToCompare = l
+		} else if h.comparator.Compare(h.data[l], h.data[r]) > 0 {
+			childToCompare = l
+		} else {
+			childToCompare = r
+		}
+
+		if h.comparator.Compare(h.data[i], h.data[childToCompare]) < 0 {
+			h.swap(i, childToCompare)
+			i = childToCompare
+			l, r = leftChildIndex(i), rightChildIndex(i)
+		} else {
+			break
+		}
+	}
+}
+
+// Peek returns the largest element from the heap without removing it.
+// if heap is empty, it returns zero value and false.
+func (h *MaxHeap[T]) Peek() (T, bool) {
+	if h.Size() == 0 {
+		var val T
+		return val, false
+	}
+
+	return h.data[0], true
+}
+
+// Size return the number of elements in the heap
+func (h *MaxHeap[T]) Size() int {
+	return len(h.data)
+}
+
+// Data return data of the heap
+func (h *MaxHeap[T]) Data() []T {
+	return h.data
+}
+
+// PrintStructure print the structure of the heap
+func (h *MaxHeap[T]) PrintStructure() {
+	level := 1
+	data := h.data
+	length := len(h.data)
+	index := 0
+
+	list := [][]string{}
+	temp := []string{}
+	for index < length {
+		start := powerTwo(level-1) - 1
+		end := start + powerTwo(level-1) - 1
+
+		temp = append(temp, fmt.Sprintf("%v", data[index]))
+		index++
+
+		if index > end || index >= length {
+			list = append(list, temp)
+			temp = []string{}
+
+			if index < length {
+				level++
+			}
+		}
+	}
+
+	lastNum := powerTwo(level - 1)
+	lastLen := lastNum + (lastNum - 1)
+
+	heapTree := make([][]string, level, level)
+	for i := 0; i < level; i++ {
+		heapTree[i] = make([]string, lastLen, lastLen)
+		for j := 0; j < lastLen; j++ {
+			heapTree[i][j] = ""
+		}
+	}
+
+	for k := 0; k < len(list); k++ {
+		vals := list[k]
+		tempLevel := level - k
+		st := powerTwo(tempLevel-1) - 1
+		for _, v := range vals {
+			heapTree[k][st] = v
+			gap := powerTwo(tempLevel)
+			st = st + gap
+		}
+	}
+
+	for m := 0; m < level; m++ {
+		for n := 0; n < lastLen; n++ {
+			val := heapTree[m][n]
+			if val == "" {
+				fmt.Printf(" ")
+			} else {
+				fmt.Printf(val)
+			}
+		}
+		fmt.Println()
+	}
+}
+
+// parentIndex get parent index of the given index
+func parentIndex(i int) int {
+	return (i - 1) / 2
+}
+
+// leftChildIndex get left child index of the given index
+func leftChildIndex(i int) int {
+	return 2*i + 1
+}
+
+// rightChildIndex get right child index of the given index
+func rightChildIndex(i int) int {
+	return 2*i + 2
+}
+
+// swap two elements in the heap
+func (h *MaxHeap[T]) swap(i, j int) {
+	h.data[i], h.data[j] = h.data[j], h.data[i]
+}
+
+func powerTwo(n int) int {
+	return 1 << n
+}

datastructure/heap/maxheap_test.go

@@ -0,0 +1,92 @@
+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 TestMaxHeap_BuildMaxHeap(t *testing.T) {
+	assert := internal.NewAssert(t, "TestMaxHeap_BuildMaxHeap")
+
+	values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+	heap := BuildMaxHeap(values, &intComparator{})
+
+	expected := []int{12, 9, 11, 4, 8, 10, 7, 1, 3, 5, 6, 2}
+	assert.Equal(expected, heap.data)
+
+	assert.Equal(12, heap.Size())
+
+	heap.PrintStructure()
+}
+
+func TestMaxHeap_Push(t *testing.T) {
+	assert := internal.NewAssert(t, "TestMaxHeap_Push")
+
+	heap := NewMaxHeap[int](&intComparator{})
+	values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+
+	for _, v := range values {
+		heap.Push(v)
+	}
+
+	expected := []int{12, 9, 11, 4, 8, 10, 7, 1, 3, 5, 6, 2}
+	assert.Equal(expected, heap.data)
+
+	assert.Equal(12, heap.Size())
+
+	heap.PrintStructure()
+}
+
+func TestMaxHeap_Pop(t *testing.T) {
+	assert := internal.NewAssert(t, "TestMaxHeap_Pop")
+
+	heap := NewMaxHeap[int](&intComparator{})
+
+	_, ok := heap.Pop()
+	assert.Equal(false, ok)
+
+	values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+	for _, v := range values {
+		heap.Push(v)
+	}
+
+	val, ok := heap.Pop()
+	assert.Equal(12, val)
+	assert.Equal(true, ok)
+	assert.Equal(11, heap.Size())
+}
+
+func TestMaxHeap_Peek(t *testing.T) {
+	assert := internal.NewAssert(t, "TestMaxHeap_Peek")
+
+	heap := NewMaxHeap[int](&intComparator{})
+
+	_, ok := heap.Peek()
+	assert.Equal(false, ok)
+
+	values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+	for _, v := range values {
+		heap.Push(v)
+	}
+
+	val, ok := heap.Peek()
+	assert.Equal(12, val)
+	assert.Equal(true, ok)
+
+	assert.Equal(12, heap.Size())
+}

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 {
+	result := []T{}
+	current := link.Head
+	for current != nil {
+		result = append(result, current.Value)
+		current = current.Next
+	}
+	return result
+}
+
+// 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
+}

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())
+}

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 {
+	result := []T{}
+	current := link.Head
+	for current != nil {
+		result = append(result, current.Value)
+		current = current.Next
+	}
+	return result
+}
+
+// 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)
+}

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())
+}

datastructure/list/list.go

@@ -0,0 +1,325 @@
+// 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 returns 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
+}
+
+// LastIndexOf returns the index of the last occurrence of the value in this list.
+// if not found return -1
+func (l *List[T]) LastIndexOf(value T) int {
+	index := -1
+	data := l.data
+	for i := len(data) - 1; i >= 0; i-- {
+		if reflect.DeepEqual(data[i], value) {
+			index = i
+			break
+		}
+	}
+	return index
+}
+
+// IndexOfFunc returns the first index satisfying f(v)
+// if not found return -1
+func (l *List[T]) IndexOfFunc(f func(T) bool) int {
+	index := -1
+	data := l.data
+	for i, v := range data {
+		if f(v) {
+			index = i
+			break
+		}
+	}
+	return index
+}
+
+// LastIndexOfFunc returns the index of the last occurrence of the value in this list satisfying f(data[i])
+// if not found return -1
+func (l *List[T]) LastIndexOfFunc(f func(T) bool) int {
+	index := -1
+	data := l.data
+	for i := len(data) - 1; i >= 0; i-- {
+		if f(data[i]) {
+			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
+}
+
+// DeleteIf delete all satisfying f(data[i]), returns count of removed elements
+func (l *List[T]) DeleteIf(f func(T) bool) int {
+	data := l.data
+	size := len(data)
+
+	var c int
+	for index := 0; index < len(data); index++ {
+		if !f(data[index]) {
+			continue
+		}
+		if index == size-1 {
+			data = append(data[:index])
+		} else {
+			data = append(data[:index], data[index+1:]...)
+			index--
+		}
+		c++
+	}
+
+	if c > 0 {
+		l.data = data
+	}
+	return c
+}
+
+// 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)
+}
+
+// Cap return cap of the inner data
+func (l *List[T]) Cap() int {
+	return cap(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] {
+	result := NewList([]T{})
+
+	result.data = append(result.data, l.data...)
+	result.data = append(result.data, other.data...)
+	result.Unique()
+
+	return result
+}
+
+// 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] {
+	result := NewList(make([]T, 0, 0))
+
+	for _, v := range l.data {
+		if other.Contain(v) {
+			result.data = append(result.data, v)
+		}
+	}
+
+	return result
+}
+
+// SubList returns a sub list of the original list between the specified fromIndex, inclusive, and toIndex, exclusive.
+func (l *List[T]) SubList(fromIndex, toIndex int) *List[T] {
+	data := l.data[fromIndex:toIndex]
+	subList := make([]T, len(data))
+	copy(subList, data)
+	return NewList(subList)
+}

datastructure/list/list_test.go

@@ -0,0 +1,359 @@
+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 TestIndexOfFunc(t *testing.T) {
+	assert := internal.NewAssert(t, "TestIndexOf")
+
+	list := NewList([]int{1, 2, 3})
+	i := list.IndexOfFunc(func(a int) bool { return a == 1 })
+	assert.Equal(0, i)
+
+	i = list.IndexOfFunc(func(a int) bool { return a == 4 })
+	assert.Equal(-1, i)
+}
+
+func TestLastIndexOf(t *testing.T) {
+	assert := internal.NewAssert(t, "TestIndexOf")
+
+	list := NewList([]int{1, 2, 3, 3, 3, 3, 4, 5, 6, 9})
+	i := list.LastIndexOf(3)
+	assert.Equal(5, i)
+
+	i = list.LastIndexOf(10)
+	assert.Equal(-1, i)
+
+	i = list.LastIndexOf(4)
+	assert.Equal(6, i)
+
+	i = list.LastIndexOf(1)
+	assert.Equal(0, i)
+}
+
+func TestLastIndexOfFunc(t *testing.T) {
+	assert := internal.NewAssert(t, "TestIndexOf")
+
+	list := NewList([]int{1, 2, 3, 3, 3, 3, 4, 5, 6, 9})
+	i := list.LastIndexOfFunc(func(a int) bool { return a == 3 })
+	assert.Equal(5, i)
+
+	i = list.LastIndexOfFunc(func(a int) bool { return a == 10 })
+	assert.Equal(-1, i)
+
+	i = list.LastIndexOfFunc(func(a int) bool { return a == 4 })
+	assert.Equal(6, i)
+
+	i = list.LastIndexOfFunc(func(a int) bool { return a == 1 })
+	assert.Equal(0, 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 TestCap(t *testing.T) {
+	assert := internal.NewAssert(t, "TestCap")
+
+	data := make([]int, 0, 100)
+	list := NewList(data)
+	assert.Equal(100, list.Cap())
+
+	data = make([]int, 0)
+	list = NewList(data)
+	assert.Equal(0, list.Cap())
+}
+
+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))
+}
+
+func TestSubSlice(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSubSlice")
+
+	list := NewList([]int{1, 2, 3, 4, 5, 8})
+	subList := list.SubList(2, 5)
+
+	assert.Equal([]int{3, 4, 5}, subList.Data())
+}
+
+func BenchmarkSubSlice(b *testing.B) {
+	list := NewList([]int{1, 2, 3, 4, 5, 8})
+	for n := 0; n < b.N; n++ {
+		list.SubList(2, 5)
+	}
+}
+
+func TestDeleteIf(t *testing.T) {
+	assert := internal.NewAssert(t, "TestDeleteIf")
+
+	list := NewList([]int{1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1, 1, 1})
+
+	count := list.DeleteIf(func(a int) bool { return a == 1 })
+	assert.Equal([]int{2, 3, 4}, list.Data())
+	assert.Equal(12, count)
+
+	count = list.DeleteIf(func(a int) bool { return a == 5 })
+	assert.Equal([]int{2, 3, 4}, list.Data())
+	assert.Equal(0, count)
+}

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

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

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())
+}

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

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())
+
+}

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

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

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

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())
+}

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]struct{}
+
+// 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] = struct{}{}
+	}
+}
+
+// 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
+}

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

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

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())
+}

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

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())
+}

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 {
+	result := false
+
+	if superTreeRoot != nil && subTreeRoot != nil {
+		if comparator.Compare(superTreeRoot.Value, subTreeRoot.Value) == 0 {
+			result = isSubTree(superTreeRoot, subTreeRoot, comparator)
+		}
+		if !result {
+			result = hasSubTree(superTreeRoot.Left, subTreeRoot, comparator)
+		}
+		if !result {
+			result = hasSubTree(superTreeRoot.Right, subTreeRoot, comparator)
+		}
+	}
+	return result
+}
+
+// Print the bstree structure
+func (t *BSTree[T]) Print() {
+	maxLevel := t.NodeLevel(t.root)
+	nodes := []*datastructure.TreeNode[T]{t.root}
+	printTreeNodes(nodes, 1, maxLevel)
+}

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

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
+	}
+	result := isSubTree(superTreeRoot.Left, subTreeRoot.Left, comparator) && isSubTree(superTreeRoot.Right, subTreeRoot.Right, comparator)
+	return result
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return 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)
+}

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())
+}

datetime/datetime.go

@@ -4,24 +4,24 @@
 // Package datetime implements some functions to format date and time.
 // Note:
 // 1. `format` param in FormatTimeToStr function should be as flow:
-//"yyyy-mm-dd hh:mm:ss"
-//"yyyy-mm-dd hh:mm"
-//"yyyy-mm-dd hh"
-//"yyyy-mm-dd"
-//"yyyy-mm"
-//"mm-dd"
-//"dd-mm-yy hh:mm:ss"
-//"yyyy/mm/dd hh:mm:ss"
-//"yyyy/mm/dd hh:mm"
-//"yyyy/mm/dd hh"
-//"yyyy/mm/dd"
-//"yyyy/mm"
-//"mm/dd"
-//"dd/mm/yy hh:mm:ss"
-//"yyyy"
-//"mm"
-//"hh:mm:ss"
-//"mm:ss"
+// "yyyy-mm-dd hh:mm:ss"
+// "yyyy-mm-dd hh:mm"
+// "yyyy-mm-dd hh"
+// "yyyy-mm-dd"
+// "yyyy-mm"
+// "mm-dd"
+// "dd-mm-yy hh:mm:ss"
+// "yyyy/mm/dd hh:mm:ss"
+// "yyyy/mm/dd hh:mm"
+// "yyyy/mm/dd hh"
+// "yyyy/mm/dd"
+// "yyyy/mm"
+// "mm/dd"
+// "dd/mm/yy hh:mm:ss"
+// "yyyy"
+// "mm"
+// "hh:mm:ss"
+// "mm:ss"
 package datetime
 
 import (
@@ -147,16 +147,32 @@ func EndOfDay(t time.Time) time.Time {
 	return time.Date(y, m, d, 23, 59, 59, int(time.Second-time.Nanosecond), t.Location())
 }
 
-// BeginOfWeek return beginning week, week begin from Sunday
-func BeginOfWeek(t time.Time) time.Time {
-	y, m, d := t.AddDate(0, 0, 0-int(BeginOfDay(t).Weekday())).Date()
-	return time.Date(y, m, d, 0, 0, 0, 0, t.Location())
+// BeginOfWeek return beginning week, default week begin from Sunday
+func BeginOfWeek(t time.Time, beginFrom ...time.Weekday) time.Time {
+	var beginFromWeekday = time.Sunday
+	if len(beginFrom) > 0 {
+		beginFromWeekday = beginFrom[0]
+	}
+	y, m, d := t.AddDate(0, 0, int(beginFromWeekday-t.Weekday())).Date()
+	beginOfWeek := time.Date(y, m, d, 0, 0, 0, 0, t.Location())
+	if beginOfWeek.After(t) {
+		return beginOfWeek.AddDate(0, 0, -7)
+	}
+	return beginOfWeek
 }
 
-// EndOfWeek return end week time, week end with Saturday
-func EndOfWeek(t time.Time) time.Time {
-	y, m, d := BeginOfWeek(t).AddDate(0, 0, 7).Add(-time.Nanosecond).Date()
-	return time.Date(y, m, d, 23, 59, 59, int(time.Second-time.Nanosecond), t.Location())
+// EndOfWeek return end week time, default week end with Saturday
+func EndOfWeek(t time.Time, endWith ...time.Weekday) time.Time {
+	var endWithWeekday = time.Saturday
+	if len(endWith) > 0 {
+		endWithWeekday = endWith[0]
+	}
+	y, m, d := t.AddDate(0, 0, int(endWithWeekday-t.Weekday())).Date()
+	var endWithWeek = time.Date(y, m, d, 23, 59, 59, int(time.Second-time.Nanosecond), t.Location())
+	if endWithWeek.Before(t) {
+		endWithWeek = endWithWeek.AddDate(0, 0, 7)
+	}
+	return endWithWeek
 }
 
 // BeginOfMonth return beginning of month

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

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/sort.go](https://github.com/duke-git/lancet/blob/main/algorithm/sort.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 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, 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
+
+}
+```

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/sort.go](https://github.com/duke-git/lancet/blob/main/algorithm/sort.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, 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, 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
+
+}
+```

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

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

docs/condition.md

@@ -0,0 +1,264 @@
+# Condition
+Package condition contains some functions for conditional judgment. eg. And, Or, TernaryOperator... The implementation of this package refers to the implementation of carlmjohnson's truthy package, you may find more useful information in [truthy](https://github.com/carlmjohnson/truthy), thanks carlmjohnson.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source:
+
+- [https://github.com/duke-git/lancet/blob/main/condition/condition.go](https://github.com/duke-git/lancet/blob/main/condition/condition.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage:
+```go
+import (
+    "github.com/duke-git/lancet/v2/condition"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+
+- [Bool](#Bool)
+- [And](#And)
+- [Or](#Or)
+- [Xor](#Generate)
+- [Nor](#Nor)
+- [Nand](#Nand)
+- [TernaryOperator](#TernaryOperator)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+
+### <span id="Bool">Bool</span>
+<p>Returns the truthy value of anything.<br/>
+If the value's type has a Bool() bool method, the method is called and returned.<br/>
+If the type has an IsZero() bool method, the opposite value is returned.<br/>
+Slices and maps are truthy if they have a length greater than zero.<br/>
+All other types are truthy if they are not their zero value.</p>
+
+<b>Signature:</b>
+
+```go
+func Bool[T any](value T) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+	// bool
+	fmt.Println(condition.Bool(false)) // false
+	fmt.Println(condition.Bool(true)) // true
+
+	// integer
+	fmt.Println(condition.Bool(0)) // false
+	fmt.Println(condition.Bool(1)) // true
+
+	// float
+	fmt.Println(condition.Bool(0.0)) // false
+	fmt.Println(condition.Bool(0.1)) // true
+
+	// string
+	fmt.Println(condition.Bool("")) // false
+	fmt.Println(condition.Bool(" ")) // true
+	fmt.Println(condition.Bool("0")) // true
+
+	// slice
+	var nums [2]int
+	fmt.Println(condition.Bool(nums)) // false
+	nums = [2]int{0, 1}
+	fmt.Println(condition.Bool(nums)) // true
+
+	// map
+	fmt.Println(condition.Bool(map[string]string{})) // false
+	fmt.Println(condition.Bool(map[string]string{"a": "a"})) // true
+
+	// struct
+	fmt.Println(condition.Bool(struct{}{})) // false
+	fmt.Println(condition.Bool(time.Now())) // true
+}
+```
+
+
+
+### <span id="And">And</span>
+<p>Returns true if both a and b are truthy.</p>
+
+<b>Signature:</b>
+
+```go
+func And[T, U any](a T, b U) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+	fmt.Println(condition.And(0, 1)) // false
+	fmt.Println(condition.And(0, "")) // false
+	fmt.Println(condition.And(0, "0")) // false
+	fmt.Println(condition.And(1, "0")) // true
+}
+```
+
+
+
+### <span id="Or">Or</span>
+<p>Returns false iff neither a nor b is truthy.</p>
+
+<b>Signature:</b>
+
+```go
+func Or[T, U any](a T, b U) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+	fmt.Println(condition.Or(0, "")) // false
+	fmt.Println(condition.Or(0, 1)) // true
+	fmt.Println(condition.Or(0, "0")) // true
+	fmt.Println(condition.Or(1, "0")) // true
+}
+```
+
+
+
+### <span id="Xor">Xor</span>
+<p>Returns true iff a or b but not both is truthy.</p>
+
+<b>Signature:</b>
+
+```go
+func Xor[T, U any](a T, b U) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+	fmt.Println(condition.Xor(0, 0)) // false
+	fmt.Println(condition.Xor(0, 1)) // true
+	fmt.Println(condition.Xor(1, 0)) // true
+	fmt.Println(condition.Xor(1, 1)) // false
+}
+```
+
+
+
+### <span id="Nor">Nor</span>
+<p>Returns true iff neither a nor b is truthy.</p>
+
+<b>Signature:</b>
+
+```go
+func Nor[T, U any](a T, b U) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+	fmt.Println(condition.Nor(0, 0)) // true
+	fmt.Println(condition.Nor(0, 1)) // false
+	fmt.Println(condition.Nor(1, 0)) // false
+	fmt.Println(condition.Nor(1, 1)) // true
+}
+```
+
+
+
+### <span id="Nand">Nand</span>
+<p>Returns false iff both a and b are truthy</p>
+
+<b>Signature:</b>
+
+```go
+func Nand[T, U any](a T, b U) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+	fmt.Println(condition.Nand(0, 0)) // true
+	fmt.Println(condition.Nand(0, 1)) // true
+	fmt.Println(condition.Nand(1, 0)) // true
+	fmt.Println(condition.Nand(1, 1)) // false
+}
+```
+
+
+
+### <span id="TernaryOperator">TernaryOperator</span>
+<p>Checks the value of param `isTrue`, if true return ifValue else return elseValue</p>
+
+<b>Signature:</b>
+
+```go
+func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+	trueValue := "1"
+	falseValue := "0"
+
+	fmt.Println(condition.TernaryOperator(true, trueValue, falseValue)) // "1"
+}
+```
+
+
+
+
+
+

docs/condition_zh-CN.md

@@ -0,0 +1,263 @@
+# Condition
+condition包含一些用于条件判断的函数。这个包的实现参考了carlmjohnson的truthy包的实现，更多有用的信息可以在[truthy](https://github.com/carlmjohnson/truthy)中找到，感谢carlmjohnson。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+- [https://github.com/duke-git/lancet/blob/main/condition/condition.go](https://github.com/duke-git/lancet/blob/main/condition/condition.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+```go
+import (
+    "github.com/duke-git/lancet/v2/condition"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+
+- [Bool](#Bool)
+- [And](#And)
+- [Or](#Or)
+- [Xor](#Generate)
+- [Nor](#Nor)
+- [Nand](#Nand)
+- [TernaryOperator](#TernaryOperator)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+### <span id="Bool">Bool</span>
+<p>返回传入参数的bool值.<br/>
+如果出入类型参数含有Bool方法, 会调用该方法并返回<br/>
+如果传入类型参数有IsZero方法, 返回IsZero方法返回值的取反<br/>
+slices和map的length大于0时，返回true，否则返回false<br/>
+其他类型会判断是否是零值</p>
+
+<b>函数签名:</b>
+
+```go
+func Bool[T any](value T) bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+	// bool
+	fmt.Println(condition.Bool(false)) // false
+	fmt.Println(condition.Bool(true)) // true
+
+	// integer
+	fmt.Println(condition.Bool(0)) // false
+	fmt.Println(condition.Bool(1)) // true
+
+	// float
+	fmt.Println(condition.Bool(0.0)) // false
+	fmt.Println(condition.Bool(0.1)) // true
+
+	// string
+	fmt.Println(condition.Bool("")) // false
+	fmt.Println(condition.Bool(" ")) // true
+	fmt.Println(condition.Bool("0")) // true
+
+	// slice
+	var nums [2]int
+	fmt.Println(condition.Bool(nums)) // false
+	nums = [2]int{0, 1}
+	fmt.Println(condition.Bool(nums)) // true
+
+	// map
+	fmt.Println(condition.Bool(map[string]string{})) // false
+	fmt.Println(condition.Bool(map[string]string{"a": "a"})) // true
+
+	// struct
+	fmt.Println(condition.Bool(struct{}{})) // false
+	fmt.Println(condition.Bool(time.Now())) // true
+}
+```
+
+
+
+### <span id="And">And</span>
+<p>逻辑且操作，当切仅当a和b都为true时返回true</p>
+
+<b>函数签名:</b>
+
+```go
+func And[T, U any](a T, b U) bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+	fmt.Println(condition.And(0, 1)) // false
+	fmt.Println(condition.And(0, "")) // false
+	fmt.Println(condition.And(0, "0")) // false
+	fmt.Println(condition.And(1, "0")) // true
+}
+```
+
+
+
+### <span id="Or">Or</span>
+<p>逻辑或操作，当切仅当a和b都为false时返回false</p>
+
+<b>函数签名:</b>
+
+```go
+func Or[T, U any](a T, b U) bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+	fmt.Println(condition.Or(0, "")) // false
+	fmt.Println(condition.Or(0, 1)) // true
+	fmt.Println(condition.Or(0, "0")) // true
+	fmt.Println(condition.Or(1, "0")) // true
+}
+```
+
+
+
+### <span id="Xor">Xor</span>
+<p>逻辑异或操作，a和b相同返回false，a和b不相同返回true</p>
+
+<b>函数签名:</b>
+
+```go
+func Xor[T, U any](a T, b U) bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+	fmt.Println(condition.Xor(0, 0)) // false
+	fmt.Println(condition.Xor(0, 1)) // true
+	fmt.Println(condition.Xor(1, 0)) // true
+	fmt.Println(condition.Xor(1, 1)) // false
+}
+```
+
+
+
+### <span id="Nor">Nor</span>
+<p>异或的取反操作</p>
+
+<b>函数签名:</b>
+
+```go
+func Nor[T, U any](a T, b U) bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+	fmt.Println(condition.Nor(0, 0)) // true
+	fmt.Println(condition.Nor(0, 1)) // false
+	fmt.Println(condition.Nor(1, 0)) // false
+	fmt.Println(condition.Nor(1, 1)) // true
+}
+```
+
+
+
+### <span id="Nand">Nand</span>
+<p>如果a和b都为真，返回false，否则返回true</p>
+
+<b>函数签名:</b>
+
+```go
+func Nand[T, U any](a T, b U) bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+	fmt.Println(condition.Nand(0, 0)) // true
+	fmt.Println(condition.Nand(0, 1)) // true
+	fmt.Println(condition.Nand(1, 0)) // true
+	fmt.Println(condition.Nand(1, 1)) // false
+}
+```
+
+
+
+### <span id="TernaryOperator">TernaryOperator</span>
+<p>三元运算符</p>
+
+<b>函数签名:</b>
+
+```go
+func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/condition"
+)
+
+func main() {
+	trueValue := "1"
+	falseValue := "0"
+
+	fmt.Println(condition.TernaryOperator(true, trueValue, falseValue)) // "1"
+}
+```
+
+
+
+
+
+

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"
 )
 ```
 
@@ -24,10 +24,18 @@ import (
 - [ToBool](#ToBool)
 - [ToBytes](#ToBytes)
 - [ToChar](#ToChar)
+- [ToChannel](#ToChannel)
+
+- [ToFloat](#ToFloat)
 - [ToInt](#ToInt)
 - [ToJson](#ToJson)
+- [ToMap](#ToMap)
+- [ToPointer](#ToPointer)
 - [ToString](#ToString)
 - [StructToMap](#StructToMap)
+- [MapToSlice](#MapToSlice)
+- [EncodeByte](#EncodeByte)
+- [DecodeByte](#DecodeByte)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -50,12 +58,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 +86,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 +117,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 
 func main() {
@@ -136,7 +144,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func ToBytes(data interface{}) ([]byte, error)
+func ToBytes(data any) ([]byte, error)
 ```
 <b>Example:</b>
 
@@ -145,7 +153,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 
 func main() {
@@ -175,7 +183,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 
 func main() {
@@ -191,15 +199,14 @@ func main() {
 ```
 
 
+### <span id="ToChannel">ToChannel</span>
 
-### <span id="ToFloat">ToFloat</span>
-
-<p>Convert interface to a float64 value. If param is a invalid floatable, will return 0 and error. </p>
+<p>Convert a collection of elements to a read-only channels.</p>
 
 <b>Signature:</b>
 
 ```go
-func ToFloat(value interface{}) (float64, error)
+func ToChannel[T any](array []T) <-chan T
 ```
 <b>Example:</b>
 
@@ -208,7 +215,45 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    ch := convertor.ToChannel([]int{1, 2, 3})
+
+    val1, _ := <-ch
+    fmt.Println(val1) //1
+
+    val2, _ := <-ch
+    fmt.Println(val2) //2
+
+    val3, _ := <-ch
+    fmt.Println(val3) //3
+
+    _, ok := <-ch
+    fmt.Println(ok) //false
+}
+```
+
+
+
+### <span id="ToFloat">ToFloat</span>
+
+<p>Convert interface to a float64 value. If param is a invalid floatable, will return 0 and error. </p>
+
+<b>Signature:</b>
+
+```go
+func ToFloat(value any) (float64, error)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 
 func main() {
@@ -232,7 +277,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func ToInt(value interface{}) (int64, error)
+func ToInt(value any) (int64, error)
 ```
 <b>Example:</b>
 
@@ -241,7 +286,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 
 func main() {
@@ -265,7 +310,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func ToJson(value interface{}) (string, error)
+func ToJson(value any) (string, error)
 ```
 <b>Example:</b>
 
@@ -274,7 +319,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 
 func main() {
@@ -286,14 +331,14 @@ func main() {
 
 
 
-### <span id="ToString">ToString</span>
+### <span id="ToMap">ToMap</span>
 
-<p>Convert interface to string. </p>
+<p>Convert a slice or an array of structs to a map based on iteratee function. </p>
 
 <b>Signature:</b>
 
 ```go
-func ToString(value interface{}) string
+func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K]V
 ```
 <b>Example:</b>
 
@@ -302,13 +347,50 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 
 func main() {
-    fmt.Printf("%q", convertor.ToString(1)) //"1"
-    fmt.Printf("%q", convertor.ToString(1.1)) //"1.1"
-    fmt.Printf("%q", convertor.ToString([]int{1, 2, 3})) //"[1,2,3]"
+    type Message struct {
+        name string
+        code int
+    }
+    messages := []Message{
+        {name: "Hello", code: 100},
+        {name: "Hi", code: 101},
+    }
+    result := convertor.ToMap(messages, func(msg Message) (int, string) {
+        return msg.code, msg.name
+    })
+
+    fmt.Println(result) //{100: "Hello", 101: "Hi"}
+}
+```
+
+
+
+### <span id="ToPointer">ToPointer</span>
+
+<p>Returns a pointer to passed value. </p>
+
+<b>Signature:</b>
+
+```go
+func ToPointer[T any](value T) *T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    result := convertor.ToPointer(123)
+    fmt.Println(*result) //123
 }
 ```
 
@@ -321,7 +403,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 +412,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 
 func main() {
@@ -346,4 +428,90 @@ func main() {
 
     fmt.Printf("type: %T, value: %s", pm, pm) //type: map[string]interface {}, value: map[name:test]
 }
+```
+
+
+
+### <span id="MapToSlice">MapToSlice</span>
+
+<p>Convert a map to a slice based on iteratee function.</p>
+
+<b>Signature:</b>
+
+```go
+func MapToSlice[T any, K comparable, V any](aMap map[K]V, iteratee func(K, V) T) []T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    aMap := map[string]int{"a": 1, "b": 2, "c": 3}
+    result := MapToSlice(aMap, func(key string, value int) string {
+        return key + ":" + strconv.Itoa(value)
+    })
+
+    fmt.Println(result) //[]string{"a:1", "b:2", "c:3"}
+}
+```
+
+
+### <span id="EncodeByte">EncodeByte</span>
+
+<p>Encode data to byte slice.</p>
+
+<b>Signature:</b>
+
+```go
+func EncodeByte(data any) ([]byte, error)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    byteData, _ := convertor.EncodeByte("abc")
+    fmt.Println(byteData) //[]byte{6, 12, 0, 3, 97, 98, 99}
+}
+```
+
+
+
+### <span id="DecodeByte">DecodeByte</span>
+
+<p>Decode byte data to target object. target should be a pointer instance.</p>
+
+<b>Signature:</b>
+
+```go
+func DecodeByte(data []byte, target any) error
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    var result string
+	byteData := []byte{6, 12, 0, 3, 97, 98, 99}
+	convertor.DecodeByte(byteData, &result)
+    fmt.Println(result) //"abc"
+}
 ```

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"
 )
 ```
 
@@ -26,10 +26,18 @@ import (
 - [ToBool](#ToBool)
 - [ToBytes](#ToBytes)
 - [ToChar](#ToChar)
+- [ToChannel](#ToChannel)
+
+- [ToFloat](#ToFloat)
 - [ToInt](#ToInt)
 - [ToJson](#ToJson)
+- [ToMap](#ToMap)
+- [ToPointer](#ToPointer)
 - [ToString](#ToString)
 - [StructToMap](#StructToMap)
+- [MapToSlice](#MapToSlice)
+- [EncodeByte](#EncodeByte)
+- [DecodeByte](#DecodeByte)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -52,12 +60,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 +88,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 +119,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 
 func main() {
@@ -138,7 +146,7 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func ToBytes(data interface{}) ([]byte, error)
+func ToBytes(data any) ([]byte, error)
 ```
 <b>列子:</b>
 
@@ -147,7 +155,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 
 func main() {
@@ -177,7 +185,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 
 func main() {
@@ -194,6 +202,44 @@ func main() {
 
 
 
+### <span id="ToChannel">ToChannel</span>
+
+<p>将切片转为只读channel</p>
+
+<b>函数签名:</b>
+
+```go
+func ToChannel[T any](array []T) <-chan T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    ch := convertor.ToChannel([]int{1, 2, 3})
+
+    val1, _ := <-ch
+    fmt.Println(val1) //1
+
+    val2, _ := <-ch
+    fmt.Println(val2) //2
+
+    val3, _ := <-ch
+    fmt.Println(val3) //3
+
+    _, ok := <-ch
+    fmt.Println(ok) //false
+}
+```
+
+
+
 ### <span id="ToFloat">ToFloat</span>
 
 <p>将interface转成float64类型，如果参数无法转换，会返回0和error</p>
@@ -201,7 +247,7 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func ToFloat(value interface{}) (float64, error)
+func ToFloat(value any) (float64, error)
 ```
 <b>列子:</b>
 
@@ -210,7 +256,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 
 func main() {
@@ -229,12 +275,12 @@ func main() {
 
 ### <span id="ToInt">ToInt</span>
 
-<p>将interface转成intt64类型，如果参数无法转换，会返回0和error</p>
+<p>将interface转成int64类型，如果参数无法转换，会返回0和error</p>
 
 <b>函数签名:</b>
 
 ```go
-func ToInt(value interface{}) (int64, error)
+func ToInt(value any) (int64, error)
 ```
 <b>例子:</b>
 
@@ -243,7 +289,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 
 func main() {
@@ -267,7 +313,7 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func ToJson(value interface{}) (string, error)
+func ToJson(value any) (string, error)
 ```
 <b>列子:</b>
 
@@ -276,7 +322,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 
 func main() {
@@ -288,6 +334,71 @@ func main() {
 
 
 
+### <span id="ToMap">ToMap</span>
+
+<p>将切片转为map</p>
+
+<b>函数签名:</b>
+
+```go
+func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K]V
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    type Message struct {
+        name string
+        code int
+    }
+    messages := []Message{
+        {name: "Hello", code: 100},
+        {name: "Hi", code: 101},
+    }
+    result := convertor.ToMap(messages, func(msg Message) (int, string) {
+        return msg.code, msg.name
+    })
+
+    fmt.Println(result) //{100: "Hello", 101: "Hi"}
+}
+```
+
+
+
+### <span id="ToPointer">ToPointer</span>
+
+<p>返回传入值的指针</p>
+
+<b>函数签名:</b>
+
+```go
+func ToPointer[T any](value T) *T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    result := convertor.ToPointer(123)
+    fmt.Println(*result) //123
+}
+```
+
+
+
 ### <span id="ToString">ToString</span>
 
 <p>将interface转成字符串</p>
@@ -295,7 +406,7 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func ToString(value interface{}) string
+func ToString(value any) string
 ```
 <b>例子:</b>
 
@@ -304,7 +415,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 
 func main() {
@@ -323,7 +434,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 +443,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/convertor"
+    "github.com/duke-git/lancet/v2/convertor"
 )
 
 func main() {
@@ -348,4 +459,91 @@ func main() {
 
     fmt.Printf("type: %T, value: %s", pm, pm) //type: map[string]interface {}, value: map[name:test]
 }
+```
+
+
+
+### <span id="MapToSlice">MapToSlice</span>
+
+<p>map中key和value执行函数iteratee后，转为切片</p>
+
+<b>函数签名:</b>
+
+```go
+func MapToSlice[T any, K comparable, V any](aMap map[K]V, iteratee func(K, V) T) []T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    aMap := map[string]int{"a": 1, "b": 2, "c": 3}
+    result := MapToSlice(aMap, func(key string, value int) string {
+        return key + ":" + strconv.Itoa(value)
+    })
+
+    fmt.Println(result) //[]string{"a:1", "b:2", "c:3"}
+}
+```
+
+
+
+### <span id="EncodeByte">EncodeByte</span>
+
+<p>将data编码成字节切片</p>
+
+<b>函数签名:</b>
+
+```go
+func EncodeByte(data any) ([]byte, error)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    byteData, _ := convertor.EncodeByte("abc")
+    fmt.Println(byteData) //[]byte{6, 12, 0, 3, 97, 98, 99}
+}
+```
+
+
+
+### <span id="DecodeByte">DecodeByte</span>
+
+<p>解码字节切片到目标对象，目标对象需要传入一个指针实例子</p>
+
+<b>函数签名:</b>
+
+```go
+func DecodeByte(data []byte, target any) error
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    var result string
+	byteData := []byte{6, 12, 0, 3, 97, 98, 99}
+	convertor.DecodeByte(byteData, &result)
+    fmt.Println(result) //"abc"
+}
 ```

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,12 +80,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesEcbEncrypt([]byte(data), []byte(key))
 
     fmt.Println(string(encrypted))
@@ -110,14 +110,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesEcbEncrypt([]byte(data), []byte(key))
-	decrypted := cryptor.AesEcbDecrypt(encrypted, []byte(key))
+    decrypted := cryptor.AesEcbDecrypt(encrypted, []byte(key))
     fmt.Println(string(decrypted)) //hello world
 }
 ```
@@ -140,12 +140,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesCbcEncrypt([]byte(data), []byte(key))
 
     fmt.Println(string(encrypted))
@@ -171,14 +171,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesCbcEncrypt([]byte(data), []byte(key))
-	decrypted := cryptor.AesCbcDecrypt(encrypted, []byte(key))
+    decrypted := cryptor.AesCbcDecrypt(encrypted, []byte(key))
     fmt.Println(string(decrypted)) //hello world
 }
 ```
@@ -202,12 +202,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesCtrCrypt([]byte(data), []byte(key))
     decrypted := cryptor.AesCtrCrypt(encrypted, []byte(key))
 
@@ -234,12 +234,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesCfbEncrypt([]byte(data), []byte(key))
     fmt.Println(string(encrypted))
 }
@@ -264,14 +264,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
     key := "abcdefghijklmnop"
     encrypted := cryptor.AesCfbEncrypt([]byte(data), []byte(key))
-	decrypted := cryptor.AesCfbDecrypt(encrypted, []byte(key))
+    decrypted := cryptor.AesCfbDecrypt(encrypted, []byte(key))
     fmt.Println(string(decrypted)) //hello world
 }
 ```
@@ -295,12 +295,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesOfbEncrypt([]byte(data), []byte(key))
     fmt.Println(string(encrypted))
 }
@@ -325,14 +325,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesOfbEncrypt([]byte(data), []byte(key))
-	decrypted := cryptor.AesOfbDecrypt(encrypted, []byte(key))
+    decrypted := cryptor.AesOfbDecrypt(encrypted, []byte(key))
     
     fmt.Println(string(decrypted)) //hello world
 }
@@ -356,11 +356,11 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	base64Str := cryptor.Base64StdEncode("hello world")
+    base64Str := cryptor.Base64StdEncode("hello world")
     fmt.Println(base64Str) //aGVsbG8gd29ybGQ=
 }
 ```
@@ -384,7 +384,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
@@ -412,12 +412,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesEcbEncrypt([]byte(data), []byte(key))
 
     fmt.Println(string(encrypted))
@@ -443,14 +443,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesEcbEncrypt([]byte(data), []byt(key)
-	decrypted := cryptor.DesEcbDecrypt(encrypted, []byte(key))
+    decrypted := cryptor.DesEcbDecrypt(encrypted, []byte(key))
   
     fmt.Println(string(decrypted)) //hello world
 }
@@ -475,12 +475,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesCbcEncrypt([]byte(data), []byt(key)
 
     fmt.Println(string(encrypted))
@@ -506,12 +506,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesCbcEncrypt([]byte(data), []byt(key)
 	decrypted := cryptor.DesCbcDecrypt(encrypted, []byte(key))
     
@@ -538,12 +538,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesCtrCrypt([]byte(data), []byte(key))
     decrypted := cryptor.DesCtrCrypt(encrypted, []byte(key))
 
@@ -570,12 +570,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesCfbEncrypt([]byte(data), []byt(key)
     fmt.Println(string(encrypted))
 }
@@ -600,14 +600,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesCfbEncrypt([]byte(data), []byt(key)
-	decrypted := cryptor.DesCfbDecrypt(encrypted, []byte(key))
+    decrypted := cryptor.DesCfbDecrypt(encrypted, []byte(key))
     fmt.Println(string(decrypted)) //hello world
 }
 ```
@@ -631,12 +631,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesOfbEncrypt([]byte(data), []byte(key))
     fmt.Println(string(encrypted))
 }
@@ -661,14 +661,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesOfbEncrypt([]byte(data), []byte(key))
-	decrypted := cryptor.DesOfbDecrypt(encrypted, []byte(key))
+    decrypted := cryptor.DesOfbDecrypt(encrypted, []byte(key))
     
     fmt.Println(string(decrypted)) //hello world
 }
@@ -693,7 +693,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
@@ -721,12 +721,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.HmacSha1("hello world", "12345"))
-  	fmt.Println(s) //3826f812255d8683f051ee97346d1359234d5dbd
+    s := cryptor.HmacSha1("hello world", "12345"))
+    fmt.Println(s) //3826f812255d8683f051ee97346d1359234d5dbd
 }
 ```
 
@@ -749,12 +749,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.HmacSha256("hello world", "12345"))
-  	fmt.Println(s) //9dce2609f2d67d41f74c7f9efc8ccd44370d41ad2de52982627588dfe7289ab8
+    s := cryptor.HmacSha256("hello world", "12345"))
+    fmt.Println(s) //9dce2609f2d67d41f74c7f9efc8ccd44370d41ad2de52982627588dfe7289ab8
 }
 ```
 
@@ -777,12 +777,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.HmacSha512("hello world", "12345"))
-  	fmt.Println(s) 
+    s := cryptor.HmacSha512("hello world", "12345"))
+    fmt.Println(s) 
  //5b1563ac4e9b49c9ada8ccb232588fc4f0c30fd12f756b3a0b95af4985c236ca60925253bae10ce2c6bf9af1c1679b51e5395ff3d2826c0a2c7c0d72225d4175
 }
 ```
@@ -806,12 +806,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.Md5String("hello"))
-  	fmt.Println(s) //5d41402abc4b2a76b9719d911017c592
+    s := cryptor.Md5String("hello"))
+    fmt.Println(s) //5d41402abc4b2a76b9719d911017c592
 }
 ```
 
@@ -834,12 +834,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.Md5File("./main.go"))
-  	fmt.Println(s)
+    s := cryptor.Md5File("./main.go"))
+    fmt.Println(s)
 }
 ```
 
@@ -862,12 +862,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.Sha1("hello world"))
-  	fmt.Println(s) //2aae6c35c94fcfb415dbe95f408b9ce91ee846ed
+    s := cryptor.Sha1("hello world"))
+    fmt.Println(s) //2aae6c35c94fcfb415dbe95f408b9ce91ee846ed
 }
 ```
 
@@ -890,12 +890,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.Sha256("hello world"))
-  	fmt.Println(s) //b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
+    s := cryptor.Sha256("hello world"))
+    fmt.Println(s) //b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
 }
 ```
 
@@ -918,11 +918,11 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.Sha512("hello world"))
+    s := cryptor.Sha512("hello world"))
     fmt.Println(s) //309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f
 }
 ```
@@ -946,14 +946,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+    err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
     if err != nil {
         fmt.Println(err)
-  	}
+    }
 }
 ```
 
@@ -976,18 +976,18 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+    err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
     if err != nil {
         fmt.Println(err)
     }
   	
     data := []byte("hello world")
-	encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
-	decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
+    encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
+    decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
   	
     fmt.Println(string(decrypted)) //hello world
 }
@@ -1012,18 +1012,18 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+    err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
     if err != nil {
         fmt.Println(err)
-  	}
+    }
   	
     data := []byte("hello world")
-	encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
-	decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
+    encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
+    decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
   	
     fmt.Println(string(decrypted)) //hello world
 }

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,12 +80,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesEcbEncrypt([]byte(data), []byte(key))
 
     fmt.Println(string(encrypted))
@@ -110,14 +110,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesEcbEncrypt([]byte(data), []byte(key))
-		decrypted := cryptor.AesEcbDecrypt(encrypted, []byte(key))
+    decrypted := cryptor.AesEcbDecrypt(encrypted, []byte(key))
     fmt.Println(string(decrypted)) //hello world
 }
 ```
@@ -140,12 +140,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesCbcEncrypt([]byte(data), []byte(key))
 
     fmt.Println(string(encrypted))
@@ -171,14 +171,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesCbcEncrypt([]byte(data), []byte(key))
-		decrypted := cryptor.AesCbcDecrypt(encrypted, []byte(key))
+    decrypted := cryptor.AesCbcDecrypt(encrypted, []byte(key))
     
     fmt.Println(string(decrypted)) //hello world
 }
@@ -203,12 +203,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesCtrCrypt([]byte(data), []byte(key))
     decrypted := cryptor.AesCtrCrypt(encrypted, []byte(key))
 
@@ -235,12 +235,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesCfbEncrypt([]byte(data), []byte(key))
     fmt.Println(string(encrypted))
 }
@@ -265,14 +265,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesCfbEncrypt([]byte(data), []byte(key))
-		decrypted := cryptor.AesCfbDecrypt(encrypted, []byte(key))
+    decrypted := cryptor.AesCfbDecrypt(encrypted, []byte(key))
     fmt.Println(string(decrypted)) //hello world
 }
 ```
@@ -296,12 +296,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesOfbEncrypt([]byte(data), []byte(key))
     fmt.Println(string(encrypted))
 }
@@ -326,14 +326,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefghijklmnop"
+    key := "abcdefghijklmnop"
     encrypted := cryptor.AesOfbEncrypt([]byte(data), []byte(key))
-		decrypted := cryptor.AesOfbDecrypt(encrypted, []byte(key))
+    decrypted := cryptor.AesOfbDecrypt(encrypted, []byte(key))
     fmt.Println(string(decrypted)) //hello world
 }
 ```
@@ -356,11 +356,11 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	base64Str := cryptor.Base64StdEncode("hello world")
+    base64Str := cryptor.Base64StdEncode("hello world")
     fmt.Println(base64Str) //aGVsbG8gd29ybGQ=
 }
 ```
@@ -384,11 +384,11 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	str := cryptor.Base64StdDecode("aGVsbG8gd29ybGQ=")
+    str := cryptor.Base64StdDecode("aGVsbG8gd29ybGQ=")
     fmt.Println(str) //hello world
 }
 ```
@@ -412,12 +412,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesEcbEncrypt([]byte(data), []byte(key))
 
     fmt.Println(string(encrypted))
@@ -443,12 +443,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesEcbEncrypt([]byte(data), []byte(key))
     decrypted := cryptor.DesEcbDecrypt(encrypted, []byte(key))
   
@@ -475,12 +475,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesCbcEncrypt([]byte(data), []byte(key))
 
     fmt.Println(string(encrypted))
@@ -506,12 +506,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesCbcEncrypt([]byte(data), []byte(key))
     decrypted := cryptor.DesCbcDecrypt(encrypted, []byte(key))
     
@@ -538,12 +538,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesCtrCrypt([]byte(data), []byte(key))
     decrypted := cryptor.DesCtrCrypt(encrypted, []byte(key))
 
@@ -570,12 +570,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesCfbEncrypt([]byte(data), []byte(key))
     fmt.Println(string(encrypted))
 }
@@ -600,12 +600,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesCfbEncrypt([]byte(data), []byte(key))
     decrypted := cryptor.DesCfbDecrypt(encrypted, []byte(key))
     fmt.Println(string(decrypted)) //hello world
@@ -631,12 +631,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesOfbEncrypt([]byte(data), []byte(key))
     fmt.Println(string(encrypted))
 }
@@ -661,12 +661,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
     data := "hello world"
-  	key := "abcdefgh"
+    key := "abcdefgh"
     encrypted := cryptor.DesOfbEncrypt([]byte(data), []byte(key))
     decrypted := cryptor.DesOfbDecrypt(encrypted, []byte(key))
     fmt.Println(string(decrypted)) //hello world
@@ -692,12 +692,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.HmacMd5("hello world", "12345"))
-  	fmt.Println(s) //5f4c9faaff0a1ad3007d9ddc06abe36d
+    s := cryptor.HmacMd5("hello world", "12345"))
+    fmt.Println(s) //5f4c9faaff0a1ad3007d9ddc06abe36d
 }
 ```
 
@@ -720,12 +720,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.HmacSha1("hello world", "12345"))
-  	fmt.Println(s) //3826f812255d8683f051ee97346d1359234d5dbd
+    s := cryptor.HmacSha1("hello world", "12345"))
+    fmt.Println(s) //3826f812255d8683f051ee97346d1359234d5dbd
 }
 ```
 
@@ -748,12 +748,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.HmacSha256("hello world", "12345"))
-  	fmt.Println(s) //9dce2609f2d67d41f74c7f9efc8ccd44370d41ad2de52982627588dfe7289ab8
+    s := cryptor.HmacSha256("hello world", "12345"))
+    fmt.Println(s) //9dce2609f2d67d41f74c7f9efc8ccd44370d41ad2de52982627588dfe7289ab8
 }
 ```
 
@@ -776,12 +776,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.HmacSha512("hello world", "12345"))
-  	fmt.Println(s) 
+    s := cryptor.HmacSha512("hello world", "12345"))
+    fmt.Println(s) 
  //5b1563ac4e9b49c9ada8ccb232588fc4f0c30fd12f756b3a0b95af4985c236ca60925253bae10ce2c6bf9af1c1679b51e5395ff3d2826c0a2c7c0d72225d4175
 }
 ```
@@ -805,12 +805,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.Md5String("hello"))
-  	fmt.Println(s) //5d41402abc4b2a76b9719d911017c592
+    s := cryptor.Md5String("hello"))
+    fmt.Println(s) //5d41402abc4b2a76b9719d911017c592
 }
 ```
 
@@ -833,12 +833,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.Md5File("./main.go"))
-  	fmt.Println(s)
+    s := cryptor.Md5File("./main.go"))
+    fmt.Println(s)
 }
 ```
 
@@ -861,12 +861,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.Sha1("hello world"))
-  	fmt.Println(s) //2aae6c35c94fcfb415dbe95f408b9ce91ee846ed
+    s := cryptor.Sha1("hello world"))
+    fmt.Println(s) //2aae6c35c94fcfb415dbe95f408b9ce91ee846ed
 }
 ```
 
@@ -889,12 +889,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.Sha256("hello world"))
-  	fmt.Println(s) //b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
+    s := cryptor.Sha256("hello world"))
+    fmt.Println(s) //b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
 }
 ```
 
@@ -917,12 +917,12 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	s := cryptor.Sha512("hello world"))
-  	fmt.Println(s) //309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f
+    s := cryptor.Sha512("hello world"))
+    fmt.Println(s) //309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f
 }
 ```
 
@@ -945,14 +945,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
-  	if err != nil {
-      fmt.Println(err)
-  	}
+    err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+    if err != nil {
+        fmt.Println(err)
+    }
 }
 ```
 
@@ -975,15 +975,15 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
-  	if err != nil {
-      fmt.Println(err)
-  	}
-  	data := []byte("hello world")
+    err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+    if err != nil {
+        fmt.Println(err)
+    }
+    data := []byte("hello world")
     encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
     decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
   	fmt.Println(string(decrypted)) //hello world
@@ -1009,15 +1009,15 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/cryptor"
+    "github.com/duke-git/lancet/v2/cryptor"
 )
 
 func main() {
-  	err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
-  	if err != nil {
-      fmt.Println(err)
-  	}
-  	data := []byte("hello world")
+    err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+    if err != nil {
+        fmt.Println(err)
+    }
+    data := []byte("hello world")
     encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
     decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
   	fmt.Println(string(decrypted)) //hello world

docs/datastructure/hashmap.md

@@ -0,0 +1,314 @@
+# HashMap
+
+HashMap is a key value map data structure.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source
+
+- [https://github.com/duke-git/lancet/blob/main/datastructure/hashmap/hashmap.go](https://github.com/duke-git/lancet/blob/main/datastructure/hashmap/hashmap.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage
+
+```go
+import (
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+
+## Index
+
+- [NewHashMap](#NewHashMap)
+- [NewHashMapWithCapacity](#NewHashMapWithCapacity)
+- [Get](#Get)
+- [Put](#Put)
+- [Delete](#Delete)
+- [Contains](#Contains)
+- [Iterate](#Iterate)
+- [Keys](#Keys)
+- [Values](#Values)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+### <span id="NewHashMap">NewHashMap</span>
+
+<p>Make a HashMap instance with default capacity is 1 << 10.</p>
+
+<b>Signature:</b>
+
+```go
+func NewHashMap() *HashMap
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMap()
+    fmt.Println(hm)
+}
+```
+
+### <span id="NewHashMap">NewHashMap</span>
+
+<p>Make a HashMap instance with given size and capacity.</p>
+
+<b>Signature:</b>
+
+```go
+func NewHashMapWithCapacity(size, capacity uint64) *HashMap
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMapWithCapacity(uint64(100), uint64(1000))
+    fmt.Println(hm)
+}
+```
+
+### <span id="Get">Get</span>
+
+<p>Get the value of given key in hashmap</p>
+
+<b>Signature:</b>
+
+```go
+func (hm *HashMap) Get(key any) any
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMap()
+    val := hm.Get("a")
+
+    fmt.Println(val) //nil
+}
+```
+
+### <span id="Put">Put</span>
+
+<p>Put new key value in hashmap, then return value</p>
+
+<b>Signature:</b>
+
+```go
+func (hm *HashMap) Put(key any, value any) any
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMap()
+    hm.Put("a", 1)
+
+    val := hm.Get("a")
+    fmt.Println(val) //1
+}
+```
+
+
+
+### <span id="Delete">Delete</span>
+
+<p>Delete key-value item by given key in hashmap.</p>
+
+<b>Signature:</b>
+
+```go
+func (hm *HashMap) Delete(key any)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMap()
+    hm.Put("a", 1)
+    val := hm.Get("a")
+    fmt.Println(val) //1
+
+    hm.Delete("a")
+    val = hm.Get("a")
+    fmt.Println(val) //nil
+}
+```
+
+
+
+### <span id="Contains">Contains</span>
+
+<p>Checks if given key is in hashmap or not.</p>
+
+<b>Signature:</b>
+
+```go
+func (hm *HashMap) Contains(key any) bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMap()
+    hm.Put("a", 1)
+
+    fmt.Println(hm.Contains("a")) //true
+    fmt.Println(hm.Contains("b")) //false
+}
+```
+
+
+
+### <span id="Iterate">Iterate</span>
+
+<p>Executes iteratee funcation for every key and value pair of hashmap.</p>
+
+<b>Signature:</b>
+
+```go
+func (hm *HashMap) Iterate(iteratee func(key, value any))
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMap()
+    hm.Put("a", 1)
+    hm.Put("b", 2)
+    hm.Put("c", 3)
+
+    hm.Iterate(func(key, value any) {
+        fmt.Println(key)
+        fmt.Println(value)
+    })
+}
+```
+
+
+
+### <span id="Keys">Keys</span>
+
+<p>Return a slice of the hashmap's keys (random order).</p>
+
+<b>Signature:</b>
+
+```go
+func (hm *HashMap) Keys() []any
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMap()
+    hm.Put("a", 1)
+    hm.Put("b", 2)
+    hm.Put("c", 3)
+
+    keys := hm.Keys()
+    fmt.Println(keys) //[]interface{"a", "b", "c"}
+}
+```
+
+
+### <span id="Values">Values</span>
+
+<p>Return a slice of the hashmap's values (random order).</p>
+
+<b>Signature:</b>
+
+```go
+func (hm *HashMap) Values() []any
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMap()
+    hm.Put("a", 1)
+    hm.Put("b", 2)
+    hm.Put("c", 3)
+
+    values := hm.Values()
+    fmt.Println(values) //[]interface{2, 1, 3}
+}
+```
+
+

docs/datastructure/hashmap_zh-CN.md

@@ -0,0 +1,308 @@
+# HashMap
+
+HashMap 数据结构实现
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码
+
+- [https://github.com/duke-git/lancet/blob/main/datastructure/hashmap/hashmap.go](https://github.com/duke-git/lancet/blob/main/datastructure/hashmap/hashmap.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法
+
+```go
+import (
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+- [NewHashMap](#NewHashMap)
+- [NewHashMapWithCapacity](#NewHashMapWithCapacity)
+- [Get](#Get)
+- [Put](#Put)
+- [Delete](#Delete)
+- [Contains](#Contains)
+- [Iterate](#Iterate)
+- [Keys](#Keys)
+- [Values](#Values)
+
+<div STYLE="page-break-after: always;"></div>
+
+## API 文档
+
+### <span id="NewHashMap">NewHashMap</span>
+
+<p>新建默认容量（1 << 10）的HashMap指针实例</p>
+
+<b>函数签名:</b>
+
+```go
+func NewHashMap() *HashMap
+```
+
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMap()
+    fmt.Println(hm)
+}
+```
+
+### <span id="NewHashMapWithCapacity">NewHashMapWithCapacity</span>
+
+<p>新建指定容量和长度的HashMap指针实例.</p>
+
+<b>函数签名:</b>
+
+```go
+func NewHashMapWithCapacity(size, capacity uint64) *HashMap
+```
+
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMapWithCapacity(uint64(100), uint64(1000))
+    fmt.Println(hm)
+}
+```
+
+### <span id="Get">Get</span>
+
+<p>在hashmap中根据key获取值</p>
+
+<b>函数签名:</b>
+
+```go
+func (hm *HashMap) Get(key any) any
+```
+
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMap()
+    val := hm.Get("a")
+
+    fmt.Println(val) //nil
+}
+```
+
+### <span id="Put">Put</span>
+
+<p>将key-value放入hashmap中</p>
+
+<b>函数签名:</b>
+
+```go
+func (hm *HashMap) Put(key any, value any) any
+```
+
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMap()
+    hm.Put("a", 1)
+
+    val := hm.Get("a")
+    fmt.Println(val) //1
+}
+```
+
+### <span id="Delete">Delete</span>
+
+<p>将指定的key从hashmap中删除</p>
+
+<b>函数签名:</b>
+
+```go
+func (hm *HashMap) Delete(key any)
+```
+
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMap()
+    hm.Put("a", 1)
+    val := hm.Get("a")
+    fmt.Println(val) //1
+
+    hm.Delete("a")
+    val = hm.Get("a")
+    fmt.Println(val) //nil
+}
+```
+
+### <span id="Contains">Contains</span>
+
+<p>判断hashmap中是否包含指定的key</p>
+
+<b>函数签名:</b>
+
+```go
+func (hm *HashMap) Contains(key any) bool
+```
+
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMap()
+    hm.Put("a", 1)
+
+    fmt.Println(hm.Contains("a")) //true
+    fmt.Println(hm.Contains("b")) //false
+}
+```
+
+
+### <span id="Iterate">Iterate</span>
+
+<p>迭代hashmap，对每个key和value执行iteratee函数</p>
+
+<b>函数签名:</b>
+
+```go
+func (hm *HashMap) Iterate(iteratee func(key, value any))
+```
+
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMap()
+    hm.Put("a", 1)
+    hm.Put("b", 2)
+    hm.Put("c", 3)
+
+    hm.Iterate(func(key, value any) {
+        fmt.Println(key)
+        fmt.Println(value)
+    })
+}
+```
+
+
+
+### <span id="Keys">Keys</span>
+
+<p>返回hashmap所有key的切片 (随机顺序)</p>
+
+<b>函数签名:</b>
+
+```go
+func (hm *HashMap) Keys() []any
+```
+
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMap()
+    hm.Put("a", 1)
+    hm.Put("b", 2)
+    hm.Put("c", 3)
+
+    keys := hm.Keys()
+    fmt.Println(keys) //[]interface{"a", "b", "c"}
+}
+```
+
+
+### <span id="Values">Values</span>
+
+<p>返回hashmap所有值的切片 (随机顺序).</p>
+
+<b>函数签名:</b>
+
+```go
+func (hm *HashMap) Values() []any
+```
+
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := heap.NewHashMap()
+    hm.Put("a", 1)
+    hm.Put("b", 2)
+    hm.Put("c", 3)
+
+    values := hm.Values()
+    fmt.Println(values) //[]interface{2, 1, 3}
+}
+```
+
+

docs/datastructure/heap.md

@@ -0,0 +1,364 @@
+# Heap
+Heap is a binary heap tree implemented by slice.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source
+
+- [https://github.com/duke-git/lancet/blob/main/datastructure/heap/maxheap.go](https://github.com/duke-git/lancet/blob/main/datastructure/heap/maxheap.go)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage
+```go
+import (
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+
+- [MaxHeap](#MaxHeap)
+- [Push](#Push)
+- [Pop](#Pop)
+- [Peek](#Peek)
+- [Data](#Data)
+- [Size](#Size)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+### 1. MaxHeap
+MaxHeap is a binary heap tree implemented by slice, The key of the root node is both greater than or equal to the key value of the left subtree and greater than or equal to the key value of the right subtree.
+
+### <span id="NewMaxHeap">NewMaxHeap</span>
+<p>Return a NewMaxHeap pointer instance.</p>
+
+<b>Signature:</b>
+
+```go
+type MaxHeap[T any] struct {
+	data       []T
+	comparator lancetconstraints.Comparator
+}
+func NewMaxHeap[T any](comparator lancetconstraints.Comparator) *MaxHeap[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+
+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() {
+    maxHeap := heap.NewMaxHeap[int](&intComparator{})
+    fmt.Println(maxHeap)
+}
+```
+
+
+
+
+### <span id="Push">Push</span>
+<p>Push value into the heap</p>
+
+<b>Signature:</b>
+
+```go
+func (h *MaxHeap[T]) Push(value T)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+
+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() {
+    maxHeap := heap.NewMaxHeap[int](&intComparator{})
+    values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+
+	for _, v := range values {
+		maxHeap.Push(v)
+	}
+
+    fmt.Println(maxHeap.Data()) //[]int{12, 9, 11, 4, 8, 10, 7, 1, 3, 5, 6, 2}
+}
+```
+
+
+
+
+### <span id="Pop">Pop</span>
+<p>Pop return the largest value, and remove it from the heap if heap is empty, return zero value and fasle</p>
+
+<b>Signature:</b>
+
+```go
+func (h *MaxHeap[T]) Pop() (T, bool)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+
+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() {
+    maxHeap := heap.NewMaxHeap[int](&intComparator{})
+    values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+
+	for _, v := range values {
+		maxHeap.Push(v)
+	}
+    val, ok := maxHeap.Pop()
+
+    fmt.Println(val) //12
+    fmt.Println(ok) //true
+}
+```
+
+
+
+### <span id="Peek">Peek</span>
+<p>Return the largest element from the heap without removing it, if heap is empty, it returns zero value and false.</p>
+
+<b>Signature:</b>
+
+```go
+func (h *MaxHeap[T]) Peek() (T, bool)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+
+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() {
+    maxHeap := heap.NewMaxHeap[int](&intComparator{})
+    values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+
+	for _, v := range values {
+		maxHeap.Push(v)
+	}
+    val, ok := maxHeap.Peek()
+
+    fmt.Println(val) //12
+    fmt.Println(maxHeap.Size()) //12
+}
+```
+
+
+
+### <span id="Data">Data</span>
+<p>Return all element of the heap</p>
+
+<b>Signature:</b>
+
+```go
+func (h *MaxHeap[T]) Data() []T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+
+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() {
+    maxHeap := heap.NewMaxHeap[int](&intComparator{})
+    values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+
+	for _, v := range values {
+		maxHeap.Push(v)
+	}
+
+    fmt.Println(maxHeap.Data()) //[]int{12, 9, 11, 4, 8, 10, 7, 1, 3, 5, 6, 2}
+}
+```
+
+
+### <span id="Size">Size</span>
+<p>Return the number of elements in the heap</p>
+
+<b>Signature:</b>
+
+```go
+func (h *MaxHeap[T]) Size() int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+
+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() {
+    maxHeap := heap.NewMaxHeap[int](&intComparator{})
+    values := []int{6, 5, 2}
+
+	for _, v := range values {
+		maxHeap.Push(v)
+	}
+
+    fmt.Println(maxHeap.Size()) //3
+}
+```
+
+
+
+### <span id="PrintStructure">PrintStructure</span>
+<p>Print the tree structure of the heap</p>
+
+<b>Signature:</b>
+
+```go
+func (h *MaxHeap[T]) PrintStructure()
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+
+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() {
+    maxHeap := heap.NewMaxHeap[int](&intComparator{})
+    values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+
+	for _, v := range values {
+		maxHeap.Push(v)
+	}
+
+    fmt.Println(maxHeap.PrintStructure())
+//        12
+//    9       11
+//  4   8   10   7
+// 1 3 5 6 2
+}
+```

docs/datastructure/heap_zh-CN.md

@@ -0,0 +1,364 @@
+# Heap
+堆，切片实现的二叉堆数据结构。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码
+
+- [https://github.com/duke-git/lancet/blob/main/datastructure/heap/maxheap.go](https://github.com/duke-git/lancet/blob/main/datastructure/heap/maxheap.go)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法
+```go
+import (
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+- [MaxHeap](#MaxHeap)
+- [Push](#Push)
+- [Pop](#Pop)
+- [Peek](#Peek)
+- [Data](#Data)
+- [Size](#Size)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## API文档
+
+### 1. MaxHeap
+MaxHeap是通过slice实现的二叉堆树，根节点的key既大于等于左子树的key值且大于等于右子树的key值。
+
+### <span id="NewMaxHeap">NewMaxHeap</span>
+<p>返回NewMaxHeap指针实例</p>
+
+<b>函数签名:</b>
+
+```go
+type MaxHeap[T any] struct {
+	data       []T
+	comparator lancetconstraints.Comparator
+}
+func NewMaxHeap[T any](comparator lancetconstraints.Comparator) *MaxHeap[T]
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+
+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() {
+    maxHeap := heap.NewMaxHeap[int](&intComparator{})
+    fmt.Println(maxHeap)
+}
+```
+
+
+
+
+### <span id="Push">Push</span>
+<p>向堆中插入数据</p>
+
+<b>函数签名:</b>
+
+```go
+func (h *MaxHeap[T]) Push(value T)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+
+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() {
+    maxHeap := heap.NewMaxHeap[int](&intComparator{})
+    values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+
+	for _, v := range values {
+		maxHeap.Push(v)
+	}
+
+    fmt.Println(maxHeap.Data()) //[]int{12, 9, 11, 4, 8, 10, 7, 1, 3, 5, 6, 2}
+}
+```
+
+
+
+
+### <span id="Pop">Pop</span>
+<p>返回堆中最大值并将其从堆中删除，如果堆为空，返回零值并返回false</p>
+
+<b>函数签名:</b>
+
+```go
+func (h *MaxHeap[T]) Pop() (T, bool)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+
+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() {
+    maxHeap := heap.NewMaxHeap[int](&intComparator{})
+    values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+
+	for _, v := range values {
+		maxHeap.Push(v)
+	}
+    val, ok := maxHeap.Pop()
+
+    fmt.Println(val) //12
+    fmt.Println(ok) //true
+}
+```
+
+
+
+### <span id="Peek">Peek</span>
+<p>返回堆中最大值，如果堆为空，返回零值并返回false</p>
+
+<b>函数签名:</b>
+
+```go
+func (h *MaxHeap[T]) Peek() (T, bool)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+
+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() {
+    maxHeap := heap.NewMaxHeap[int](&intComparator{})
+    values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+
+	for _, v := range values {
+		maxHeap.Push(v)
+	}
+    val, ok := maxHeap.Peek()
+
+    fmt.Println(val) //12
+    fmt.Println(maxHeap.Size()) //12
+}
+```
+
+
+
+### <span id="Data">Data</span>
+<p>返回堆中全部元素的切片</p>
+
+<b>函数签名:</b>
+
+```go
+func (h *MaxHeap[T]) Data() []T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+
+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() {
+    maxHeap := heap.NewMaxHeap[int](&intComparator{})
+    values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+
+	for _, v := range values {
+		maxHeap.Push(v)
+	}
+
+    fmt.Println(maxHeap.Data()) //[]int{12, 9, 11, 4, 8, 10, 7, 1, 3, 5, 6, 2}
+}
+```
+
+
+### <span id="Size">Size</span>
+<p>返回堆中元素的数量</p>
+
+<b>函数签名:</b>
+
+```go
+func (h *MaxHeap[T]) Size() int
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+
+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() {
+    maxHeap := heap.NewMaxHeap[int](&intComparator{})
+    values := []int{6, 5, 2}
+
+	for _, v := range values {
+		maxHeap.Push(v)
+	}
+
+    fmt.Println(maxHeap.Size()) //3
+}
+```
+
+
+
+### <span id="PrintStructure">PrintStructure</span>
+<p>打印堆的树形结构</p>
+
+<b>函数签名:</b>
+
+```go
+func (h *MaxHeap[T]) PrintStructure()
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+
+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() {
+    maxHeap := heap.NewMaxHeap[int](&intComparator{})
+    values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+
+	for _, v := range values {
+		maxHeap.Push(v)
+	}
+
+    fmt.Println(maxHeap.PrintStructure())
+//        12
+//    9       11
+//  4   8   10   7
+// 1 3 5 6 2
+}
+```

docs/datastructure/list.md

@@ -0,0 +1,884 @@
+# 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)
+- [LastIndexOf](#LastIndexOf)
+- [IndexOfFunc](#IndexOfFunc)
+- [LastIndexOfFunc](#LastIndexOfFunc)
+- [Push](#Push)
+- [PopFirst](#PopFirst)
+- [PopLast](#PopLast)
+- [DeleteAt](#DeleteAt)
+- [InsertAt](#InsertAt)
+- [UpdateAt](#UpdateAt)
+- [Equal](#Equal)
+- [IsEmpty](#IsEmpty)
+- [Clear](#Clear)
+- [Clone](#Clone)
+- [Merge](#Merge)
+- [Size](#Size)
+- [Cap](#Cap)
+- [Swap](#Swap)
+- [Reverse](#Reverse)
+- [Unique](#Unique)
+- [Union](#Union)
+- [Intersection](#Intersection)
+- [SubList](#SubList)
+- [DeleteIf](#DeleteIf)
+
+<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>Returns 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="LastIndexOf">LastIndexOf</span>
+<p> Returns the index of the last occurrence of the value in this list if not found return -1</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) LastIndexOf(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, 1})
+
+    fmt.Println(li.LastIndexOf(1)) // 3
+    fmt.Println(li.LastIndexOf(0)) //-1
+}
+```
+
+### <span id="IndexOfFunc">IndexOfFunc</span>
+<p> IndexOfFunc returns the first index satisfying f(v). if not found return -1</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) IndexOfFunc(f func(T) bool) 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.IndexOfFunc(func(a int) bool { return a == 1 })) //0
+    fmt.Println(li.IndexOfFunc(func(a int) bool { return a == 0 })) //-1
+}
+```
+
+### <span id="LastIndexOfFunc">LastIndexOfFunc</span>
+<p>LastIndexOfFunc returns the index of the last occurrence of the value in this list satisfying f(data[i]). if not found return -1</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) LastIndexOfFunc(f func(T) bool) 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, 1})
+
+    fmt.Println(li.LastIndexOfFunc(func(a int) bool { return a == 1 })) // 3
+    fmt.Println(li.LastIndexOfFunc(func(a int) bool { return a == 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="Cap">Cap</span>
+<p>Cap return cap of the inner data</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) Cap() int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+	data := make([]int, 0, 100)
+	
+    li := list.NewList(data)
+
+    fmt.Println(li.Cap()) // 100
+}
+```
+
+
+
+
+### <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
+}
+```
+
+
+
+
+### <span id="SubList">SubList</span>
+<p>SubList returns a sub list of the original list between the specified fromIndex, inclusive, and toIndex, exclusive.</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) SubList(fromIndex, toIndex int) *List[T] 
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    l := list.NewList([]int{1, 2, 3, 4, 5, 6})
+   
+    fmt.Println(l.SubList(2, 5)) // []int{3, 4, 5}
+}
+```
+
+
+
+
+### <span id="DeleteIf">DeleteIf</span>
+<p>DeleteIf delete all satisfying f(data[i]), returns count of removed elements</p>
+
+<b>Signature:</b>
+
+```go
+func (l *List[T]) DeleteIf(f func(T) bool) int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+	l := list.NewList([]int{1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1, 1, 1})
+
+	fmt.Println(l.DeleteIf(func(a int) bool { return a == 1 })) // 12 
+	fmt.Println(l.Data()) // []int{2, 3, 4}
+}
+```

docs/datastructure/list_zh-CN.md

@@ -0,0 +1,882 @@
+# 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)
+- [LastIndexOf](#LastIndexOf)
+- [IndexOfFunc](#IndexOfFunc)
+- [LastIndexOfFunc](#LastIndexOfFunc)
+- [Push](#Push)
+- [PopFirst](#PopFirst)
+- [PopLast](#PopLast)
+- [DeleteAt](#DeleteAt)
+- [InsertAt](#InsertAt)
+
+- [UpdateAt](#UpdateAt)
+- [Equal](#Equal)
+- [IsEmpty](#IsEmpty)
+- [Clear](#Clear)
+- [Clone](#Clone)
+- [Merge](#Merge)
+- [Size](#Size)
+- [Cap](#Cap)
+- [Swap](#Swap)
+- [Reverse](#Reverse)
+- [Unique](#Unique)
+- [Union](#Union)
+- [Intersection](#Intersection)
+- [SubList](#SubList)
+- [DeleteIf](#DeleteIf)
+
+<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="LastIndexOf">LastIndexOf</span>
+<p>返回列表中最后一次出现的值的索引。如果未找到，则返回-1</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) LastIndexOf(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, 1})
+
+    fmt.Println(li.LastIndexOf(1)) // 3
+    fmt.Println(li.LastIndexOf(0)) //-1
+}
+```
+
+### <span id="IndexOfFunc">IndexOfFunc</span>
+<p>返回第一个符合函数条件的元素的索引。如果未找到，则返回-1</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) IndexOfFunc(f func(T) bool) 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.IndexOfFunc(func(a int) bool { return a == 1 })) //0
+    fmt.Println(li.IndexOfFunc(func(a int) bool { return a == 0 })) //-1
+}
+```
+
+### <span id="LastIndexOfFunc">LastIndexOfFunc</span>
+<p>返回最后一个符合函数条件的元素的索引。如果未找到，则返回-1</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) LastIndexOfFunc(f func(T) bool) 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, 1})
+
+    fmt.Println(li.LastIndexOfFunc(func(a int) bool { return a == 1 })) // 3
+    fmt.Println(li.LastIndexOfFunc(func(a int) bool { return a == 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="Cap">Cap</span>
+<p>返回列表数据容量</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) Cap() int
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+	data := make([]int, 0, 100)
+	
+    li := list.NewList(data)
+
+    fmt.Println(li.Cap()) // 100
+}
+```
+
+
+
+### <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
+}
+```
+
+
+
+### <span id="SubList">SubList</span>
+<p>SubList returns a sub list of the original list between the specified fromIndex, inclusive, and toIndex, exclusive.</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) SubList(fromIndex, toIndex int) *List[T] 
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    l := list.NewList([]int{1, 2, 3, 4, 5, 6})
+   
+    fmt.Println(l.SubList(2, 5)) // []int{3, 4, 5}
+}
+```
+
+
+
+
+### <span id="DeleteIf">DeleteIf</span>
+<p>删除列表中所有符合函数（调用函数返回true)的元素，返回删除元素的数量</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *List[T]) DeleteIf(f func(T) bool) int
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    list "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+	l := list.NewList([]int{1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1, 1, 1})
+
+	fmt.Println(l.DeleteIf(func(a int) bool { return a == 1 })) // 12 
+	fmt.Println(l.Data()) // []int{2, 3, 4}
+}
+```

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

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

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>},  ]
+}
+```

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>},  ]
+}
+```

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

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

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

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

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,14 +135,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )
 
 func main() {
     err := fileutil.CopyFile("./test.txt", "./test_copy.txt")
-	if err != nil {
-		fmt.Println(err)
-	}
+    if err != nil {
+        fmt.Println(err)
+    }
 }
 ```
 
@@ -135,14 +163,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )
 
 func main() {
     mode, err := fileutil.FileMode("./test.txt")
-	if err != nil {
-		fmt.Println(err)
-	}
+    if err != nil {
+        fmt.Println(err)
+    }
     fmt.Println(mode)
 }
 ```
@@ -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,14 +332,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )
 
 func main() {
     err := fileutil.RemoveFile("./test.txt")
     if err != nil {
-		fmt.Println(err)
-	}
+        fmt.Println(err)
+    }
 }
 ```
 
@@ -332,17 +360,17 @@ package main
 import (
     "fmt"
     "os"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )
 
 func main() {
     path := "./test.txt"
-	fileutil.CreateFile(path)
+    fileutil.CreateFile(path)
 
-	f, _ := os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0777)
-	f.WriteString("hello world")
+    f, _ := os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0777)
+    f.WriteString("hello world")
 
-	content, _ := fileutil.ReadFileToString(path)
+    content, _ := fileutil.ReadFileToString(path)
     fmt.Println(content) //hello world
 }
 ```
@@ -365,18 +393,18 @@ package main
 import (
     "fmt"
     "os"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )
 
 func main() {
     path := "./text.txt"
-	fileutil.CreateFile(path)
+    fileutil.CreateFile(path)
 
-	f, _ := os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0777)
-	defer f.Close()
-	f.WriteString("hello\nworld")
+    f, _ := os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0777)
+    defer f.Close()
+    f.WriteString("hello\nworld")
 
-	contents, _ := fileutil.ReadFileByLine(path)
+    contents, _ := fileutil.ReadFileByLine(path)
     fmt.Println(contents) //[]string{"hello", "world"}
 }
 ```
@@ -398,11 +426,11 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )
 
 func main() {
-	err := fileutil.Zip("./test.txt", "./test.zip")
+    err := fileutil.Zip("./test.txt", "./test.zip")
     if err != nil {
         fmt.Println(err)
     }
@@ -427,11 +455,11 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )
 
 func main() {
-	err := fileutil.Zip("./test.zip", "./unzip/test.txt")
+    err := fileutil.Zip("./test.zip", "./unzip/test.txt")
     if err != nil {
         fmt.Println(err)
     }

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,14 +134,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )
 
 func main() {
     err := fileutil.CopyFile("./test.txt", "./test_copy.txt")
-	if err != nil {
-		fmt.Println(err)
-	}
+    if err != nil {
+        fmt.Println(err)
+    }
 }
 ```
 
@@ -135,14 +162,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )
 
 func main() {
     mode, err := fileutil.FileMode("./test.txt")
-	if err != nil {
-		fmt.Println(err)
-	}
+    if err != nil {
+        fmt.Println(err)
+    }
     fmt.Println(mode)
 }
 ```
@@ -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,14 +331,14 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )
 
 func main() {
     err := fileutil.RemoveFile("./test.txt")
     if err != nil {
-		fmt.Println(err)
-	}
+        fmt.Println(err)
+    }
 }
 ```
 
@@ -332,17 +359,17 @@ package main
 import (
     "fmt"
     "os"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )
 
 func main() {
     path := "./test.txt"
-	fileutil.CreateFile(path)
+    fileutil.CreateFile(path)
 
-	f, _ := os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0777)
-	f.WriteString("hello world")
+    f, _ := os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0777)
+    f.WriteString("hello world")
 
-	content, _ := fileutil.ReadFileToString(path)
+    content, _ := fileutil.ReadFileToString(path)
     fmt.Println(content) //hello world
 }
 ```
@@ -365,18 +392,18 @@ package main
 import (
     "fmt"
     "os"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )
 
 func main() {
     path := "./text.txt"
-	fileutil.CreateFile(path)
+    fileutil.CreateFile(path)
 
-	f, _ := os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0777)
-	defer f.Close()
-	f.WriteString("hello\nworld")
+    f, _ := os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0777)
+    defer f.Close()
+    f.WriteString("hello\nworld")
 
-	contents, _ := fileutil.ReadFileByLine(path)
+    contents, _ := fileutil.ReadFileByLine(path)
     fmt.Println(contents) //[]string{"hello", "world"}
 }
 ```
@@ -398,11 +425,11 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )
 
 func main() {
-	err := fileutil.Zip("./test.txt", "./test.zip")
+    err := fileutil.Zip("./test.txt", "./test.zip")
     if err != nil {
         fmt.Println(err)
     }
@@ -427,11 +454,11 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/fileutil"
+    "github.com/duke-git/lancet/v2/fileutil"
 )
 
 func main() {
-	err := fileutil.Zip("./test.zip", "./unzip/test.txt")
+    err := fileutil.Zip("./test.zip", "./unzip/test.txt")
     if err != nil {
         fmt.Println(err)
     }

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() {

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() {

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,20 +96,18 @@ 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() {
-    assert := internal.NewAssert(t, "TestBefore")
-
 	arr := []string{"a", "b", "c", "d", "e"}
 	f := function.Before(3, func(i int) int {
 		return i
 	})
 
 	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())
@@ -120,7 +118,7 @@ func main() {
 	}
 
 	expected := []int64{0, 1, 2, 2, 2}
-	assert.Equal(expected, res)
+	fmt.Println(res) // 0, 1, 2, 2, 2
 }
 ```
 
@@ -133,8 +131,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 +141,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 +166,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 +175,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 +211,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )
 
 func main() {
@@ -246,7 +244,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 +253,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )
 
 func main() {
@@ -275,7 +273,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 +282,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )
 
 func main() {
@@ -327,7 +325,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )
 
 func main() {

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,20 +96,18 @@ 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() {
-	assert := internal.NewAssert(t, "TestBefore")
-
 	arr := []string{"a", "b", "c", "d", "e"}
 	f := function.Before(3, func(i int) int {
 		return i
 	})
 
 	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())
@@ -119,8 +117,7 @@ func main() {
 		appendStr(i, arr[i], f)
 	}
 
-	expected := []int64{0, 1, 2, 2, 2}
-	assert.Equal(expected, res)
+	fmt.Println(res) // 0, 1, 2, 2, 2
 }
 ```
 
@@ -133,8 +130,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 +140,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 +165,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 +174,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 +210,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )
 
 func main() {
@@ -246,7 +243,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 +252,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )
 
 func main() {
@@ -275,7 +272,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 +281,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )
 
 func main() {
@@ -297,7 +294,7 @@ func main() {
 	time.Sleep(5 * time.Second)
 	close(stop)
 
-    fmt.Println(res) //[* * * * *]
+	fmt.Println(res) //[* * * * *]
 }
 ```
 
@@ -327,7 +324,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/function"
+    "github.com/duke-git/lancet/v2/function"
 )
 
 func main() {

docs/maputil.md

@@ -0,0 +1,352 @@
+# 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/map.go](https://github.com/duke-git/lancet/blob/main/maputil/map.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)
+- [IsDisjoint](#IsDisjoint)
+
+<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"}
+}
+```
+
+### <span id="IsDisjoint">IsDisjoint</span>
+<p>Checks two maps are disjoint if they have no keys in common</p>
+
+<b>Signature:</b>
+
+```go
+func IsDisjoint[K comparable, V any](mapA, mapB map[K]V) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+	m1 := map[int]string{
+		1: "a",
+		2: "a",
+		3: "b",
+		4: "c",
+		5: "d",
+	}
+
+	m2 := map[int]string{
+		1: "a",
+		2: "a",
+		3: "b",
+		4: "c",
+		5: "d",
+	}
+
+	m3 := map[int]string{
+		6: "a",
+	}
+
+	ok := maputil.IsDisjoint(m2, m1)
+	fmt.Println(ok) // false
+
+	ok = maputil.IsDisjoint(m2, m3)
+	fmt.Println(ok) // true
+}
+```

docs/maputil_zh-CN.md

@@ -0,0 +1,352 @@
+# Maputil
+maputil包包括一些操作map的函数。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+- [https://github.com/duke-git/lancet/blob/main/maputil/map.go](https://github.com/duke-git/lancet/blob/main/maputil/map.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)
+- [IsDisjoint](#IsDisjoint)
+
+<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"}
+}
+```
+
+
+### <span id="IsDisjoint">IsDisjoint</span>
+<p>验证两个map是否具有不同的key</p>
+
+<b>函数签名:</b>
+
+```go
+func IsDisjoint[K comparable, V any](mapA, mapB map[K]V) bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+	m1 := map[int]string{
+		1: "a",
+		2: "a",
+		3: "b",
+		4: "c",
+		5: "d",
+	}
+
+	m2 := map[int]string{
+		1: "a",
+		2: "a",
+		3: "b",
+		4: "c",
+		5: "d",
+	}
+
+	m3 := map[int]string{
+		6: "a",
+	}
+
+	ok := maputil.IsDisjoint(m2, m1)
+	fmt.Println(ok) // false
+
+	ok = maputil.IsDisjoint(m2, m3)
+	fmt.Println(ok) // true
+}
+```

docs/mathutil.md

@@ -5,7 +5,7 @@ Package mathutil implements some functions for math calculation.
 
 ## Source:
 
-[https://github.com/duke-git/lancet/blob/main/mathutil/mathutil.go](https://github.com/duke-git/lancet/blob/main/mathutil/mathutil.go)
+- [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>
@@ -13,16 +13,22 @@ Package mathutil implements some functions for math calculation.
 ## Example:
 ```go
 import (
-    "github.com/duke-git/lancet/mathutil"
+    "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)
@@ -33,6 +39,35 @@ import (
 ## 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>
 
@@ -48,7 +83,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/mathutil"
+    "github.com/duke-git/lancet/v2/mathutil"
 )
 
 func main() {
@@ -75,7 +110,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/mathutil"
+    "github.com/duke-git/lancet/v2/mathutil"
 )
 
 func main() {
@@ -104,7 +139,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/mathutil"
+    "github.com/duke-git/lancet/v2/mathutil"
 )
 
 func main() {
@@ -117,6 +152,138 @@ func main() {
 
 
 
+### <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>
 
@@ -132,7 +299,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/mathutil"
+    "github.com/duke-git/lancet/v2/mathutil"
 )
 
 func main() {
@@ -158,7 +325,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/mathutil"
+    "github.com/duke-git/lancet/v2/mathutil"
 )
 
 func main() {
@@ -188,7 +355,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/mathutil"
+    "github.com/duke-git/lancet/v2/mathutil"
 )
 
 func main() {
@@ -217,7 +384,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/mathutil"
+    "github.com/duke-git/lancet/v2/mathutil"
 )
 
 func main() {

docs/mathutil_zh-CN.md

@@ -5,7 +5,7 @@ mathutil包实现了一些数学计算的函数.
 
 ## 源码:
 
-[https://github.com/duke-git/lancet/blob/main/mathutil/mathutil.go](https://github.com/duke-git/lancet/blob/main/mathutil/mathutil.go)
+- [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>
@@ -13,17 +13,22 @@ mathutil包实现了一些数学计算的函数.
 ## 用法:
 ```go
 import (
-    "github.com/duke-git/lancet/mathutil"
+    "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)
@@ -34,6 +39,33 @@ import (
 ## 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>
 
@@ -49,7 +81,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/mathutil"
+    "github.com/duke-git/lancet/v2/mathutil"
 )
 
 func main() {
@@ -76,7 +108,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/mathutil"
+    "github.com/duke-git/lancet/v2/mathutil"
 )
 
 func main() {
@@ -105,7 +137,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/mathutil"
+    "github.com/duke-git/lancet/v2/mathutil"
 )
 
 func main() {
@@ -117,6 +149,137 @@ func main() {
 ```
 
 
+### <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>
@@ -133,7 +296,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/mathutil"
+    "github.com/duke-git/lancet/v2/mathutil"
 )
 
 func main() {
@@ -159,7 +322,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/mathutil"
+    "github.com/duke-git/lancet/v2/mathutil"
 )
 
 func main() {
@@ -189,7 +352,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/mathutil"
+    "github.com/duke-git/lancet/v2/mathutil"
 )
 
 func main() {
@@ -218,7 +381,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/mathutil"
+    "github.com/duke-git/lancet/v2/mathutil"
 )
 
 func main() {

docs/netutil.md

@@ -5,16 +5,18 @@ 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_client.go](https://github.com/duke-git/lancet/blob/main/netutil/http_client.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"
 )
 ```
 
@@ -22,17 +24,26 @@ import (
 
 ## Index
 - [ConvertMapToQueryString](#ConvertMapToQueryString)
+- [EncodeUrl](#EncodeUrl)
+  
 - [GetInternalIp](#GetInternalIp)
 - [GetIps](#GetIps)
 - [GetMacAddrs](#GetMacAddrs)
 - [GetPublicIpInfo](#GetPublicIpInfo)
+- [GetRequestPublicIp](#GetRequestPublicIp)
 - [IsPublicIP](#IsPublicIP)
-- [HttpGet](#HttpGet)
-- [HttpDelete](#HttpDelete)
-- [HttpPost](#HttpPost)
-- [HttpPut](#HttpPut)
+- [IsInternalIP](#IsInternalIP)
+- [HttpRequest](#HttpRequest)
+- [HttpClient](#HttpClient)
+- [SendRequest](#SendRequest)
+- [DecodeResponse](#DecodeResponse)
+- [StructToUrlValues](#StructToUrlValues)
 
-- [HttpPatch](#HttpPatch)
+- [HttpGet<sup>Deprecated</sup>](#HttpGet)
+- [HttpDelete<sup>Deprecated</sup>](#HttpDelete)
+- [HttpPost<sup>Deprecated</sup>](#HttpPost)
+- [HttpPut<sup>Deprecated</sup>](#HttpPut)
+- [HttpPatch<sup>Deprecated</sup>](#HttpPatch)
 - [ParseHttpResponse](#ParseHttpResponse)
 
 <div STYLE="page-break-after: always;"></div>
@@ -46,7 +57,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 +66,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,
@@ -72,6 +83,36 @@ func main() {
 
 
 
+### <span id="EncodeUrl">EncodeUrl</span>
+<p>Encode url query string values.</p>
+
+<b>Signature:</b>
+
+```go
+func EncodeUrl(urlStr string) (string, error)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+	urlAddr := "http://www.lancet.com?a=1&b=[2]"
+	encodedUrl, err := netutil.EncodeUrl(urlAddr)
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(encodedUrl) //http://www.lancet.com?a=1&b=%5B2%5D
+}
+```
+
+
+
 ### <span id="GetInternalIp">GetInternalIp</span>
 <p>Get internal ip information.</p>
 
@@ -88,7 +129,7 @@ package main
 import (
     "fmt"
 	"net"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -117,7 +158,7 @@ package main
 import (
     "fmt"
 	"net"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -144,7 +185,7 @@ package main
 import (
     "fmt"
 	"net"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -184,7 +225,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -199,8 +240,51 @@ func main() {
 
 
 
+### <span id="GetRequestPublicIp">GetRequestPublicIp</span>
+<p>Get http request public ip.</p>
+
+<b>Signature:</b>
+
+```go
+func GetRequestPublicIp(req *http.Request) string
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+	ip := "36.112.24.10"
+
+	request1 := http.Request{
+		Method: "GET",
+		Header: http.Header{
+			"X-Forwarded-For": {ip},
+		},
+	}
+	publicIp1 := netutil.GetRequestPublicIp(&request1)
+	fmt.Println(publicIp1) //36.112.24.10
+
+	request2 := http.Request{
+		Method: "GET",
+		Header: http.Header{
+			"X-Real-Ip": {ip},
+		},
+	}
+	publicIp2 := netutil.GetRequestPublicIp(&request2)
+	fmt.Println(publicIp2) //36.112.24.10
+}
+```
+
+
+
 ### <span id="IsPublicIP">IsPublicIP</span>
-<p>Checks if a ip is public or not.</p>
+<p>Checks if an ip is public or not.</p>
 
 <b>Signature:</b>
 
@@ -215,7 +299,7 @@ package main
 import (
     "fmt"
 	"net"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -230,17 +314,271 @@ func main() {
 
 
 
-### <span id="HttpGet">HttpGet</span>
+### <span id="IsInternalIP">IsInternalIP</span>
+<p>Checks if an ip is intranet or not.</p>
+
+<b>Signature:</b>
+
+```go
+func IsInternalIP(IP net.IP) bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+	"net"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+	ip1 := net.ParseIP("127.0.0.1")
+	ip2 := net.ParseIP("36.112.24.10")
+
+	fmt.Println(netutil.IsInternalIP(ip1)) //true
+	fmt.Println(netutil.IsInternalIP(ip2)) //false
+}
+```
+
+
+### <span id="HttpRequest">HttpRequest</span>
+<p>HttpRequest is a struct used to abstract HTTP request entity.</p>
+
+<b>Signature:</b>
+
+```go
+type HttpRequest struct {
+	RawURL      string
+	Method      string
+	Headers     http.Header
+	QueryParams url.Values
+	FormData    url.Values
+	Body        []byte
+}
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+	"net"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+	header := http.Header{}
+	header.Add("Content-Type", "multipart/form-data")
+
+	postData := url.Values{}
+	postData.Add("userId", "1")
+	postData.Add("title", "testItem")
+
+	request := &netutil.HttpRequest{
+		RawURL:   "https://jsonplaceholder.typicode.com/todos",
+		Method:   "POST",
+		Headers:  header,
+		FormData: postData,
+	}
+}
+```
+
+
+### <span id="HttpClient">HttpClient</span>
+<p>HttpClient is a struct used to send HTTP request. It can be instanced with some configurations or none config.</p>
+
+<b>Signature:</b>
+
+```go
+type HttpClient struct {
+	*http.Client
+	TLS     *tls.Config
+	Request *http.Request
+	Config  HttpClientConfig
+}
+
+type HttpClientConfig struct {
+	SSLEnabled       bool
+	TLSConfig        *tls.Config
+	Compressed       bool
+	HandshakeTimeout time.Duration
+	ResponseTimeout  time.Duration
+	Verbose          bool
+}
+
+func NewHttpClient() *HttpClient
+
+func NewHttpClientWithConfig(config *HttpClientConfig) *HttpClient
+
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+	"net"
+	"time"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+	httpClientCfg := netutil.HttpClientConfig{
+		SSLEnabled: true,
+		HandshakeTimeout:10 * time.Second
+	}
+	httpClient := netutil.NewHttpClientWithConfig(&httpClientCfg)
+}
+```
+
+
+
+### <span id="SendRequest">SendRequest</span>
+<p>Use HttpClient to send HTTP request.</p>
+
+<b>Signature:</b>
+
+```go
+func (client *HttpClient) SendRequest(request *HttpRequest) (*http.Response, error)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+	"net"
+	"time"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+	request := &netutil.HttpRequest{
+		RawURL: "https://jsonplaceholder.typicode.com/todos/1",
+		Method: "GET",
+	}
+
+	httpClient := netutil.NewHttpClient()
+	resp, err := httpClient.SendRequest(request)
+	if err != nil || resp.StatusCode != 200 {
+		log.Fatal(err)
+	}
+
+	type Todo struct {
+		UserId    int    `json:"userId"`
+		Id        int    `json:"id"`
+		Title     string `json:"title"`
+		Completed bool   `json:"completed"`
+	}
+
+	var todo Todo
+	httpClient.DecodeResponse(resp, &todo)
+
+	fmt.Println(todo.Id) //1
+}
+```
+
+
+
+### <span id="DecodeResponse">DecodeResponse</span>
+<p>Decode http response into target object.</p>
+
+<b>Signature:</b>
+
+```go
+func (client *HttpClient) DecodeResponse(resp *http.Response, target any) error
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+	"net"
+	"time"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+	request := &netutil.HttpRequest{
+		RawURL: "https://jsonplaceholder.typicode.com/todos/1",
+		Method: "GET",
+	}
+
+	httpClient := netutil.NewHttpClient()
+	resp, err := httpClient.SendRequest(request)
+	if err != nil || resp.StatusCode != 200 {
+		log.Fatal(err)
+	}
+
+	type Todo struct {
+		UserId    int    `json:"userId"`
+		Id        int    `json:"id"`
+		Title     string `json:"title"`
+		Completed bool   `json:"completed"`
+	}
+
+	var todo Todo
+	httpClient.DecodeResponse(resp, &todo)
+
+	fmt.Println(todo.Id) //1
+}
+```
+
+
+### <span id="StructToUrlValues">StructToUrlValues</span>
+<p>Convert struct to url values, only convert the field which is exported and has `json` tag.</p>
+
+<b>Signature:</b>
+
+```go
+func StructToUrlValues(targetStruct any) url.Values
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+	type TodoQuery struct {
+		Id     int `json:"id"`
+		UserId int `json:"userId"`
+	}
+	todoQuery := TodoQuery{
+		Id:     1,
+		UserId: 2,
+	}
+	todoValues := netutil.StructToUrlValues(todoQuery)
+
+	fmt.Println(todoValues.Get("id")) //1
+	fmt.Println(todoValues.Get("userId")) //2
+}
+```
+
+
+
+### <span id="HttpGet">HttpGet (Deprecated: use SendRequest for replacement)</span>
 <p>Send http get request.</p>
 
 <b>Signature:</b>
 
 ```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]string,
 // 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 +589,7 @@ import (
     "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -272,17 +610,17 @@ func main() {
 
 
 
-### <span id="HttpPost">HttpPost</span>
+### <span id="HttpPost">HttpPost (Deprecated: use SendRequest for replacement)</span>
 <p>Send http post request.</p>
 
 <b>Signature:</b>
 
 ```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]string,
 // 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 +632,7 @@ import (
     "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -321,17 +659,17 @@ func main() {
 
 
 
-### <span id="HttpPut">HttpPut</span>
+### <span id="HttpPut">HttpPut (Deprecated: use SendRequest for replacement)</span>
 <p>Send http put request.</p>
 
 <b>Signature:</b>
 
 ```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]string,
 // 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 +681,7 @@ import (
     "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -371,17 +709,17 @@ func main() {
 
 
 
-### <span id="HttpDelete">HttpDelete</span>
+### <span id="HttpDelete">HttpDelete (Deprecated: use SendRequest for replacement)</span>
 <p>Send http delete request.</p>
 
 <b>Signature:</b>
 
 ```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]string,
 // 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 +731,7 @@ import (
     "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -410,17 +748,17 @@ func main() {
 
 
 
-### <span id="HttpPatch">HttpPatch</span>
+### <span id="HttpPatch">HttpPatch (Deprecated: use SendRequest for replacement)</span>
 <p>Send http patch request.</p>
 
 <b>Signature:</b>
 
 ```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]string,
 // 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 +770,7 @@ import (
     "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -466,7 +804,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 +816,7 @@ import (
     "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {

docs/netutil_zh-CN.md

@@ -5,16 +5,18 @@ 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/net.go](https://github.com/duke-git/lancet/blob/main/netutil/net.go)
+  
+- [https://github.com/duke-git/lancet/blob/main/netutil/http_client.go](https://github.com/duke-git/lancet/blob/main/netutil/http_client.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>
 
 ## 用法:
 ```go
 import (
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 ```
 
@@ -22,17 +24,27 @@ import (
 
 ## 目录
 - [ConvertMapToQueryString](#ConvertMapToQueryString)
+- [EncodeUrl](#EncodeUrl)
 - [GetInternalIp](#GetInternalIp)
 - [GetIps](#GetIps)
 - [GetMacAddrs](#GetMacAddrs)
 - [GetPublicIpInfo](#GetPublicIpInfo)
-- [IsPublicIP](#IsPublicIP)
-- [HttpGet](#HttpGet)
-- [HttpDelete](#HttpDelete)
-- [HttpPost](#HttpPost)
-- [HttpPut](#HttpPut)
+- [GetRequestPublicIp](#GetRequestPublicIp)
+
+- [IsPublicIP](#IsPublicIP)
+- [IsInternalIP](#IsInternalIP)
+- [HttpRequest](#HttpRequest)
+- [HttpClient](#HttpClient)
+- [SendRequest](#SendRequest)
+- [DecodeResponse](#DecodeResponse)
+- [StructToUrlValues](#StructToUrlValues)
+
+- [HttpGet<sup>Deprecated</sup>](#HttpGet)
+- [HttpDelete<sup>Deprecated</sup>](#HttpDelete)
+- [HttpPost<sup>Deprecated</sup>](#HttpPost)
+- [HttpPut<sup>Deprecated</sup>](#HttpPut)
+- [HttpPatch<sup>Deprecated</sup>](#HttpPatch)
 
-- [HttpPatch](#HttpPatch)
 - [ParseHttpResponse](#ParseHttpResponse)
 
 <div STYLE="page-break-after: always;"></div>
@@ -46,7 +58,7 @@ import (
 <b>函数签名:</b>
 
 ```go
-func ConvertMapToQueryString(param map[string]interface{}) string
+func ConvertMapToQueryString(param map[string]any) string
 ```
 <b>例子:</b>
 
@@ -55,11 +67,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,
@@ -72,6 +84,37 @@ func main() {
 
 
 
+### <span id="EncodeUrl">EncodeUrl</span>
+<p>编码url query string的值</p>
+
+<b>函数签名:</b>
+
+```go
+func EncodeUrl(urlStr string) (string, error)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+	urlAddr := "http://www.lancet.com?a=1&b=[2]"
+	encodedUrl, err := netutil.EncodeUrl(urlAddr)
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(encodedUrl) //http://www.lancet.com?a=1&b=%5B2%5D
+}
+```
+
+
+
+
 ### <span id="GetInternalIp">GetInternalIp</span>
 <p>获取内部ip</p>
 
@@ -88,7 +131,7 @@ package main
 import (
     "fmt"
 	"net"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -116,7 +159,7 @@ package main
 import (
     "fmt"
 	"net"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -143,7 +186,7 @@ package main
 import (
     "fmt"
 	"net"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -183,7 +226,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -198,6 +241,50 @@ func main() {
 
 
 
+### <span id="GetRequestPublicIp">GetRequestPublicIp</span>
+<p>获取http请求ip</p>
+
+<b>函数签名:</b>
+
+```go
+func GetRequestPublicIp(req *http.Request) string
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+	ip := "36.112.24.10"
+
+	request1 := http.Request{
+		Method: "GET",
+		Header: http.Header{
+			"X-Forwarded-For": {ip},
+		},
+	}
+	publicIp1 := netutil.GetRequestPublicIp(&request1)
+	fmt.Println(publicIp1) //36.112.24.10
+
+	request2 := http.Request{
+		Method: "GET",
+		Header: http.Header{
+			"X-Real-Ip": {ip},
+		},
+	}
+	publicIp2 := netutil.GetRequestPublicIp(&request2)
+	fmt.Println(publicIp2) //36.112.24.10
+}
+```
+
+
+
+
 ### <span id="IsPublicIP">IsPublicIP</span>
 <p>判断ip是否是公共ip</p>
 
@@ -214,7 +301,7 @@ package main
 import (
     "fmt"
 	"net"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -228,18 +315,271 @@ func main() {
 
 
 
+### <span id="IsInternalIP">IsInternalIP</span>
+<p>判断ip是否是局域网ip.</p>
 
-### <span id="HttpGet">HttpGet</span>
+<b>函数签名:</b>
+
+```go
+func IsInternalIP(IP net.IP) bool
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+	"net"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+	ip1 := net.ParseIP("127.0.0.1")
+	ip2 := net.ParseIP("36.112.24.10")
+
+	fmt.Println(netutil.IsInternalIP(ip1)) //true
+	fmt.Println(netutil.IsInternalIP(ip2)) //false
+}
+```
+
+
+### <span id="HttpRequest">HttpRequest</span>
+<p>HttpRequest用于抽象HTTP请求实体的结构</p>
+
+<b>函数签名:</b>
+
+```go
+type HttpRequest struct {
+	RawURL      string
+	Method      string
+	Headers     http.Header
+	QueryParams url.Values
+	FormData    url.Values
+	Body        []byte
+}
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+	"net"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+	header := http.Header{}
+	header.Add("Content-Type", "multipart/form-data")
+
+	postData := url.Values{}
+	postData.Add("userId", "1")
+	postData.Add("title", "testItem")
+
+	request := &netutil.HttpRequest{
+		RawURL:   "https://jsonplaceholder.typicode.com/todos",
+		Method:   "POST",
+		Headers:  header,
+		FormData: postData,
+	}
+}
+```
+
+
+### <span id="HttpClient">HttpClient</span>
+<p>HttpClient是用于发送HTTP请求的结构体。它可以用一些配置参数或无配置实例化.</p>
+
+<b>函数签名:</b>
+
+```go
+type HttpClient struct {
+	*http.Client
+	TLS     *tls.Config
+	Request *http.Request
+	Config  HttpClientConfig
+}
+
+type HttpClientConfig struct {
+	SSLEnabled       bool
+	TLSConfig        *tls.Config
+	Compressed       bool
+	HandshakeTimeout time.Duration
+	ResponseTimeout  time.Duration
+	Verbose          bool
+}
+
+func NewHttpClient() *HttpClient
+
+func NewHttpClientWithConfig(config *HttpClientConfig) *HttpClient
+
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+	"net"
+	"time"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+	httpClientCfg := netutil.HttpClientConfig{
+		SSLEnabled: true,
+		HandshakeTimeout:10 * time.Second
+	}
+	httpClient := netutil.NewHttpClientWithConfig(&httpClientCfg)
+}
+```
+
+
+
+### <span id="SendRequest">SendRequest</span>
+<p>HttpClient发送http请求</p>
+
+<b>函数签名:</b>
+
+```go
+func (client *HttpClient) SendRequest(request *HttpRequest) (*http.Response, error)
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+	"net"
+	"time"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+	request := &netutil.HttpRequest{
+		RawURL: "https://jsonplaceholder.typicode.com/todos/1",
+		Method: "GET",
+	}
+
+	httpClient := netutil.NewHttpClient()
+	resp, err := httpClient.SendRequest(request)
+	if err != nil || resp.StatusCode != 200 {
+		log.Fatal(err)
+	}
+
+	type Todo struct {
+		UserId    int    `json:"userId"`
+		Id        int    `json:"id"`
+		Title     string `json:"title"`
+		Completed bool   `json:"completed"`
+	}
+
+	var todo Todo
+	httpClient.DecodeResponse(resp, &todo)
+
+	fmt.Println(todo.Id) //1
+}
+```
+
+
+
+### <span id="DecodeResponse">DecodeResponse</span>
+<p>解析http响应体到目标结构体</p>
+
+<b>函数签名:</b>
+
+```go
+func (client *HttpClient) DecodeResponse(resp *http.Response, target any) error
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+	"net"
+	"time"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+	request := &netutil.HttpRequest{
+		RawURL: "https://jsonplaceholder.typicode.com/todos/1",
+		Method: "GET",
+	}
+
+	httpClient := netutil.NewHttpClient()
+	resp, err := httpClient.SendRequest(request)
+	if err != nil || resp.StatusCode != 200 {
+		log.Fatal(err)
+	}
+
+	type Todo struct {
+		UserId    int    `json:"userId"`
+		Id        int    `json:"id"`
+		Title     string `json:"title"`
+		Completed bool   `json:"completed"`
+	}
+
+	var todo Todo
+	httpClient.DecodeResponse(resp, &todo)
+
+	fmt.Println(todo.Id) //1
+}
+```
+
+
+### <span id="StructToUrlValues">StructToUrlValues</span>
+<p>将结构体转为url values, 仅转化结构体导出字段并且包含`json` tag.</p>
+
+<b>函数签名:</b>
+
+```go
+func StructToUrlValues(targetStruct any) url.Values
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/netutil"
+)
+
+func main() {
+	type TodoQuery struct {
+		Id     int `json:"id"`
+		UserId int `json:"userId"`
+	}
+	todoQuery := TodoQuery{
+		Id:     1,
+		UserId: 2,
+	}
+	todoValues := netutil.StructToUrlValues(todoQuery)
+
+	fmt.Println(todoValues.Get("id")) //1
+	fmt.Println(todoValues.Get("userId")) //2
+}
+```
+
+
+
+### <span id="HttpGet">HttpGet (Deprecated: use SendRequest for replacement)</span>
 <p>发送http get请求</p>
 
 <b>函数签名:</b>
 
 ```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]string
 // 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 +590,7 @@ import (
     "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -271,17 +611,17 @@ func main() {
 
 
 
-### <span id="HttpPost">HttpPost</span>
+### <span id="HttpPost">HttpPost (Deprecated: use SendRequest for replacement)</span>
 <p>发送http post请求</p>
 
 <b>函数签名:</b>
 
 ```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]string
 // 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 +633,7 @@ import (
     "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -320,19 +660,19 @@ func main() {
 
 
 
-### <span id="HttpPut">HttpPut</span>
+### <span id="HttpPut">HttpPut (Deprecated: use SendRequest for replacement)</span>
 <p>发送http put请求</p>
 
 <b>函数签名:</b>
 
 ```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]string
 // 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>
+<b>例子:</b>
 
 ```go
 package main
@@ -342,7 +682,7 @@ import (
     "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -370,17 +710,17 @@ func main() {
 
 
 
-### <span id="HttpDelete">HttpDelete</span>
+### <span id="HttpDelete">HttpDelete (Deprecated: use SendRequest for replacement)</span>
 <p>发送http delete请求</p>
 
 <b>函数签名:</b>
 
 ```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]string
 // 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 +732,7 @@ import (
     "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -409,17 +749,17 @@ func main() {
 
 
 
-### <span id="HttpPatch">HttpPatch</span>
+### <span id="HttpPatch">HttpPatch (Deprecated: use SendRequest for replacement)</span>
 <p>发送http patch请求</p>
 
 <b>函数签名:</b>
 
 ```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]string
 // 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 +771,7 @@ import (
     "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {
@@ -465,7 +805,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 +817,7 @@ import (
     "fmt"
 	"io/ioutil"
 	"log"
-    "github.com/duke-git/lancet/netutil"
+    "github.com/duke-git/lancet/v2/netutil"
 )
 
 func main() {

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() {

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() {

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,13 +92,13 @@ import (
     "fmt"
     "errors"
     "log"
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )
 
 func main() {
     var number int
-    var increaseNumber retry.RetryFunc
-	increaseNumber = func() error {
+
+	increaseNumber := func() error {
 		number++
 		if number == 3 {
 			return nil
@@ -134,11 +134,12 @@ import (
     "fmt"
     "errors"
     "log"
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )
 
 func main() {
     var number int
+
 	increaseNumber := func() error {
 		number++
 		if number == 3 {
@@ -173,7 +174,7 @@ import (
     "fmt"
     "errors"
     "log"
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )
 
 func main() {
@@ -213,7 +214,7 @@ import (
     "fmt"
     "errors"
     "log"
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )
 
 func main() {

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,13 +94,12 @@ import (
     "fmt"
     "errors"
     "log"
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )
 
 func main() {
     var number int
-    var increaseNumber retry.RetryFunc
-	increaseNumber = func() error {
+	increaseNumber := func() error {
 		number++
 		if number == 3 {
 			return nil
@@ -136,7 +135,7 @@ import (
     "fmt"
     "errors"
     "log"
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )
 
 func main() {
@@ -175,7 +174,7 @@ import (
     "fmt"
     "errors"
     "log"
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )
 
 func main() {
@@ -215,7 +214,7 @@ import (
     "fmt"
     "errors"
     "log"
-    "github.com/duke-git/lancet/retry"
+    "github.com/duke-git/lancet/v2/retry"
 )
 
 func main() {