doc: update doc for v2.3.1

* fix(netutil): Add proxy ip to send request

* fix(netutil): Add proxy IP to send request

---------

Co-authored-by: 杨崟 <yangyin@addcn.com>

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+liberapay: Duke_Du
+patreon: DukeDu

.github/workflows/codecov.yml

@@ -3,11 +3,11 @@ on:
   push:
     branches:
       - main
-      # - v2
+      - rc
   pull_request:
     branches:
       - main
-      # - v2
+      - rc
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -17,8 +17,10 @@ jobs:
           fetch-depth: 2
       - uses: actions/setup-go@v2
         with:
-          go-version: "1.18"
+          go-version: "1.20"
       - name: Run coverage
         run: go test -v ./... -coverprofile=coverage.txt -covermode=atomic
+      - name: Run govet
+        run: go vet -v ./...
       - name: Upload coverage to Codecov
         run: bash <(curl -s https://codecov.io/bash)

.gitignore

@@ -6,6 +6,10 @@ fileutil/*.txt
 fileutil/*.zip
 fileutil/*.link
 fileutil/unzip/*
+fileutil/tempdir/*
 slice/testdata/*
 cryptor/*.pem
-test
+test
+docs/node_modules
+docs/.vitepress/cache
+docs/.vitepress/dist

CONTRIBUTING.md

@@ -0,0 +1,37 @@
+# Lancet Contributing Guide
+
+Hi! Thank you for choosing Lancet.
+
+Lancet is a powerful, efficient, and reusable util function library of go. It makes Go dev easier by taking the hassle out of working with concurrency, net, math, slice, string, etc.
+
+We are excited that you are interested in contributing to lancet. Before submitting your contribution though, please make sure to take a moment and read through the following guidelines.
+
+## Issue Guidelines
+
+- Issues are exclusively for bug reports, feature requests and design-related topics. Other questions may be closed directly.
+
+- Before submitting an issue, please check if similar problems have already been issued.
+
+- Please specify which version of Lancet and Go you are using, and provide OS information. [Go Playground](https://go.dev/play/) is recommended to build a live demo so that your issue can be reproduced clearly.
+
+## Pull Request Guidelines
+
+- Fork this repository to your own account. Do not create branches here.
+
+- Commit info should be formatted as `type(scope): info about commit`. eg. `fix(package): [scrollbar] fix xxx bug`.
+
+  1. type: type must be one of [chore, docs, feat, fix, refactor, release, test].
+
+  2. scope: scope must be one of [package, file, internal].
+
+  3. header: header must not be longer than 72 characters.
+
+- Rebase before creating a PR to keep commit history clear.
+
+- Before submitting a PR, please execute the unit test command: `go test -v ./...` to ensure that all unit test tasks should pass.
+
+- Make sure PRs are created to `rc` branch instead of other branch.
+
+- If your PR fixes a bug, please provide a description about the related bug.
+
+- If the PR is for a new feature, make sure to complete the relevant documentation (/lancet/docs/en/api/packages).

CONTRIBUTING.zh-CN.md

@@ -0,0 +1,37 @@
+# Lancet 贡献指南
+
+Hi! 首先感谢你使用 Lancet。
+
+lancet（柳叶刀）是一个功能强大、全面、高效、可复用的go语言工具函数库。它消除了处理并发、网络、数学、切片、字符串等的麻烦，使 Go 开发变得更容易。
+
+Lancet 的成长离不开大家的支持，如果你愿意为 Lancet 贡献代码或提供建议，请阅读以下内容。
+
+## Issue 规范
+
+- issue 仅用于提交 Bug 或 Feature 以及设计相关的内容，其它内容可能会被直接关闭。
+
+- 在提交 issue 之前，请搜索相关内容是否已被提出。
+
+- 请说明 Lancet 和 Go 的版本号，并提供操作系统信息。推荐使用 [Go Playground](https://go.dev/play/) 生成在线 demo，这能够更直观地重现问题。
+
+## Pull Request 规范
+
+- 请先 fork 一份到自己的项目下，不要直接在仓库下建分支。
+
+- commit 信息要以 `type(scope): 描述信息` 的形式填写，例如 `fix(package): [scrollbar] fix xxx bug`。
+
+  1. type: 必须是 chore, docs, feat, fix, refactor, release, test 其中的一个。
+
+  2. scope: 必须是 package, file, internal 其中的一个。
+
+  3. header: 描述信息不要超过 72 个字符。
+
+- 提交 PR 前请 rebase，确保 commit 记录的整洁。
+
+- 提交 PR 前请执行单元测试命令：go test -v ./...，确保所有单元测试任务通过。
+
+- 确保 PR 是提交到 `rc` 分支，而不是其他分支。
+
+- 如果是修复 bug，请在 PR 中给出描述信息。
+
+- 如果PR是新功能，确保完成相关文档(/lancet/docs/api/packages)。

algorithm/search.go

@@ -4,7 +4,7 @@
 // Package algorithm contain some basic algorithm functions. eg. sort, search, list, linklist, stack, queue, tree, graph.
 package algorithm
 
-import "github.com/duke-git/lancet/v2/lancetconstraints"
+import "github.com/duke-git/lancet/v2/constraints"
 
 // Search algorithms see https://github.com/TheAlgorithms/Go/tree/master/search
 
@@ -23,7 +23,7 @@ func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int {
 // BinarySearch return the index of target within a sorted slice, use binary search (recursive call itself).
 // If not found return -1.
 // Play: https://go.dev/play/p/t6MeGiUSN47
-func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int {
+func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator constraints.Comparator) int {
 	if highIndex < lowIndex || len(sortedSlice) == 0 {
 		return -1
 	}
@@ -44,7 +44,7 @@ func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, com
 // BinaryIterativeSearch return the index of target within a sorted slice, use binary search (no recursive).
 // If not found return -1.
 // Play: https://go.dev/play/p/Anozfr8ZLH3
-func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int {
+func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator constraints.Comparator) int {
 	startIndex := lowIndex
 	endIndex := highIndex
 

algorithm/sort.go

@@ -3,24 +3,29 @@
 
 package algorithm
 
-import "github.com/duke-git/lancet/v2/lancetconstraints"
+import "github.com/duke-git/lancet/v2/constraints"
 
 // BubbleSort applys the bubble sort algorithm to sort the collection, will change the original collection data.
 // Play: https://go.dev/play/p/GNdv7Jg2Taj
-func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+func BubbleSort[T any](slice []T, comparator constraints.Comparator) {
 	for i := 0; i < len(slice); i++ {
+		breakTag := false
 		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)
+				breakTag = true
 			}
 		}
+		if !breakTag {
+			break
+		}
 	}
 }
 
 // InsertionSort applys the insertion sort algorithm to sort the collection, will change the original collection data.
 // Play: https://go.dev/play/p/G5LJiWgJJW6
-func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+func InsertionSort[T any](slice []T, comparator constraints.Comparator) {
 	for i := 0; i < len(slice); i++ {
 		for j := i; j > 0; j-- {
 			isPreLessThanCurrent := comparator.Compare(slice[j], slice[j-1]) == -1
@@ -35,7 +40,7 @@ func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator) {
 
 // SelectionSort applys the selection sort algorithm to sort the collection, will change the original collection data.
 // Play: https://go.dev/play/p/oXovbkekayS
-func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+func SelectionSort[T any](slice []T, comparator constraints.Comparator) {
 	for i := 0; i < len(slice); i++ {
 		min := i
 		for j := i + 1; j < len(slice); j++ {
@@ -49,7 +54,7 @@ func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator) {
 
 // ShellSort applys the shell sort algorithm to sort the collection, will change the original collection data.
 // Play: https://go.dev/play/p/3ibkszpJEu3
-func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+func ShellSort[T any](slice []T, comparator constraints.Comparator) {
 	size := len(slice)
 
 	gap := 1
@@ -69,11 +74,11 @@ func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator) {
 
 // QuickSort quick sorting for slice, lowIndex is 0 and highIndex is len(slice)-1.
 // Play: https://go.dev/play/p/7Y7c1Elk3ax
-func QuickSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+func QuickSort[T any](slice []T, comparator constraints.Comparator) {
 	quickSort(slice, 0, len(slice)-1, comparator)
 }
 
-func quickSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) {
+func quickSort[T any](slice []T, lowIndex, highIndex int, comparator constraints.Comparator) {
 	if lowIndex < highIndex {
 		p := partition(slice, lowIndex, highIndex, comparator)
 		quickSort(slice, lowIndex, p-1, comparator)
@@ -82,7 +87,7 @@ func quickSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconst
 }
 
 // partition split slice into two parts
-func partition[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int {
+func partition[T any](slice []T, lowIndex, highIndex int, comparator constraints.Comparator) int {
 	p := slice[highIndex]
 	i := lowIndex
 	for j := lowIndex; j < highIndex; j++ {
@@ -99,7 +104,7 @@ func partition[T any](slice []T, lowIndex, highIndex int, comparator lancetconst
 
 // HeapSort applys the heap sort algorithm to sort the collection, will change the original collection data.
 // Play: https://go.dev/play/p/u6Iwa1VZS_f
-func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+func HeapSort[T any](slice []T, comparator constraints.Comparator) {
 	size := len(slice)
 
 	for i := size/2 - 1; i >= 0; i-- {
@@ -111,7 +116,7 @@ func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator) {
 	}
 }
 
-func sift[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) {
+func sift[T any](slice []T, lowIndex, highIndex int, comparator constraints.Comparator) {
 	i := lowIndex
 	j := 2*i + 1
 
@@ -133,11 +138,11 @@ func sift[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraint
 
 // MergeSort applys the merge sort algorithm to sort the collection, will change the original collection data.
 // Play: https://go.dev/play/p/ydinn9YzUJn
-func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+func MergeSort[T any](slice []T, comparator constraints.Comparator) {
 	mergeSort(slice, 0, len(slice)-1, comparator)
 }
 
-func mergeSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) {
+func mergeSort[T any](slice []T, lowIndex, highIndex int, comparator constraints.Comparator) {
 	if lowIndex < highIndex {
 		mid := (lowIndex + highIndex) / 2
 		mergeSort(slice, lowIndex, mid, comparator)
@@ -146,7 +151,7 @@ func mergeSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconst
 	}
 }
 
-func merge[T any](slice []T, lowIndex, midIndex, highIndex int, comparator lancetconstraints.Comparator) {
+func merge[T any](slice []T, lowIndex, midIndex, highIndex int, comparator constraints.Comparator) {
 	i := lowIndex
 	j := midIndex + 1
 	temp := []T{}
@@ -175,7 +180,7 @@ func merge[T any](slice []T, lowIndex, midIndex, highIndex int, comparator lance
 
 // CountSort applys the count sort algorithm to sort the collection, don't change the original collection data.
 // Play: https://go.dev/play/p/tB-Umgm0DrP
-func CountSort[T any](slice []T, comparator lancetconstraints.Comparator) []T {
+func CountSort[T any](slice []T, comparator constraints.Comparator) []T {
 	size := len(slice)
 	out := make([]T, size)
 

algorithm/sort_test.go

@@ -16,7 +16,7 @@ type people struct {
 // PeopleAageComparator sort people slice by age field
 type peopleAgeComparator struct{}
 
-// Compare implements github.com/duke-git/lancet/v2/lancetconstraints/constraints.go/Comparator
+// Compare implements github.com/duke-git/lancet/v2/constraints/constraints.go/Comparator
 func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
 	p1, _ := v1.(people)
 	p2, _ := v2.(people)

compare/compare.go

@@ -10,6 +10,8 @@ import (
 	"time"
 
 	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/duke-git/lancet/v2/mathutil"
+	"golang.org/x/exp/constraints"
 )
 
 // operator type
@@ -62,3 +64,9 @@ func LessOrEqual(left, right any) bool {
 func GreaterOrEqual(left, right any) bool {
 	return compareValue(greaterOrEqual, left, right)
 }
+
+// InDelta checks if two values are equal or not within a delta.
+// Play: https://go.dev/play/p/TuDdcNtMkjo
+func InDelta[T constraints.Integer | constraints.Float](left, right T, delta float64) bool {
+	return float64(mathutil.Abs(left-right)) <= delta
+}

compare/compare_example_test.go

@@ -168,3 +168,29 @@ func ExampleGreaterOrEqual() {
 	// false
 	// false
 }
+
+func ExampleInDelta() {
+	result1 := InDelta(1, 1, 0)
+	result2 := InDelta(1, 2, 0)
+
+	result3 := InDelta(2.0/3.0, 0.66667, 0.001)
+	result4 := InDelta(2.0/3.0, 0.0, 0.001)
+
+	result5 := InDelta(float64(74.96)-float64(20.48), 54.48, 0)
+	result6 := InDelta(float64(74.96)-float64(20.48), 54.48, 1e-14)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+	fmt.Println(result6)
+
+	// Output:
+	// true
+	// false
+	// true
+	// false
+	// false
+	// true
+}

compare/compare_internal.go

@@ -70,7 +70,7 @@ func compareRefValue(operator string, leftObj, rightObj any, kind reflect.Kind)
 
 			switch operator {
 			case equal:
-				if bytes.Compare(bytesObj1, bytesObj2) == 0 {
+				if bytes.Equal(bytesObj1, bytesObj2) {
 					return true
 				}
 			case lessThan:

compare/compare_test.go

@@ -1,6 +1,7 @@
 package compare
 
 import (
+	"encoding/json"
 	"testing"
 	"time"
 
@@ -11,6 +12,7 @@ func TestEqual(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestEqual")
 
+	// basic type
 	assert.Equal(true, Equal(1, 1))
 	assert.Equal(true, Equal(int64(1), int64(1)))
 	assert.Equal(true, Equal("a", "a"))
@@ -25,6 +27,7 @@ func TestEqual(t *testing.T) {
 	assert.Equal(false, Equal([]int{1, 2}, []int{1, 2, 3}))
 	assert.Equal(false, Equal(map[int]string{1: "a", 2: "b"}, map[int]string{1: "a"}))
 
+	// time
 	time1 := time.Now()
 	time2 := time1.Add(time.Second)
 	time3 := time1.Add(time.Second)
@@ -32,6 +35,7 @@ func TestEqual(t *testing.T) {
 	assert.Equal(false, Equal(time1, time2))
 	assert.Equal(true, Equal(time2, time3))
 
+	// struct
 	st1 := struct {
 		A string
 		B string
@@ -58,6 +62,19 @@ func TestEqual(t *testing.T) {
 
 	assert.Equal(true, Equal(st1, st2))
 	assert.Equal(false, Equal(st1, st3))
+
+	//byte slice
+	bs1 := []byte("hello")
+	bs2 := []byte("hello")
+	assert.Equal(true, Equal(bs1, bs2))
+
+	// json.Number
+	var jsonNumber1, jsonNumber2 json.Number
+	json.Unmarshal([]byte(`123`), &jsonNumber1)
+	json.Unmarshal([]byte(`123`), &jsonNumber2)
+
+	assert.Equal(true, Equal(jsonNumber1, jsonNumber2))
+
 }
 
 func TestEqualValue(t *testing.T) {
@@ -69,6 +86,13 @@ func TestEqualValue(t *testing.T) {
 	assert.Equal(true, EqualValue(1, "1"))
 
 	assert.Equal(false, EqualValue(1, "2"))
+
+	// json.Number
+	var jsonNumber1, jsonNumber2 json.Number
+	json.Unmarshal([]byte(`123`), &jsonNumber1)
+	json.Unmarshal([]byte(`123`), &jsonNumber2)
+
+	assert.Equal(true, EqualValue(jsonNumber1, 123))
 }
 
 func TestLessThan(t *testing.T) {
@@ -85,6 +109,17 @@ func TestLessThan(t *testing.T) {
 
 	assert.Equal(false, LessThan(1, 1))
 	assert.Equal(false, LessThan(1, int64(1)))
+
+	bs1 := []byte("hello1")
+	bs2 := []byte("hello2")
+	assert.Equal(true, LessThan(bs1, bs2))
+
+	// json.Number
+	var jsonNumber1, jsonNumber2 json.Number
+	json.Unmarshal([]byte(`123`), &jsonNumber1)
+	json.Unmarshal([]byte(`124`), &jsonNumber2)
+
+	assert.Equal(true, LessThan(jsonNumber1, jsonNumber2))
 }
 
 func TestGreaterThan(t *testing.T) {
@@ -102,6 +137,17 @@ func TestGreaterThan(t *testing.T) {
 	assert.Equal(false, GreaterThan(1, 2))
 	assert.Equal(false, GreaterThan(int64(2), 1))
 	assert.Equal(false, GreaterThan("b", "c"))
+
+	bs1 := []byte("hello1")
+	bs2 := []byte("hello2")
+	assert.Equal(true, GreaterThan(bs2, bs1))
+
+	// json.Number
+	var jsonNumber1, jsonNumber2 json.Number
+	json.Unmarshal([]byte(`123`), &jsonNumber1)
+	json.Unmarshal([]byte(`124`), &jsonNumber2)
+
+	assert.Equal(true, GreaterThan(jsonNumber2, jsonNumber1))
 }
 
 func TestLessOrEqual(t *testing.T) {
@@ -119,6 +165,17 @@ func TestLessOrEqual(t *testing.T) {
 
 	assert.Equal(false, LessOrEqual(2, 1))
 	assert.Equal(false, LessOrEqual(1, int64(2)))
+
+	bs1 := []byte("hello1")
+	bs2 := []byte("hello2")
+	assert.Equal(true, LessOrEqual(bs1, bs2))
+
+	// json.Number
+	var jsonNumber1, jsonNumber2 json.Number
+	json.Unmarshal([]byte(`123`), &jsonNumber1)
+	json.Unmarshal([]byte(`124`), &jsonNumber2)
+
+	assert.Equal(true, LessOrEqual(jsonNumber1, jsonNumber2))
 }
 
 func TestGreaterOrEqual(t *testing.T) {
@@ -137,4 +194,31 @@ func TestGreaterOrEqual(t *testing.T) {
 	assert.Equal(false, GreaterOrEqual(1, 2))
 	assert.Equal(false, GreaterOrEqual(int64(2), 1))
 	assert.Equal(false, GreaterOrEqual("b", "c"))
+
+	bs1 := []byte("hello1")
+	bs2 := []byte("hello2")
+	assert.Equal(true, GreaterOrEqual(bs2, bs1))
+
+	// json.Number
+	var jsonNumber1, jsonNumber2 json.Number
+	json.Unmarshal([]byte(`123`), &jsonNumber1)
+	json.Unmarshal([]byte(`124`), &jsonNumber2)
+
+	assert.Equal(true, GreaterOrEqual(jsonNumber2, jsonNumber1))
+}
+
+func TestInDelta(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestInDelta")
+
+	assert.Equal(true, InDelta(1, 1, 0))
+	assert.Equal(false, InDelta(1, 2, 0))
+
+	assert.Equal(true, InDelta(2.0/3.0, 0.66667, 0.001))
+	assert.Equal(false, InDelta(2.0/3.0, 0.0, 0.001))
+
+	assert.Equal(false, InDelta(float64(74.96)-float64(20.48), 54.48, 0))
+	assert.Equal(true, InDelta(float64(74.96)-float64(20.48), 54.48, 1e-14))
+	assert.Equal(false, InDelta(float64(float32(80.45)), float64(80.45), 0))
+	assert.Equal(true, InDelta(float64(float32(80.45)), float64(80.45), 1e-5))
 }

constraints/constraints.go

@@ -1,8 +1,8 @@
 // Copyright 2021 dudaodong@gmail.com. All rights reserved.
 // Use of this source code is governed by MIT license
 
-// Package lancetconstraints contain some comstomer constraints.
-package lancetconstraints
+// Package constraints contain some custom interface.
+package constraints
 
 // Comparator is for comparing two values
 type Comparator interface {

convertor/convertor.go

@@ -6,6 +6,7 @@ package convertor
 
 import (
 	"bytes"
+	"encoding/base64"
 	"encoding/binary"
 	"encoding/gob"
 	"encoding/json"
@@ -394,3 +395,91 @@ func GbkToUtf8(bs []byte) ([]byte, error) {
 	b, err := io.ReadAll(r)
 	return b, err
 }
+
+// ToStdBase64 convert data to standard base64 encoding.
+// Play: https://go.dev/play/p/_fLJqJD3NMo
+func ToStdBase64(value any) string {
+	if value == nil || (reflect.ValueOf(value).Kind() == reflect.Ptr && reflect.ValueOf(value).IsNil()) {
+		return ""
+	}
+	switch value.(type) {
+	case []byte:
+		return base64.StdEncoding.EncodeToString(value.([]byte))
+	case string:
+		return base64.StdEncoding.EncodeToString([]byte(value.(string)))
+	case error:
+		return base64.StdEncoding.EncodeToString([]byte(value.(error).Error()))
+	default:
+		marshal, err := json.Marshal(value)
+		if err != nil {
+			return ""
+		}
+		return base64.StdEncoding.EncodeToString(marshal)
+	}
+}
+
+// ToUrlBase64 convert data to URL base64 encoding.
+// Play: https://go.dev/play/p/C_d0GlvEeUR
+func ToUrlBase64(value any) string {
+	if value == nil || (reflect.ValueOf(value).Kind() == reflect.Ptr && reflect.ValueOf(value).IsNil()) {
+		return ""
+	}
+	switch value.(type) {
+	case []byte:
+		return base64.URLEncoding.EncodeToString(value.([]byte))
+	case string:
+		return base64.URLEncoding.EncodeToString([]byte(value.(string)))
+	case error:
+		return base64.URLEncoding.EncodeToString([]byte(value.(error).Error()))
+	default:
+		marshal, err := json.Marshal(value)
+		if err != nil {
+			return ""
+		}
+		return base64.URLEncoding.EncodeToString(marshal)
+	}
+}
+
+// ToRawStdBase64 convert data to raw standard base64 encoding.
+// Play: https://go.dev/play/p/wSAr3sfkDcv
+func ToRawStdBase64(value any) string {
+	if value == nil || (reflect.ValueOf(value).Kind() == reflect.Ptr && reflect.ValueOf(value).IsNil()) {
+		return ""
+	}
+	switch value.(type) {
+	case []byte:
+		return base64.RawStdEncoding.EncodeToString(value.([]byte))
+	case string:
+		return base64.RawStdEncoding.EncodeToString([]byte(value.(string)))
+	case error:
+		return base64.RawStdEncoding.EncodeToString([]byte(value.(error).Error()))
+	default:
+		marshal, err := json.Marshal(value)
+		if err != nil {
+			return ""
+		}
+		return base64.RawStdEncoding.EncodeToString(marshal)
+	}
+}
+
+// ToRawUrlBase64 convert data to raw URL base64 encoding.
+// Play: https://go.dev/play/p/HwdDPFcza1O
+func ToRawUrlBase64(value any) string {
+	if value == nil || (reflect.ValueOf(value).Kind() == reflect.Ptr && reflect.ValueOf(value).IsNil()) {
+		return ""
+	}
+	switch value.(type) {
+	case []byte:
+		return base64.RawURLEncoding.EncodeToString(value.([]byte))
+	case string:
+		return base64.RawURLEncoding.EncodeToString([]byte(value.(string)))
+	case error:
+		return base64.RawURLEncoding.EncodeToString([]byte(value.(error).Error()))
+	default:
+		marshal, err := json.Marshal(value)
+		if err != nil {
+			return ""
+		}
+		return base64.RawURLEncoding.EncodeToString(marshal)
+	}
+}

convertor/convertor_example_test.go

@@ -1,6 +1,7 @@
 package convertor
 
 import (
+	"errors"
 	"fmt"
 	"reflect"
 	"strconv"
@@ -391,3 +392,182 @@ func ExampleGbkToUtf8() {
 	// true
 	// hello
 }
+
+func ExampleToStdBase64() {
+	// if you want to see the result, please use 'base64.StdEncoding.DecodeString()' to decode the result
+
+	afterEncode := ToStdBase64(nil)
+	fmt.Println(afterEncode)
+
+	stringVal := "hello"
+	afterEncode = ToStdBase64(stringVal)
+	fmt.Println(afterEncode)
+
+	byteSliceVal := []byte("hello")
+	afterEncode = ToStdBase64(byteSliceVal)
+	fmt.Println(afterEncode)
+
+	intVal := 123
+	afterEncode = ToStdBase64(intVal)
+	fmt.Println(afterEncode)
+
+	mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+		A string
+		B int
+	}{"hello", 3}}
+	afterEncode = ToStdBase64(mapVal)
+	fmt.Println(afterEncode)
+
+	floatVal := 123.456
+	afterEncode = ToStdBase64(floatVal)
+	fmt.Println(afterEncode)
+
+	boolVal := true
+	afterEncode = ToStdBase64(boolVal)
+	fmt.Println(afterEncode)
+
+	errVal := errors.New("err")
+	afterEncode = ToStdBase64(errVal)
+	fmt.Println(afterEncode)
+
+	// Output:
+	//
+	// aGVsbG8=
+	// aGVsbG8=
+	// MTIz
+	// eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ==
+	// MTIzLjQ1Ng==
+	// dHJ1ZQ==
+	// ZXJy
+}
+
+func ExampleToUrlBase64() {
+	// if you want to see the result, please use 'base64.URLEncoding.DecodeString()' to decode the result
+
+	stringVal := "hello"
+	afterEncode := ToUrlBase64(stringVal)
+	fmt.Println(afterEncode)
+
+	byteSliceVal := []byte("hello")
+	afterEncode = ToUrlBase64(byteSliceVal)
+	fmt.Println(afterEncode)
+
+	intVal := 123
+	afterEncode = ToUrlBase64(intVal)
+	fmt.Println(afterEncode)
+
+	mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+		A string
+		B int
+	}{"hello", 3}}
+	afterEncode = ToUrlBase64(mapVal)
+	fmt.Println(afterEncode)
+
+	floatVal := 123.456
+	afterEncode = ToUrlBase64(floatVal)
+	fmt.Println(afterEncode)
+
+	boolVal := true
+	afterEncode = ToUrlBase64(boolVal)
+	fmt.Println(afterEncode)
+
+	errVal := errors.New("err")
+	afterEncode = ToUrlBase64(errVal)
+	fmt.Println(afterEncode)
+
+	// Output:
+	// aGVsbG8=
+	// aGVsbG8=
+	// MTIz
+	// eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ==
+	// MTIzLjQ1Ng==
+	// dHJ1ZQ==
+	// ZXJy
+}
+
+func ExampleToRawStdBase64() {
+	// if you want to see the result, please use 'base64.RawStdEncoding.DecodeString()' to decode the result
+	stringVal := "hello"
+	afterEncode := ToRawStdBase64(stringVal)
+	fmt.Println(afterEncode)
+
+	byteSliceVal := []byte("hello")
+	afterEncode = ToRawStdBase64(byteSliceVal)
+	fmt.Println(afterEncode)
+
+	intVal := 123
+	afterEncode = ToRawStdBase64(intVal)
+	fmt.Println(afterEncode)
+
+	mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+		A string
+		B int
+	}{"hello", 3}}
+	afterEncode = ToRawStdBase64(mapVal)
+	fmt.Println(afterEncode)
+
+	floatVal := 123.456
+	afterEncode = ToRawStdBase64(floatVal)
+	fmt.Println(afterEncode)
+
+	boolVal := true
+	afterEncode = ToRawStdBase64(boolVal)
+	fmt.Println(afterEncode)
+
+	errVal := errors.New("err")
+	afterEncode = ToRawStdBase64(errVal)
+	fmt.Println(afterEncode)
+
+	// Output:
+	// aGVsbG8
+	// aGVsbG8
+	// MTIz
+	// eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ
+	// MTIzLjQ1Ng
+	// dHJ1ZQ
+	// ZXJy
+}
+
+func ExampleToRawUrlBase64() {
+	// if you want to see the result, please use 'base64.RawURLEncoding.DecodeString()' to decode the result
+
+	stringVal := "hello"
+	afterEncode := ToRawUrlBase64(stringVal)
+	fmt.Println(afterEncode)
+
+	byteSliceVal := []byte("hello")
+	afterEncode = ToRawUrlBase64(byteSliceVal)
+	fmt.Println(afterEncode)
+
+	intVal := 123
+	afterEncode = ToRawUrlBase64(intVal)
+	fmt.Println(afterEncode)
+
+	mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+		A string
+		B int
+	}{"hello", 3}}
+	afterEncode = ToRawUrlBase64(mapVal)
+	fmt.Println(afterEncode)
+
+	floatVal := 123.456
+	afterEncode = ToRawUrlBase64(floatVal)
+	fmt.Println(afterEncode)
+
+	boolVal := true
+	afterEncode = ToRawUrlBase64(boolVal)
+	fmt.Println(afterEncode)
+
+	errVal := errors.New("err")
+	afterEncode = ToRawUrlBase64(errVal)
+	fmt.Println(afterEncode)
+
+	// Output:
+	// aGVsbG8
+	// aGVsbG8
+	// MTIz
+	// eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ
+	// MTIzLjQ1Ng
+	// dHJ1ZQ
+	// ZXJy
+}

convertor/convertor_internal.go

@@ -99,7 +99,7 @@ func (c *cloner) cloneArray(v reflect.Value) reflect.Value {
 	for i := 0; i < v.Len(); i++ {
 		val := c.clone(v.Index(i))
 
-		if val.IsValid() {
+		if !val.IsValid() {
 			continue
 		}
 

convertor/convertor_test.go

@@ -1,11 +1,15 @@
 package convertor
 
 import (
+	"encoding/base64"
+	"errors"
 	"fmt"
+	"io"
 	"reflect"
 	"strconv"
 	"testing"
 	"unicode/utf8"
+	"unsafe"
 
 	"github.com/duke-git/lancet/v2/internal"
 	"github.com/duke-git/lancet/v2/slice"
@@ -337,6 +341,7 @@ func TestDeepClone(t *testing.T) {
 			Nil:   nil,
 			// unexported: "can't be cloned",
 		},
+		[]interface{}{1, &Struct{Str: "test"}, Struct{Str: "test2"}},
 	}
 
 	for i, item := range cases {
@@ -460,3 +465,279 @@ func TestGbkToUtf8(t *testing.T) {
 	assert.Equal(true, utf8.Valid(utf8Data))
 	assert.Equal("hello", string(utf8Data))
 }
+
+func TestToStdBase64(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestToStdBase64")
+
+	r1 := ToStdBase64("abc")
+	d1, _ := base64.StdEncoding.DecodeString(r1)
+	assert.Equal("abc", string(d1))
+
+	r2 := ToStdBase64([]byte("abc"))
+	d2, _ := base64.StdEncoding.DecodeString(r2)
+	assert.Equal("abc", string(d2))
+
+	r3 := ToStdBase64(123)
+	d3, _ := base64.StdEncoding.DecodeString(r3)
+	assert.Equal("123", string(d3))
+
+	r4 := ToStdBase64(11.11)
+	d4, _ := base64.StdEncoding.DecodeString(r4)
+	assert.Equal("11.11", string(d4))
+
+	r5 := ToStdBase64(map[string]any{"name": "duke", "quantity": 1})
+	d5, _ := base64.StdEncoding.DecodeString(r5)
+	assert.Equal("{\"name\":\"duke\",\"quantity\":1}", string(d5))
+
+	r6 := ToStdBase64([]int64{7, 5, 9, 4, 23})
+	d6, _ := base64.StdEncoding.DecodeString(r6)
+	assert.Equal("[7,5,9,4,23]", string(d6))
+
+	r7 := ToStdBase64([]string{"7", "5", "9", "4", "23"})
+	d7, _ := base64.StdEncoding.DecodeString(r7)
+	assert.Equal("[\"7\",\"5\",\"9\",\"4\",\"23\"]", string(d7))
+
+	r8 := ToStdBase64(nil)
+	d8, _ := base64.StdEncoding.DecodeString(r8)
+	assert.Equal("", string(d8))
+
+	ch := make(chan int, 3)
+	ch <- 1
+	ch <- 2
+	r9 := ToStdBase64(ch)
+	d9, _ := base64.StdEncoding.DecodeString(r9)
+	assert.Equal("", string(d9))
+
+	r10 := ToStdBase64(io.EOF)
+	d10, _ := base64.StdEncoding.DecodeString(r10)
+	assert.Equal("EOF", string(d10))
+
+	r11 := ToStdBase64(errors.New("test"))
+	d11, _ := base64.StdEncoding.DecodeString(r11)
+	assert.Equal("test", string(d11))
+
+	typedNil := (*int)(nil)
+	r12 := ToStdBase64(typedNil)
+	d12, _ := base64.StdEncoding.DecodeString(r12)
+	assert.Equal("", string(d12))
+
+	type nilInterface interface {
+	}
+	var nI nilInterface = nil
+	d13, _ := base64.StdEncoding.DecodeString(ToStdBase64(nI))
+	assert.Equal("", string(d13))
+
+	var p unsafe.Pointer
+	d14, _ := base64.StdEncoding.DecodeString(ToStdBase64(p))
+	assert.Equal("", string(d14))
+}
+
+func TestToUrlBase64(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestToUrlBase64")
+
+	r1 := ToUrlBase64("abc")
+	d1, _ := base64.URLEncoding.DecodeString(r1)
+	assert.Equal("abc", string(d1))
+
+	r2 := ToUrlBase64([]byte("abc"))
+	d2, _ := base64.URLEncoding.DecodeString(r2)
+	assert.Equal("abc", string(d2))
+
+	r3 := ToUrlBase64(123)
+	d3, _ := base64.URLEncoding.DecodeString(r3)
+	assert.Equal("123", string(d3))
+
+	r4 := ToUrlBase64(11.11)
+	d4, _ := base64.URLEncoding.DecodeString(r4)
+	assert.Equal("11.11", string(d4))
+
+	r5 := ToUrlBase64(map[string]any{"name": "duke", "quantity": 1})
+	d5, _ := base64.URLEncoding.DecodeString(r5)
+	assert.Equal("{\"name\":\"duke\",\"quantity\":1}", string(d5))
+
+	r6 := ToUrlBase64([]int64{7, 5, 9, 4, 23})
+	d6, _ := base64.URLEncoding.DecodeString(r6)
+	assert.Equal("[7,5,9,4,23]", string(d6))
+
+	r7 := ToUrlBase64([]string{"7", "5", "9", "4", "23"})
+	d7, _ := base64.URLEncoding.DecodeString(r7)
+	assert.Equal("[\"7\",\"5\",\"9\",\"4\",\"23\"]", string(d7))
+
+	r8 := ToUrlBase64(nil)
+	d8, _ := base64.URLEncoding.DecodeString(r8)
+	assert.Equal("", string(d8))
+
+	ch := make(chan int, 3)
+	ch <- 1
+	ch <- 2
+	r9 := ToUrlBase64(ch)
+	d9, _ := base64.URLEncoding.DecodeString(r9)
+	assert.Equal("", string(d9))
+
+	r10 := ToUrlBase64(io.EOF)
+	d10, _ := base64.URLEncoding.DecodeString(r10)
+	assert.Equal("EOF", string(d10))
+
+	r11 := ToUrlBase64(errors.New("test"))
+	d11, _ := base64.URLEncoding.DecodeString(r11)
+	assert.Equal("test", string(d11))
+
+	typedNil := (*int)(nil)
+	r12 := ToUrlBase64(typedNil)
+	d12, _ := base64.URLEncoding.DecodeString(r12)
+	assert.Equal("", string(d12))
+
+	type nilInterface interface {
+	}
+	var nI nilInterface = nil
+	d13, _ := base64.URLEncoding.DecodeString(ToUrlBase64(nI))
+	assert.Equal("", string(d13))
+
+	var p unsafe.Pointer
+	d14, _ := base64.URLEncoding.DecodeString(ToUrlBase64(p))
+	assert.Equal("", string(d14))
+
+	r15 := ToUrlBase64("4+3/4?=")
+	d15, _ := base64.URLEncoding.DecodeString(r15)
+	assert.Equal("4+3/4?=", string(d15))
+}
+
+func TestToRawStdBase64(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestToRawStdBase64")
+
+	r1 := ToRawStdBase64("abc")
+	d1, _ := base64.RawStdEncoding.DecodeString(r1)
+	assert.Equal("abc", string(d1))
+
+	r2 := ToRawStdBase64([]byte("abc"))
+	d2, _ := base64.RawStdEncoding.DecodeString(r2)
+	assert.Equal("abc", string(d2))
+
+	r3 := ToRawStdBase64(123)
+	d3, _ := base64.RawStdEncoding.DecodeString(r3)
+	assert.Equal("123", string(d3))
+
+	r4 := ToRawStdBase64(11.11)
+	d4, _ := base64.RawStdEncoding.DecodeString(r4)
+	assert.Equal("11.11", string(d4))
+
+	r5 := ToRawStdBase64(map[string]any{"name": "duke", "quantity": 1})
+	d5, _ := base64.RawStdEncoding.DecodeString(r5)
+	assert.Equal("{\"name\":\"duke\",\"quantity\":1}", string(d5))
+
+	r6 := ToRawStdBase64([]int64{7, 5, 9, 4, 23})
+	d6, _ := base64.RawStdEncoding.DecodeString(r6)
+	assert.Equal("[7,5,9,4,23]", string(d6))
+
+	r7 := ToRawStdBase64([]string{"7", "5", "9", "4", "23"})
+	d7, _ := base64.RawStdEncoding.DecodeString(r7)
+	assert.Equal("[\"7\",\"5\",\"9\",\"4\",\"23\"]", string(d7))
+
+	r8 := ToRawStdBase64(nil)
+	d8, _ := base64.RawStdEncoding.DecodeString(r8)
+	assert.Equal("", string(d8))
+
+	ch := make(chan int, 3)
+	ch <- 1
+	ch <- 2
+	r9 := ToRawStdBase64(ch)
+	d9, _ := base64.RawStdEncoding.DecodeString(r9)
+	assert.Equal("", string(d9))
+
+	r10 := ToRawStdBase64(io.EOF)
+	d10, _ := base64.RawStdEncoding.DecodeString(r10)
+	assert.Equal("EOF", string(d10))
+
+	r11 := ToRawStdBase64(errors.New("test"))
+	d11, _ := base64.RawStdEncoding.DecodeString(r11)
+	assert.Equal("test", string(d11))
+
+	typedNil := (*int)(nil)
+	r12 := ToRawStdBase64(typedNil)
+	d12, _ := base64.RawStdEncoding.DecodeString(r12)
+	assert.Equal("", string(d12))
+
+	type nilInterface interface {
+	}
+	var nI nilInterface = nil
+	d13, _ := base64.RawStdEncoding.DecodeString(ToRawStdBase64(nI))
+	assert.Equal("", string(d13))
+
+	var p unsafe.Pointer
+	d14, _ := base64.RawStdEncoding.DecodeString(ToRawStdBase64(p))
+	assert.Equal("", string(d14))
+}
+
+func TestToRawUrlBase64(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestToRawUrlBase64")
+
+	r1 := ToRawUrlBase64("abc")
+	d1, _ := base64.RawURLEncoding.DecodeString(r1)
+	assert.Equal("abc", string(d1))
+
+	r2 := ToRawUrlBase64([]byte("abc"))
+	d2, _ := base64.RawURLEncoding.DecodeString(r2)
+	assert.Equal("abc", string(d2))
+
+	r3 := ToRawUrlBase64(123)
+	d3, _ := base64.RawURLEncoding.DecodeString(r3)
+	assert.Equal("123", string(d3))
+
+	r4 := ToRawUrlBase64(11.11)
+	d4, _ := base64.RawURLEncoding.DecodeString(r4)
+	assert.Equal("11.11", string(d4))
+
+	r5 := ToRawUrlBase64(map[string]any{"name": "duke", "quantity": 1})
+	d5, _ := base64.RawURLEncoding.DecodeString(r5)
+	assert.Equal("{\"name\":\"duke\",\"quantity\":1}", string(d5))
+
+	r6 := ToRawUrlBase64([]int64{7, 5, 9, 4, 23})
+	d6, _ := base64.RawURLEncoding.DecodeString(r6)
+	assert.Equal("[7,5,9,4,23]", string(d6))
+
+	r7 := ToRawUrlBase64([]string{"7", "5", "9", "4", "23"})
+	d7, _ := base64.RawURLEncoding.DecodeString(r7)
+	assert.Equal("[\"7\",\"5\",\"9\",\"4\",\"23\"]", string(d7))
+
+	r8 := ToRawUrlBase64(nil)
+	d8, _ := base64.RawURLEncoding.DecodeString(r8)
+	assert.Equal("", string(d8))
+
+	ch := make(chan int, 3)
+	ch <- 1
+	ch <- 2
+	r9 := ToRawUrlBase64(ch)
+	d9, _ := base64.RawURLEncoding.DecodeString(r9)
+	assert.Equal("", string(d9))
+
+	r10 := ToRawUrlBase64(io.EOF)
+	d10, _ := base64.RawURLEncoding.DecodeString(r10)
+	assert.Equal("EOF", string(d10))
+
+	r11 := ToRawUrlBase64(errors.New("test"))
+	d11, _ := base64.RawURLEncoding.DecodeString(r11)
+	assert.Equal("test", string(d11))
+
+	typedNil := (*int)(nil)
+	r12 := ToRawUrlBase64(typedNil)
+	d12, _ := base64.RawURLEncoding.DecodeString(r12)
+	assert.Equal("", string(d12))
+
+	type nilInterface interface {
+	}
+	var nI nilInterface = nil
+	d13, _ := base64.RawURLEncoding.DecodeString(ToRawUrlBase64(nI))
+	assert.Equal("", string(d13))
+
+	var p unsafe.Pointer
+	d14, _ := base64.RawURLEncoding.DecodeString(ToRawUrlBase64(p))
+	assert.Equal("", string(d14))
+
+	r15 := ToRawUrlBase64("4+3/4?=")
+	d15, _ := base64.RawURLEncoding.DecodeString(r15)
+	assert.Equal("4+3/4?=", string(d15))
+}

cryptor/basic.go

@@ -57,7 +57,7 @@ func Md5Byte(data []byte) string {
 }
 
 // Md5ByteWithBase64 return the md5 string of byte slice with base64.
-// Play: https://go.dev/play/p/CkN9hYKGeAy
+// Play: https://go.dev/play/p/Tcb-Z7LN2ax
 func Md5ByteWithBase64(data []byte) string {
 	h := md5.New()
 	h.Write(data)
@@ -105,7 +105,7 @@ func HmacMd5(str, key string) string {
 }
 
 // HmacMd5WithBase64 return the hmac hash of string use md5 with base64.
-// todo
+// https://go.dev/play/p/UY0ng2AefFC
 func HmacMd5WithBase64(data, key string) string {
 	h := hmac.New(md5.New, []byte(key))
 	h.Write([]byte(data))
@@ -153,7 +153,7 @@ func HmacSha512(str, key string) string {
 }
 
 // HmacSha512WithBase64 return the hmac hash of string use sha512 with base64.
-// Play: https://go.dev/play/p/61wBBOKO-GH
+// Play: https://go.dev/play/p/c6dSe3E2ydU
 func HmacSha512WithBase64(str, key string) string {
 	h := hmac.New(sha512.New, []byte(key))
 	h.Write([]byte(str))
@@ -169,7 +169,7 @@ func Sha1(str string) string {
 }
 
 // Sha1WithBase64 return the sha1 value (SHA-1 hash algorithm) of base64 string.
-// Play: todo
+// Play: https://go.dev/play/p/fSyx-Gl2l2-
 func Sha1WithBase64(str string) string {
 	sha1 := sha1.New()
 	sha1.Write([]byte(str))

cryptor/crypto.go

@@ -13,6 +13,7 @@ import (
 	"crypto/des"
 	"crypto/rand"
 	"crypto/rsa"
+	"crypto/sha256"
 	"crypto/x509"
 	"encoding/pem"
 	"io"
@@ -75,6 +76,11 @@ func AesEcbDecrypt(encrypted, key []byte) []byte {
 // len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/IOq_g8_lKZD
 func AesCbcEncrypt(data, key []byte) []byte {
+	size := len(key)
+	if size != 16 && size != 24 && size != 32 {
+		panic("key length shoud be 16 or 24 or 32")
+	}
+
 	block, _ := aes.NewCipher(key)
 	data = pkcs7Padding(data, block.BlockSize())
 
@@ -94,6 +100,11 @@ func AesCbcEncrypt(data, key []byte) []byte {
 // len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/IOq_g8_lKZD
 func AesCbcDecrypt(encrypted, key []byte) []byte {
+	size := len(key)
+	if size != 16 && size != 24 && size != 32 {
+		panic("key length shoud be 16 or 24 or 32")
+	}
+
 	block, _ := aes.NewCipher(key)
 
 	iv := encrypted[:aes.BlockSize]
@@ -110,6 +121,11 @@ func AesCbcDecrypt(encrypted, key []byte) []byte {
 // len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/SpaZO0-5Nsp
 func AesCtrCrypt(data, key []byte) []byte {
+	size := len(key)
+	if size != 16 && size != 24 && size != 32 {
+		panic("key length shoud be 16 or 24 or 32")
+	}
+
 	block, _ := aes.NewCipher(key)
 
 	iv := bytes.Repeat([]byte("1"), block.BlockSize())
@@ -125,6 +141,11 @@ func AesCtrCrypt(data, key []byte) []byte {
 // len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/tfkF10B13kH
 func AesCfbEncrypt(data, key []byte) []byte {
+	size := len(key)
+	if size != 16 && size != 24 && size != 32 {
+		panic("key length shoud be 16 or 24 or 32")
+	}
+
 	block, err := aes.NewCipher(key)
 	if err != nil {
 		panic(err)
@@ -147,6 +168,11 @@ func AesCfbEncrypt(data, key []byte) []byte {
 // len(encrypted) should be great than 16, len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/tfkF10B13kH
 func AesCfbDecrypt(encrypted, key []byte) []byte {
+	size := len(key)
+	if size != 16 && size != 24 && size != 32 {
+		panic("key length shoud be 16 or 24 or 32")
+	}
+
 	if len(encrypted) < aes.BlockSize {
 		panic("encrypted data is too short")
 	}
@@ -166,6 +192,11 @@ func AesCfbDecrypt(encrypted, key []byte) []byte {
 // len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/VtHxtkUj-3F
 func AesOfbEncrypt(data, key []byte) []byte {
+	size := len(key)
+	if size != 16 && size != 24 && size != 32 {
+		panic("key length shoud be 16 or 24 or 32")
+	}
+
 	block, err := aes.NewCipher(key)
 	if err != nil {
 		panic(err)
@@ -188,6 +219,11 @@ func AesOfbEncrypt(data, key []byte) []byte {
 // len(key) should be 16, 24 or 32.
 // Play: https://go.dev/play/p/VtHxtkUj-3F
 func AesOfbDecrypt(data, key []byte) []byte {
+	size := len(key)
+	if size != 16 && size != 24 && size != 32 {
+		panic("key length shoud be 16 or 24 or 32")
+	}
+
 	block, err := aes.NewCipher(key)
 	if err != nil {
 		panic(err)
@@ -254,6 +290,11 @@ func DesEcbDecrypt(encrypted, key []byte) []byte {
 // len(key) should be 8.
 // Play: https://go.dev/play/p/4cC4QvWfe3_1
 func DesCbcEncrypt(data, key []byte) []byte {
+	size := len(key)
+	if size != 8 {
+		panic("key length shoud be 8")
+	}
+
 	block, _ := des.NewCipher(key)
 	data = pkcs7Padding(data, block.BlockSize())
 
@@ -274,6 +315,11 @@ func DesCbcEncrypt(data, key []byte) []byte {
 // len(key) should be 8.
 // Play: https://go.dev/play/p/4cC4QvWfe3_1
 func DesCbcDecrypt(encrypted, key []byte) []byte {
+	size := len(key)
+	if size != 8 {
+		panic("key length shoud be 8")
+	}
+
 	block, _ := des.NewCipher(key)
 
 	iv := encrypted[:des.BlockSize]
@@ -290,6 +336,11 @@ func DesCbcDecrypt(encrypted, key []byte) []byte {
 // len(key) should be 8.
 // Play: https://go.dev/play/p/9-T6OjKpcdw
 func DesCtrCrypt(data, key []byte) []byte {
+	size := len(key)
+	if size != 8 {
+		panic("key length shoud be 8")
+	}
+
 	block, _ := des.NewCipher(key)
 
 	iv := bytes.Repeat([]byte("1"), block.BlockSize())
@@ -305,6 +356,11 @@ func DesCtrCrypt(data, key []byte) []byte {
 // len(key) should be 8.
 // Play: https://go.dev/play/p/y-eNxcFBlxL
 func DesCfbEncrypt(data, key []byte) []byte {
+	size := len(key)
+	if size != 8 {
+		panic("key length shoud be 8")
+	}
+
 	block, err := des.NewCipher(key)
 	if err != nil {
 		panic(err)
@@ -326,6 +382,11 @@ func DesCfbEncrypt(data, key []byte) []byte {
 // len(encrypted) should be great than 16, len(key) should be 8.
 // Play: https://go.dev/play/p/y-eNxcFBlxL
 func DesCfbDecrypt(encrypted, key []byte) []byte {
+	size := len(key)
+	if size != 8 {
+		panic("key length shoud be 8")
+	}
+
 	block, _ := des.NewCipher(key)
 	if len(encrypted) < des.BlockSize {
 		panic("encrypted data is too short")
@@ -340,9 +401,14 @@ func DesCfbDecrypt(encrypted, key []byte) []byte {
 }
 
 // DesOfbEncrypt encrypt data with key use DES OFB algorithm
-// len(key) should be 16, 24 or 32.
+// len(key) should be 8.
 // Play: https://go.dev/play/p/74KmNadjN1J
 func DesOfbEncrypt(data, key []byte) []byte {
+	size := len(key)
+	if size != 8 {
+		panic("key length shoud be 8")
+	}
+
 	block, err := des.NewCipher(key)
 	if err != nil {
 		panic(err)
@@ -364,6 +430,11 @@ func DesOfbEncrypt(data, key []byte) []byte {
 // len(key) should be 8.
 // Play: https://go.dev/play/p/74KmNadjN1J
 func DesOfbDecrypt(data, key []byte) []byte {
+	size := len(key)
+	if size != 8 {
+		panic("key length shoud be 8")
+	}
+
 	block, err := des.NewCipher(key)
 	if err != nil {
 		panic(err)
@@ -505,3 +576,32 @@ func RsaDecrypt(data []byte, privateKeyFileName string) []byte {
 	}
 	return plainText
 }
+
+// GenerateRsaKeyPair create rsa private and public key.
+// Play: https://go.dev/play/p/sSVmkfENKMz
+func GenerateRsaKeyPair(keySize int) (*rsa.PrivateKey, *rsa.PublicKey) {
+	privateKey, _ := rsa.GenerateKey(rand.Reader, keySize)
+	return privateKey, &privateKey.PublicKey
+}
+
+// RsaEncryptOAEP encrypts the given data with RSA-OAEP.
+// Play: https://go.dev/play/p/sSVmkfENKMz
+func RsaEncryptOAEP(data []byte, label []byte, key rsa.PublicKey) ([]byte, error) {
+	encryptedBytes, err := rsa.EncryptOAEP(sha256.New(), rand.Reader, &key, data, label)
+	if err != nil {
+		return nil, err
+	}
+
+	return encryptedBytes, nil
+}
+
+// RsaDecryptOAEP decrypts the data with RSA-OAEP.
+// Play: https://go.dev/play/p/sSVmkfENKMz
+func RsaDecryptOAEP(ciphertext []byte, label []byte, key rsa.PrivateKey) ([]byte, error) {
+	decryptedBytes, err := rsa.DecryptOAEP(sha256.New(), rand.Reader, &key, ciphertext, label)
+	if err != nil {
+		return nil, err
+	}
+
+	return decryptedBytes, nil
+}

cryptor/crypto_example_test.go

@@ -1,6 +1,8 @@
 package cryptor
 
-import "fmt"
+import (
+	"fmt"
+)
 
 func ExampleAesEcbEncrypt() {
 	data := "hello"
@@ -484,3 +486,25 @@ func ExampleSha512WithBase64() {
 	// Output:
 	// m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
 }
+
+func ExampleRsaEncryptOAEP() {
+	pri, pub := GenerateRsaKeyPair(1024)
+
+	data := []byte("hello world")
+	label := []byte("123456")
+
+	encrypted, err := RsaEncryptOAEP(data, label, *pub)
+	if err != nil {
+		return
+	}
+
+	decrypted, err := RsaDecryptOAEP([]byte(encrypted), label, *pri)
+	if err != nil {
+		return
+	}
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello world
+}

cryptor/crypto_test.go

@@ -150,3 +150,21 @@ func TestRsaEncrypt(t *testing.T) {
 	assert := internal.NewAssert(t, "TestRsaEncrypt")
 	assert.Equal(string(data), string(decrypted))
 }
+
+func TestRsaEncryptOAEP(t *testing.T) {
+	assert := internal.NewAssert(t, "TestRsaEncrypt")
+	t.Parallel()
+
+	pri, pub := GenerateRsaKeyPair(1024)
+
+	data := []byte("hello world")
+	label := []byte("123456")
+
+	encrypted, err := RsaEncryptOAEP(data, label, *pub)
+	assert.IsNil(err)
+
+	decrypted, err := RsaDecryptOAEP([]byte(encrypted), label, *pri)
+
+	assert.IsNil(err)
+	assert.Equal("hello world", string(decrypted))
+}

datastructure/hashmap/hashmap.go

@@ -7,6 +7,7 @@ package datastructure
 import (
 	"fmt"
 	"hash/fnv"
+	"reflect"
 )
 
 var defaultMapCapacity uint64 = 1 << 10
@@ -45,13 +46,24 @@ func NewHashMapWithCapacity(size, capacity uint64) *HashMap {
 func (hm *HashMap) Get(key any) any {
 	hashValue := hm.hash(key)
 	node := hm.table[hashValue]
-	if node != nil {
-		return node.value
+	for node != nil {
+		if reflect.DeepEqual(node.key, key) {
+			return node.value
+		}
+		node = node.next
 	}
-
 	return nil
 }
 
+// GetOrDefault return the value of given key in hashmap, if not found return default value
+func (hm *HashMap) GetOrDefault(key any, defaultValue any) any {
+	value := hm.Get(key)
+	if value == nil {
+		return defaultValue
+	}
+	return value
+}
+
 // Put new key value in hashmap
 func (hm *HashMap) Put(key any, value any) {
 	hm.putValue(hm.hash(key), key, value)
@@ -90,7 +102,13 @@ func (hm *HashMap) Delete(key any) {
 // 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
+	for node != nil {
+		if reflect.DeepEqual(node.key, key) {
+			return true
+		}
+		node = node.next
+	}
+	return false
 }
 
 // Iterate executes iteratee funcation for every key and value pair of hashmap (random order)
@@ -105,6 +123,25 @@ func (hm *HashMap) Iterate(iteratee func(key, value any)) {
 	}
 }
 
+// FilterByValue returns a filtered HashMap.
+// If any value is not matching the perdicate function then it returns nil
+// otherwise it returns the HashMap with selected values.
+func (hm *HashMap) FilterByValue(perdicate func(value any) bool) *HashMap {
+	var filteredHM *HashMap
+	if hm.size > 0 {
+		for i := 0; i < len(hm.table); i++ {
+			item := hm.table[i]
+			if item != nil && perdicate(item.value) {
+				if filteredHM == nil {
+					filteredHM = NewHashMap()
+				}
+				filteredHM.Put(item.key, item.value)
+			}
+		}
+	}
+	return filteredHM
+}
+
 // Keys returns a slice of the hashmap's keys (random order)
 func (hm *HashMap) Keys() []any {
 	keys := make([]any, int(hm.size))
@@ -150,6 +187,11 @@ func (hm *HashMap) resize() {
 	}
 }
 
+// Size returns current size of Hashmap
+func (hm *HashMap) Size() uint64 {
+	return hm.size
+}
+
 func (hm *HashMap) hash(key any) uint64 {
 	h := fnv.New64a()
 	_, _ = h.Write([]byte(fmt.Sprintf("%v", key)))

datastructure/hashmap/hashmap_test.go

@@ -74,3 +74,55 @@ func TestHashMap_KeysValues(t *testing.T) {
 	assert.Equal(3, len(values))
 	assert.Equal(3, len(keys))
 }
+
+func TestHashMap_Keys(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestHashMap_Keys")
+
+	hm := NewHashMap()
+
+	hm.Put("a", 1)
+	hm.Put("b", 2)
+	hm.Put("c", 3)
+
+	keys := hm.Keys()
+
+	assert.Equal(3, len(keys))
+}
+
+func TestHashMap_GetOrDefault(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestHashMap_GetOrDefault")
+
+	hm := NewHashMap()
+
+	hm.Put("a", 1)
+	hm.Put("b", 2)
+	hm.Put("c", 3)
+
+	assert.Equal(1, hm.GetOrDefault("a", 5))
+	assert.Equal(5, hm.GetOrDefault("d", 5))
+}
+
+func TestHashMap_FilterByValue(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestHashMap_FilterByValue")
+
+	hm := NewHashMap()
+
+	hm.Put("a", 1)
+	hm.Put("b", 2)
+	hm.Put("c", 3)
+	hm.Put("d", 4)
+	hm.Put("e", 5)
+	hm.Put("f", 6)
+
+	filteredHM := hm.FilterByValue(func(value any) bool {
+		return value.(int) == 1 || value.(int) == 3
+	})
+
+	assert.Equal(uint64(2), filteredHM.Size())
+}

datastructure/heap/maxheap.go

@@ -7,18 +7,18 @@ package datastructure
 import (
 	"fmt"
 
-	"github.com/duke-git/lancet/v2/lancetconstraints"
+	"github.com/duke-git/lancet/v2/constraints"
 )
 
 // MaxHeap implements a binary max heap
-// type T should implements Compare function in lancetconstraints.Comparator interface.
+// type T should implements Compare function in constraints.Comparator interface.
 type MaxHeap[T any] struct {
 	data       []T
-	comparator lancetconstraints.Comparator
+	comparator constraints.Comparator
 }
 
 // NewMaxHeap returns a MaxHeap instance with the given comparator.
-func NewMaxHeap[T any](comparator lancetconstraints.Comparator) *MaxHeap[T] {
+func NewMaxHeap[T any](comparator constraints.Comparator) *MaxHeap[T] {
 	return &MaxHeap[T]{
 		data:       make([]T, 0),
 		comparator: comparator,
@@ -26,7 +26,7 @@ func NewMaxHeap[T any](comparator lancetconstraints.Comparator) *MaxHeap[T] {
 }
 
 // BuildMaxHeap builds a MaxHeap instance with data and given comparator.
-func BuildMaxHeap[T any](data []T, comparator lancetconstraints.Comparator) *MaxHeap[T] {
+func BuildMaxHeap[T any](data []T, comparator constraints.Comparator) *MaxHeap[T] {
 	heap := &MaxHeap[T]{
 		data:       make([]T, 0, len(data)),
 		comparator: comparator,

datastructure/list/copyonwritelist.go

@@ -0,0 +1,379 @@
+package datastructure
+
+import (
+	"reflect"
+	"sort"
+	"sync"
+)
+
+type CopyOnWriteList[T any] struct {
+	data []T
+	lock sync.Locker
+}
+
+// NewCopyOnWriteList Creates an empty list.
+func NewCopyOnWriteList[T any](data []T) *CopyOnWriteList[T] {
+	return &CopyOnWriteList[T]{data: data, lock: &sync.RWMutex{}}
+}
+
+func (c *CopyOnWriteList[T]) getList() []T {
+	return c.data
+}
+func (c *CopyOnWriteList[T]) setList(data []T) {
+	c.data = data
+}
+
+// Size returns the number of elements in this list.
+func (c *CopyOnWriteList[T]) Size() int {
+	return len(c.getList())
+}
+
+// IsEmpty returns true if this list contains no elements.
+func (c *CopyOnWriteList[T]) IsEmpty() bool {
+	return c.Size() == 0
+}
+
+// Contain returns true if this list contains the specified element.
+func (c *CopyOnWriteList[T]) Contain(e T) bool {
+	list := c.getList()
+	return indexOf(e, list, 0, c.Size()) >= 0
+}
+
+// ValueOf returns the index of the first occurrence of the specified element in this list, or null if this list does not contain the element.
+func (c *CopyOnWriteList[T]) ValueOf(index int) (*T, bool) {
+	list := c.getList()
+	if index < 0 || index >= len(c.data) {
+		return nil, false
+	}
+	return get(list, index), true
+}
+
+// IndexOf returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element.
+func (c *CopyOnWriteList[T]) IndexOf(e T) int {
+	list := c.getList()
+	return indexOf(e, list, 0, c.Size())
+}
+
+// indexOf returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element.
+// start the start position of the search (inclusive)
+// end the end position of the search (exclusive)
+func indexOf[T any](o T, e []T, start int, end int) int {
+	if start >= end {
+		return -1
+	}
+	for i := start; i < end; i++ {
+		if reflect.DeepEqual(e[i], o) {
+			return i
+		}
+	}
+	return -1
+}
+
+// LastIndexOf returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.
+func (c *CopyOnWriteList[T]) LastIndexOf(e T) int {
+	list := c.getList()
+	return lastIndexOf(e, list, 0, c.Size())
+}
+
+// lastIndexOf returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.
+// start the start position of the search (inclusive)
+// end the end position of the search (exclusive)
+func lastIndexOf[T any](o T, e []T, start int, end int) int {
+	if start >= end {
+		return -1
+	}
+	for i := end - 1; i >= start; i-- {
+		if reflect.DeepEqual(e[i], o) {
+			return i
+		}
+	}
+	return -1
+}
+
+// LastIndexOfFunc returns the index of the last occurrence of the value in this list satisfying the
+// functional predicate f(T) bool
+// if not found return -1.
+func (l *CopyOnWriteList[T]) LastIndexOfFunc(f func(T) bool) int {
+	index := -1
+	data := l.getList()
+	for i := len(data) - 1; i >= 0; i-- {
+		if f(data[i]) {
+			index = i
+			break
+		}
+	}
+	return index
+}
+
+// IndexOfFunc returns the first index satisfying the functional predicate f(v) bool
+// if not found return -1.
+func (l *CopyOnWriteList[T]) IndexOfFunc(f func(T) bool) int {
+	index := -1
+	data := l.getList()
+	for i, v := range data {
+		if f(v) {
+			index = i
+			break
+		}
+	}
+	return index
+}
+
+// get returns the element at the specified position in this list.
+func get[T any](o []T, index int) *T {
+	return &o[index]
+}
+
+// Get returns the element at the specified position in this list.
+func (c *CopyOnWriteList[T]) Get(index int) *T {
+	list := c.getList()
+	if index < 0 || index >= len(list) {
+		return nil
+	}
+	return get(list, index)
+}
+
+func (c *CopyOnWriteList[T]) set(index int, e T) (oldValue *T) {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+	list := c.getList()
+	oldValue = get(list, index)
+
+	if reflect.DeepEqual(oldValue, e) {
+		c.setList(list)
+	} else {
+		newList := make([]T, len(list))
+		copy(newList, list)
+		newList[index] = e
+		c.setList(newList)
+	}
+	return
+}
+
+// Set replaces the element at the specified position in this list with the specified element.
+func (c *CopyOnWriteList[T]) Set(index int, e T) (oldValue *T, ok bool) {
+	list := c.getList()
+	if index < 0 || index >= len(list) {
+		return oldValue, false
+	}
+	return c.set(index, e), true
+}
+
+// Add appends the specified element to the end of this list.
+func (c *CopyOnWriteList[T]) Add(e T) bool {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	newList := make([]T, len(list)+1)
+	copy(newList, list)
+	newList[len(list)] = e
+	c.setList(newList)
+	return true
+}
+
+// AddAll appends all the elements in the specified collection to the end of this list
+func (c *CopyOnWriteList[T]) AddAll(e []T) bool {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	newList := make([]T, len(list)+len(e))
+	copy(newList, list)
+	copy(newList[len(list):], e)
+	c.setList(newList)
+	return true
+}
+
+// AddByIndex inserts the specified element at the specified position in this list.
+func (c *CopyOnWriteList[T]) AddByIndex(index int, e T) bool {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	length := len(list)
+	if index < 0 || index > length {
+		return false
+	}
+	var newList []T
+	var numMove = length - index
+	if numMove == 0 {
+		newList = make([]T, length+1)
+		copy(newList, list)
+	} else {
+		newList = make([]T, length+1)
+		copy(newList, list[:index])
+		copy(newList[index+1:], list[index:])
+	}
+	newList[index] = e
+	c.setList(newList)
+	return true
+}
+
+// delete removes the element at the specified position in this list.
+func (c *CopyOnWriteList[T]) delete(index int) *T {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	length := len(list)
+
+	oldValue := get(list, index)
+	numMove := length - index - 1
+	var newList []T
+	if numMove == 0 {
+		newList = make([]T, length-1)
+		copy(newList, list[:index])
+	} else {
+		newList = make([]T, length-1)
+		copy(newList, list[:index])
+		copy(newList[index:], list[index+1:])
+	}
+
+	c.setList(newList)
+	return oldValue
+}
+
+// DeleteAt removes the element at the specified position in this list.
+func (c *CopyOnWriteList[T]) DeleteAt(index int) (*T, bool) {
+	list := c.getList()
+	if index < 0 || index >= len(list) {
+		return nil, false
+	}
+	return c.delete(index), true
+}
+
+// DeleteBy removes the first occurrence of the specified element from this list, if it is present.
+func (c *CopyOnWriteList[T]) DeleteBy(o T) (*T, bool) {
+	list := c.getList()
+	index := indexOf(o, list, 0, len(list))
+	if index == -1 {
+		return nil, false
+	}
+	return c.delete(index), true
+}
+
+// DeleteRange removes from this list all the elements whose index is between fromIndex, inclusive, and toIndex, exclusive.
+// left close and right open
+func (c *CopyOnWriteList[T]) DeleteRange(start int, end int) {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	length := len(list)
+	if start < 0 || end > length || start > end {
+		return
+	}
+	var newList []T
+	numMove := length - end
+	if numMove == 0 {
+		newList = make([]T, length-(end-start))
+		copy(newList, list[:start])
+	} else {
+		newList = make([]T, length-(end-start))
+		copy(newList, list[:start])
+		copy(newList[start:], list[end:])
+	}
+	c.setList(newList)
+}
+
+// DeleteIf removes all the elements of this collection that satisfy the given predicate.
+func (c *CopyOnWriteList[T]) DeleteIf(f func(T) bool) {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	length := len(list)
+	var newList []T
+	for i := 0; i < length; i++ {
+		if !f(list[i]) {
+			newList = append(newList, list[i])
+		}
+	}
+	c.setList(newList)
+}
+
+// Equal returns true if the specified object is equal to this list.
+func (c *CopyOnWriteList[T]) Equal(other *[]T) bool {
+	if other == nil {
+		return false
+	}
+	if c.Size() != len(*other) {
+		return false
+	}
+	list := c.getList()
+	otherList := NewCopyOnWriteList(*other).getList()
+	for i := 0; i < len(list); i++ {
+		if !reflect.DeepEqual(list[i], otherList[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// Clear removes all the elements from this list.
+func (c *CopyOnWriteList[T]) Clear() {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	list = make([]T, 0)
+	c.setList(list)
+}
+
+// Merge a tow list to one, change the list
+func (c *CopyOnWriteList[T]) Merge(other []T) {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	list = append(list, other...)
+	c.setList(list)
+}
+
+// ForEach performs the given action for each element of the Iterable until all elements have been processed
+// or the action throws an exception.
+func (c *CopyOnWriteList[T]) ForEach(f func(T)) {
+	list := c.getList()
+	for i := 0; i < len(list); i++ {
+		f(list[i])
+	}
+
+}
+
+// Sort sorts this list according to the order induced by the specified Comparator.
+func (c *CopyOnWriteList[T]) Sort(compare func(o1 T, o2 T) bool) {
+	lock := c.lock
+	lock.Lock()
+	list := c.getList()
+
+	sort.Slice(list, func(i, j int) bool {
+		return compare(list[i], list[j])
+	})
+
+	c.setList(list)
+}
+
+func (c *CopyOnWriteList[T]) SubList(start int, end int) (newList []T) {
+	lock := c.lock
+	lock.Lock()
+	list := c.getList()
+	length := len(list)
+	defer lock.Unlock()
+	if start < 0 || end > length || start > end {
+		return []T{}
+	}
+	newList = make([]T, end-start)
+	copy(newList, list[start:end])
+	c.setList(newList)
+	return
+}

datastructure/list/copyonwritelist_test.go

@@ -0,0 +1,268 @@
+package datastructure
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestCopyOnWriteList_ValueOf(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+
+	assert := internal.NewAssert(t, "CopyOnWriteList_IndexOf")
+	of, ok := list.ValueOf(3)
+	assert.Equal(4, *of)
+	assert.Equal(true, ok)
+
+	_, ok = list.ValueOf(6)
+	assert.Equal(false, ok)
+}
+
+func TestCopyOnWriteList_Contain(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Contains")
+	assert.Equal(true, list.Contain(3))
+}
+
+func TestCopyOnWriteList_IsEmpty(t *testing.T) {
+	list := NewCopyOnWriteList([]int{})
+	assert := internal.NewAssert(t, "CopyOnWriteList_IsEmpty")
+	assert.Equal(true, list.IsEmpty())
+}
+
+func TestCopyOnWriteList_Size(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_size")
+	assert.Equal(5, list.Size())
+}
+
+func TestCopyOnWriteList_GetList(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_GetList")
+	assert.Equal([]int{1, 2, 3, 4, 5}, list.getList())
+}
+
+func TestCopyOnWriteList_Get(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Get")
+	i := list.Get(2)
+	assert.Equal(3, *i)
+}
+
+func TestCopyOnWriteList_Set(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Set")
+	list.Set(2, 6)
+	assert.Equal(6, list.getList()[2])
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.Set(0, 6)
+	assert.Equal(6, list.getList()[0])
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.Set(0, 1)
+	assert.Equal(1, list.getList()[0])
+}
+
+func TestCopyOnWriteList_Add(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Add")
+	list.Add(6)
+	assert.Equal([]int{1, 2, 3, 4, 5, 6}, list.getList())
+}
+
+func TestCopyOnWriteList_AddAll(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_AddAll")
+	list.AddAll([]int{6, 7, 8})
+	assert.Equal([]int{1, 2, 3, 4, 5, 6, 7, 8}, list.getList())
+}
+
+func TestCopyOnWriteList_AddByIndex(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_AddByIndex")
+	list.AddByIndex(2, 6)
+	assert.Equal([]int{1, 2, 6, 3, 4, 5}, list.getList())
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.AddByIndex(0, 6)
+	assert.Equal([]int{6, 1, 2, 3, 4, 5}, list.getList())
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.AddByIndex(5, 6)
+	assert.Equal([]int{1, 2, 3, 4, 5, 6}, list.getList())
+}
+
+func TestCopyOnWriteList_DeleteAt2(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_RemoveByIndex")
+	list.DeleteAt(2)
+	assert.Equal([]int{1, 2, 4, 5}, list.getList())
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.DeleteAt(4)
+	assert.Equal([]int{1, 2, 3, 4}, list.getList())
+}
+
+func TestCopyOnWriteList_RemoveByValue(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_RemoveByValue")
+	list.DeleteBy(3)
+	assert.Equal([]int{1, 2, 4, 5}, list.getList())
+}
+
+func TestCopyOnWriteList_DeleteRange(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_RemoveRange")
+	list.DeleteRange(1, 3)
+	assert.Equal([]int{1, 4, 5}, list.getList())
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.DeleteRange(0, 5)
+	assert.Equal([]int{}, list.getList())
+}
+
+func TestCopyOnWriteList_LastIndexOf(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3})
+	assert := internal.NewAssert(t, "CopyOnWriteList_LastIndexOf")
+	assert.Equal(5, list.LastIndexOf(3))
+}
+
+func TestCopyOnWriteList_DeleteAt(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3})
+	assert := internal.NewAssert(t, "CopyOnWriteList_DeleteAt")
+	list.DeleteAt(2)
+	assert.Equal([]int{1, 2, 4, 5, 3}, list.getList())
+}
+
+func TestCopyOnWriteList_DeleteBy(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3})
+	assert := internal.NewAssert(t, "CopyOnWriteList_DeleteBy")
+	list.DeleteBy(3)
+	assert.Equal([]int{1, 2, 4, 5, 3}, list.getList())
+}
+
+func TestCopyOnWriteList_DeleteIf(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3, 6})
+	assert := internal.NewAssert(t, "CopyOnWriteList_DeleteIf")
+
+	list.DeleteIf(func(i int) bool {
+		return i%2 == 0
+	})
+
+	assert.Equal([]int{1, 3, 5, 3}, list.getList())
+}
+
+func TestCopyOnWriteList_Equal(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3, 6})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Equal")
+
+	assert.Equal(true, list.Equal(&[]int{1, 2, 3, 4, 5, 3, 6}))
+}
+
+func TestCopyOnWriteList_ForEach(t *testing.T) {
+	testList := make([]int, 0)
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3, 6})
+	assert := internal.NewAssert(t, "CopyOnWriteList_ForEach")
+
+	list.ForEach(func(i int) {
+		testList = append(testList, i)
+	})
+	assert.Equal([]int{1, 2, 3, 4, 5, 3, 6}, testList)
+
+	list.ForEach(func(i int) {
+		list.Add(i)
+	})
+	assert.Equal([]int{1, 2, 3, 4, 5, 3, 6, 1, 2, 3, 4, 5, 3, 6}, list.getList())
+}
+
+func TestCopyOnWriteList_Clear(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3, 6})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Clear")
+
+	list.Clear()
+	assert.Equal([]int{}, list.getList())
+}
+
+func TestCopyOnWriteList_Merge(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 3, 5, 7, 9})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Merge")
+
+	list.Merge([]int{2, 4, 6, 8, 10})
+	assert.Equal([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10}, list.getList())
+
+}
+
+func TestCopyOnWriteList_Sort(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Sort")
+
+	list.Sort(func(i, j int) bool {
+		return i < j
+	})
+	assert.Equal([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, list.getList())
+}
+
+func TestCopyOnWriteList_IndexOf(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	assert := internal.NewAssert(t, "CopyOnWriteList_IndexOf")
+
+	assert.Equal(0, list.IndexOf(1))
+	assert.Equal(9, list.IndexOf(10))
+	assert.Equal(-1, list.IndexOf(11))
+}
+
+func TestCopyOnWriteList_SubList(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+
+	assert := internal.NewAssert(t, "CopyOnWriteList_SubList")
+
+	list = NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	subList := list.SubList(1, 3)
+	assert.Equal([]int{3, 5}, subList)
+
+	list = NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	subList = list.SubList(1, 1)
+	assert.Equal([]int{}, subList)
+
+	list = NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	assert.Equal(10, list.Size())
+	subList = list.SubList(1, 10)
+	assert.Equal([]int{3, 5, 7, 9, 2, 4, 6, 8, 10}, subList)
+
+	list = NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	subList = list.SubList(11, 1)
+	assert.Equal([]int{}, subList)
+}
+
+func TestCopyOnWriteListIndexOfFunc(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestIndexOfFunc")
+
+	list := NewCopyOnWriteList([]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 TestNewCopyOnWriteListLastIndexOfFunc(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestLastIndexOfFunc")
+
+	list := NewCopyOnWriteList([]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)
+}

datastructure/list/list.go

@@ -271,7 +271,7 @@ func (l *List[T]) Reverse() {
 	}
 }
 
-// Unique remove duplicate items in list.
+// Unique delete duplicate items in list.
 func (l *List[T]) Unique() {
 	data := l.data
 	size := len(data)
@@ -294,7 +294,7 @@ func (l *List[T]) Unique() {
 	l.data = uniqueData
 }
 
-// Union creates a new list contain all element in list l and other, remove duplicate element.
+// Union creates a new list contain all element in list l and other, delete duplicate element.
 func (l *List[T]) Union(other *List[T]) *List[T] {
 	result := NewList([]T{})
 

datastructure/optional/optional.go

@@ -0,0 +1,108 @@
+package optional
+
+import (
+	"sync"
+)
+
+// Optional is a type that may or may not contain a non-nil value.
+type Optional[T any] struct {
+	value *T
+	mu    *sync.RWMutex
+}
+
+// Default returns an default Optional instance.
+func Default[T any]() Optional[T] {
+	return Optional[T]{mu: &sync.RWMutex{}}
+}
+
+// Of returns an Optional with a non-nil value.
+func Of[T any](value T) Optional[T] {
+	return Optional[T]{value: &value, mu: &sync.RWMutex{}}
+}
+
+// FromNillable returns an Optional for a given value, which may be nil.
+func FromNillable[T any](value *T) Optional[T] {
+	if value == nil {
+		return Default[T]()
+	}
+	return Optional[T]{value: value, mu: &sync.RWMutex{}}
+}
+
+// IsNotNil checks if there is a value present.
+func (o Optional[T]) IsNotNil() bool {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	return o.value != nil
+}
+
+// IsNil checks if the Optional is nil.
+func (o Optional[T]) IsNil() bool {
+	return !o.IsNotNil()
+}
+
+// IfNotNil performs the given action with the value if a value is not nil.
+func (o Optional[T]) IfNotNil(action func(value T)) {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	if o.value != nil {
+		action(*o.value)
+	}
+}
+
+// IfNotNilOrElse performs the action with the value if present, otherwise performs the fallback action.
+func (o Optional[T]) IfNotNilOrElse(action func(value T), fallbackAction func()) {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	if o.value != nil {
+		action(*o.value)
+	} else {
+		fallbackAction()
+	}
+}
+
+// Unwarp returns the value if not nil, otherwise panics.
+func (o Optional[T]) Unwarp() T {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	if o.value == nil {
+		panic("Optional.Get: no value present")
+	}
+	return *o.value
+}
+
+// OrElse returns the value if is not nil, otherwise returns other.
+func (o Optional[T]) OrElse(other T) T {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	if o.value != nil {
+		return *o.value
+	}
+	return other
+}
+
+// OrElseGet returns the value if is not nil, otherwise invokes action and returns the result.
+func (o Optional[T]) OrElseGet(action func() T) T {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	if o.value != nil {
+		return *o.value
+	}
+	return action()
+}
+
+// OrElseTrigger returns the value if present, otherwise returns an error.
+func (o Optional[T]) OrElseTrigger(errorHandler func() error) (T, error) {
+	o.mu.RLock()
+	defer o.mu.RUnlock()
+
+	if o.value == nil {
+		return *new(T), errorHandler()
+	}
+	return *o.value, nil
+}

datastructure/optional/optional_test.go

@@ -0,0 +1,151 @@
+package optional
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestDefault(t *testing.T) {
+	assert := internal.NewAssert(t, "TestEmpty")
+	opt := Default[int]()
+
+	assert.ShouldBeTrue(opt.IsNil())
+}
+
+func TestOf(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOf")
+	value := 42
+	opt := Of(value)
+
+	assert.ShouldBeTrue(opt.IsNotNil())
+	assert.Equal(opt.Unwarp(), value)
+}
+
+func TestFromNillable(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOfNullable")
+	var value *int = nil
+	opt := FromNillable(value)
+
+	assert.ShouldBeFalse(opt.IsNotNil())
+
+	value = new(int)
+	*value = 42
+	opt = FromNillable(value)
+
+	assert.ShouldBeTrue(opt.IsNotNil())
+}
+
+func TestOrElse(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOrElse")
+	optDefault := Default[int]()
+	defaultValue := 100
+
+	val := optDefault.OrElse(defaultValue)
+	assert.Equal(val, defaultValue)
+
+	optWithValue := Of(42)
+	val = optWithValue.OrElse(defaultValue)
+	assert.Equal(val, 42)
+}
+
+func TestOrElseGetHappyPath(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOrElseGetHappyPath")
+	optWithValue := Of(42)
+	action := func() int { return 100 }
+
+	val := optWithValue.OrElseGet(action)
+	assert.Equal(val, 42)
+}
+
+func TestOrElseGet(t *testing.T) {
+	assert := internal.NewAssert(t, "TestOrElseGet")
+	optDefault := Default[int]()
+	action := func() int { return 100 }
+
+	val := optDefault.OrElseGet(action)
+	assert.Equal(val, action())
+}
+
+func TestOrElseTrigger(t *testing.T) {
+	assert := internal.NewAssert(t, "OrElseTrigger")
+	optDefault := Default[int]()
+	_, err := optDefault.OrElseTrigger(func() error { return errors.New("no value") })
+
+	assert.Equal(err.Error(), "no value")
+
+	optWithValue := Of(42)
+	val, err := optWithValue.OrElseTrigger(func() error { return errors.New("no value") })
+
+	assert.IsNil(err)
+	assert.Equal(val, 42)
+}
+
+func TestIfNotNil(t *testing.T) {
+	assert := internal.NewAssert(t, "IfNotNil")
+	called := false
+	action := func(value int) { called = true }
+
+	optDefault := Default[int]()
+	optDefault.IfNotNil(action)
+
+	assert.ShouldBeFalse(called)
+
+	called = false // Reset for next test
+	optWithValue := Of(42)
+	optWithValue.IfNotNil(action)
+
+	assert.ShouldBeTrue(called)
+}
+
+func TestIfNotNilOrElse(t *testing.T) {
+	assert := internal.NewAssert(t, "TestIfNotNilOrElse")
+
+	// Test when value is present
+	calledWithValue := false
+	valueAction := func(value int) { calledWithValue = true }
+	fallbackAction := func() { t.Errorf("Empty action should not be called when value is present") }
+
+	optWithValue := Of(42)
+	optWithValue.IfNotNilOrElse(valueAction, fallbackAction)
+
+	assert.ShouldBeTrue(calledWithValue)
+
+	// Test when value is not present
+	calledWithEmpty := false
+	valueAction = func(value int) { t.Errorf("Value action should not be called when value is not present") }
+	fallbackAction = func() { calledWithEmpty = true }
+
+	optDefault := Default[int]()
+	optDefault.IfNotNilOrElse(valueAction, fallbackAction)
+
+	assert.ShouldBeTrue(calledWithEmpty)
+}
+
+func TestGetWithPanicStandard(t *testing.T) {
+	assert := internal.NewAssert(t, "TestGetWithPanicStandard")
+
+	// Test when value is present
+	optWithValue := Of(42)
+	func() {
+		defer func() {
+			r := recover()
+			assert.IsNil(r)
+		}()
+		val := optWithValue.Unwarp()
+		if val != 42 {
+			t.Errorf("Expected Unwarp to return 42, got %v", val)
+		}
+	}()
+
+	// Test when value is not present
+	optDefault := Default[int]()
+	func() {
+		defer func() {
+			r := recover()
+			assert.IsNotNil(r)
+		}()
+		_ = optDefault.Unwarp()
+	}()
+}

datastructure/queue/arrayqueue.go

@@ -12,7 +12,7 @@ import (
 
 // ArrayQueue implements queue with slice
 type ArrayQueue[T any] struct {
-	items    []T
+	data     []T
 	head     int
 	tail     int
 	capacity int
@@ -21,7 +21,7 @@ type ArrayQueue[T any] struct {
 
 func NewArrayQueue[T any](capacity int) *ArrayQueue[T] {
 	return &ArrayQueue[T]{
-		items:    make([]T, 0, capacity),
+		data:     make([]T, 0, capacity),
 		head:     0,
 		tail:     0,
 		capacity: capacity,
@@ -33,7 +33,7 @@ func NewArrayQueue[T any](capacity int) *ArrayQueue[T] {
 func (q *ArrayQueue[T]) Data() []T {
 	items := []T{}
 	for i := q.head; i < q.tail; i++ {
-		items = append(items, q.items[i])
+		items = append(items, q.data[i])
 	}
 	return items
 }
@@ -55,40 +55,71 @@ func (q *ArrayQueue[T]) IsFull() bool {
 
 // Front return front value of queue
 func (q *ArrayQueue[T]) Front() T {
-	return q.items[0]
+	return q.data[0]
 }
 
 // Back return back value of queue
 func (q *ArrayQueue[T]) Back() T {
-	return q.items[q.size-1]
+	return q.data[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]
+	if q.tail < q.capacity {
+		q.data = append(q.data, item)
+		// q.tail++
+		q.data[q.tail] = item
+	} else {
+		//upgrade
+		if q.head > 0 {
+			for i := 0; i < q.tail-q.head; i++ {
+				q.data[i] = q.data[i+q.head]
+			}
+			q.tail -= q.head
+			q.head = 0
+		} else {
+			if q.capacity < 65536 {
+				if q.capacity == 0 {
+					q.capacity = 1
+				}
+				q.capacity *= 2
+			} else {
+				q.capacity += 2 ^ 16
+			}
+
+			tmp := make([]T, q.capacity, q.capacity)
+			copy(tmp, q.data)
+			q.data = tmp
 		}
-		q.tail = q.tail - q.head
-		q.head = 0
+
+		q.data[q.tail] = item
 	}
 
-	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 {
+	if q.size == 0 {
 		return item, false
 	}
-	item = q.items[q.head]
+
+	item = q.data[q.head]
 	q.head++
+
+	if q.head >= 1024 || q.head*2 > q.tail {
+		q.capacity -= q.head
+		q.tail -= q.head
+		tmp := make([]T, q.capacity, q.capacity)
+		copy(tmp, q.data[q.head:])
+		q.data = tmp
+		q.head = 0
+	}
+
 	q.size--
 	return item, true
 }
@@ -96,7 +127,7 @@ func (q *ArrayQueue[T]) Dequeue() (T, bool) {
 // Clear the queue data
 func (q *ArrayQueue[T]) Clear() {
 	capacity := q.capacity
-	q.items = make([]T, 0, capacity)
+	q.data = make([]T, 0, capacity)
 	q.head = 0
 	q.tail = 0
 	q.size = 0
@@ -105,7 +136,7 @@ func (q *ArrayQueue[T]) Clear() {
 
 // Contain checks if the value is in queue or not
 func (q *ArrayQueue[T]) Contain(value T) bool {
-	for _, v := range q.items {
+	for _, v := range q.data {
 		if reflect.DeepEqual(v, value) {
 			return true
 		}
@@ -117,7 +148,7 @@ func (q *ArrayQueue[T]) Contain(value T) bool {
 func (q *ArrayQueue[T]) Print() {
 	info := "["
 	for i := q.head; i < q.tail; i++ {
-		info += fmt.Sprintf("%+v, ", q.items[i])
+		info += fmt.Sprintf("%+v, ", q.data[i])
 	}
 	info += "]"
 	fmt.Println(info)

datastructure/queue/arrayqueue_test.go

@@ -11,7 +11,7 @@ func TestArrayQueue_Enqueue(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestArrayQueue_Enqueue")
 
-	queue := NewArrayQueue[int](5)
+	queue := NewArrayQueue[int](2)
 	queue.Enqueue(1)
 	queue.Enqueue(2)
 	queue.Enqueue(3)

datastructure/queue/priorityqueue.go

@@ -8,20 +8,20 @@ package datastructure
 import (
 	"errors"
 
-	"github.com/duke-git/lancet/v2/lancetconstraints"
+	"github.com/duke-git/lancet/v2/constraints"
 )
 
 // PriorityQueue is a priority queue implemented by binary heap tree
-// type T should implements Compare function in lancetconstraints.Comparator interface.
+// type T should implements Compare function in constraints.Comparator interface.
 type PriorityQueue[T any] struct {
 	items      []T
 	size       int
-	comparator lancetconstraints.Comparator
+	comparator constraints.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] {
+func NewPriorityQueue[T any](capacity int, comparator constraints.Comparator) *PriorityQueue[T] {
 	return &PriorityQueue[T]{
 		items:      make([]T, capacity+1),
 		size:       0,

datastructure/set/set.go

@@ -4,19 +4,21 @@
 // Package datastructure contains some data structure. Set is a data container, like slice, but element of set is not duplicate.
 package datastructure
 
+import "sort"
+
 // 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](items ...T) Set[T] {
-	set := make(Set[T])
+// New create a instance of set from given values.
+func New[T comparable](items ...T) Set[T] {
+	set := make(Set[T], len(items))
 	set.Add(items...)
 	return set
 }
 
-// NewSetFromSlice create a set from slice
-func NewSetFromSlice[T comparable](items []T) Set[T] {
-	set := make(Set[T])
+// FromSlice create a set from given slice.
+func FromSlice[T comparable](items []T) Set[T] {
+	set := make(Set[T], len(items))
 	for _, item := range items {
 		set.Add(item)
 	}
@@ -77,8 +79,7 @@ func (s Set[T]) ContainAll(other Set[T]) bool {
 
 // Clone return a copy of set
 func (s Set[T]) Clone() Set[T] {
-	set := NewSet[T]()
-	set.Add(s.Values()...)
+	set := FromSlice(s.ToSlice())
 	return set
 }
 
@@ -116,14 +117,11 @@ func (s Set[T]) Size() int {
 }
 
 // Values return all values of set
+// Deprecated: Values function is deprecated and will be removed in future versions. Please use ToSlice() function instead.
+//
+// The ToSlice() function provides the same functionality as Values and returns a slice containing all values of the set.
 func (s Set[T]) Values() []T {
-	result := make([]T, 0, len(s))
-
-	s.Iterate(func(value T) {
-		result = append(result, value)
-	})
-
-	return result
+	return s.ToSlice()
 }
 
 // Union creates a new set contain all element of set s and other
@@ -135,7 +133,7 @@ func (s Set[T]) Union(other Set[T]) Set[T] {
 
 // 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]()
+	set := New[T]()
 	s.Iterate(func(value T) {
 		if other.Contain(value) {
 			set.Add(value)
@@ -147,7 +145,7 @@ func (s Set[T]) Intersection(other Set[T]) Set[T] {
 
 // 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]()
+	set := New[T]()
 	s.Iterate(func(value T) {
 		if !other.Contain(value) {
 			set.Add(value)
@@ -163,9 +161,9 @@ func (s Set[T]) SymmetricDifference(other Set[T]) Set[T] {
 	return set
 }
 
-// Minus creates an set of whose element in origin set but not in compared set
+// Minus creates a 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]()
+	set := New[T]()
 
 	s.Iterate(func(value T) {
 		if !comparedSet.Contain(value) {
@@ -189,11 +187,34 @@ func (s Set[T]) EachWithBreak(iteratee func(item T) bool) {
 // Pop delete the top element of set then return it, if set is empty, return nil-value of T and false.
 func (s Set[T]) Pop() (v T, ok bool) {
 	if len(s) > 0 {
-		items := s.Values()
-		item := items[len(s)-1]
-		delete(s, item)
-		return item, true
+		for item := range s {
+			v = item
+			delete(s, item)
+			return v, true
+		}
 	}
 
 	return v, false
 }
+
+// ToSlice returns a slice containing all values of the set.
+func (s Set[T]) ToSlice() []T {
+	if s.IsEmpty() {
+		return []T{}
+	}
+	result := make([]T, 0, s.Size())
+	s.Iterate(func(value T) {
+		result = append(result, value)
+	})
+
+	return result
+}
+
+// ToSortedSlice returns a sorted slice containing all values of the set.
+func (s Set[T]) ToSortedSlice(less func(v1, v2 T) bool) []T {
+	result := s.ToSlice()
+	sort.Slice(result, func(i, j int) bool {
+		return less(result[i], result[j])
+	})
+	return result
+}

datastructure/set/set_test.go

@@ -1,23 +1,25 @@
 package datastructure
 
 import (
+	"reflect"
+	"sort"
 	"testing"
 
 	"github.com/duke-git/lancet/v2/internal"
 )
 
-func TestSet_NewSetFromSlice(t *testing.T) {
+func TestSet_FromSlice(t *testing.T) {
 	t.Parallel()
 
-	assert := internal.NewAssert(t, "TestSet_NewSetFromSlice")
+	assert := internal.NewAssert(t, "TestSet_FromSlice")
 
-	s1 := NewSetFromSlice([]int{1, 2, 2, 3})
+	s1 := FromSlice([]int{1, 2, 2, 3})
 	assert.Equal(3, s1.Size())
 	assert.Equal(true, s1.Contain(1))
 	assert.Equal(true, s1.Contain(2))
 	assert.Equal(true, s1.Contain(3))
 
-	s2 := NewSetFromSlice([]int{})
+	s2 := FromSlice([]int{})
 	assert.Equal(0, s2.Size())
 }
 
@@ -26,10 +28,10 @@ func TestSet_Add(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Add")
 
-	set := NewSet[int]()
+	set := New[int]()
 	set.Add(1, 2, 3)
 
-	cmpSet := NewSet(1, 2, 3)
+	cmpSet := New(1, 2, 3)
 
 	assert.Equal(true, set.Equal(cmpSet))
 }
@@ -39,12 +41,12 @@ func TestSet_AddIfNotExist(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_AddIfNotExist")
 
-	set := NewSet[int]()
+	set := New[int]()
 	set.Add(1, 2, 3)
 
 	assert.Equal(false, set.AddIfNotExist(1))
 	assert.Equal(true, set.AddIfNotExist(4))
-	assert.Equal(NewSet(1, 2, 3, 4), set)
+	assert.Equal(New(1, 2, 3, 4), set)
 }
 
 func TestSet_AddIfNotExistBy(t *testing.T) {
@@ -52,7 +54,7 @@ func TestSet_AddIfNotExistBy(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_AddIfNotExistBy")
 
-	set := NewSet[int]()
+	set := New[int]()
 	set.Add(1, 2)
 
 	ok := set.AddIfNotExistBy(3, func(val int) bool {
@@ -75,7 +77,7 @@ func TestSet_Contain(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Contain")
 
-	set := NewSet[int]()
+	set := New[int]()
 	set.Add(1, 2, 3)
 
 	assert.Equal(true, set.Contain(1))
@@ -87,9 +89,9 @@ 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)
+	set1 := New(1, 2, 3)
+	set2 := New(1, 2)
+	set3 := New(1, 2, 3, 4)
 
 	assert.Equal(true, set1.ContainAll(set2))
 	assert.Equal(false, set1.ContainAll(set3))
@@ -100,7 +102,7 @@ func TestSet_Clone(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Clone")
 
-	set1 := NewSet(1, 2, 3)
+	set1 := New(1, 2, 3)
 	set2 := set1.Clone()
 
 	assert.Equal(true, set1.Size() == set2.Size())
@@ -112,11 +114,11 @@ func TestSet_Delete(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Delete")
 
-	set := NewSet[int]()
+	set := New[int]()
 	set.Add(1, 2, 3)
 	set.Delete(3)
 
-	assert.Equal(true, set.Equal(NewSet(1, 2)))
+	assert.Equal(true, set.Equal(New(1, 2)))
 }
 
 func TestSet_Equal(t *testing.T) {
@@ -124,9 +126,9 @@ 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)
+	set1 := New(1, 2, 3)
+	set2 := New(1, 2, 3)
+	set3 := New(1, 2, 3, 4)
 
 	assert.Equal(true, set1.Equal(set2))
 	assert.Equal(false, set1.Equal(set3))
@@ -137,7 +139,7 @@ func TestSet_Iterate(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Iterate")
 
-	set := NewSet(1, 2, 3)
+	set := New(1, 2, 3)
 	arr := []int{}
 	set.Iterate(func(value int) {
 		arr = append(arr, value)
@@ -151,7 +153,7 @@ func TestSet_IsEmpty(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_IsEmpty")
 
-	set := NewSet[int]()
+	set := New[int]()
 	assert.Equal(true, set.IsEmpty())
 }
 
@@ -160,7 +162,7 @@ func TestSet_Size(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Size")
 
-	set := NewSet(1, 2, 3)
+	set := New(1, 2, 3)
 	assert.Equal(3, set.Size())
 }
 
@@ -169,7 +171,7 @@ func TestSet_Values(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Values")
 
-	set := NewSet(1, 2, 3)
+	set := New(1, 2, 3)
 	values := set.Values()
 
 	assert.Equal(3, len(values))
@@ -180,12 +182,12 @@ func TestSet_Union(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Union")
 
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
+	set1 := New(1, 2, 3)
+	set2 := New(2, 3, 4, 5)
 
 	unionSet := set1.Union(set2)
 
-	assert.Equal(NewSet(1, 2, 3, 4, 5), unionSet)
+	assert.Equal(New(1, 2, 3, 4, 5), unionSet)
 }
 
 func TestSet_Intersection(t *testing.T) {
@@ -193,11 +195,11 @@ func TestSet_Intersection(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Intersection")
 
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
+	set1 := New(1, 2, 3)
+	set2 := New(2, 3, 4, 5)
 	intersectionSet := set1.Intersection(set2)
 
-	assert.Equal(NewSet(2, 3), intersectionSet)
+	assert.Equal(New(2, 3), intersectionSet)
 }
 
 func TestSet_SymmetricDifference(t *testing.T) {
@@ -205,10 +207,10 @@ func TestSet_SymmetricDifference(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_SymmetricDifference")
 
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
+	set1 := New(1, 2, 3)
+	set2 := New(2, 3, 4, 5)
 
-	assert.Equal(NewSet(1, 4, 5), set1.SymmetricDifference(set2))
+	assert.Equal(New(1, 4, 5), set1.SymmetricDifference(set2))
 }
 
 func TestSet_Minus(t *testing.T) {
@@ -216,16 +218,16 @@ 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)
+	set1 := New(1, 2, 3)
+	set2 := New(2, 3, 4, 5)
+	set3 := New(2, 3)
 
-	assert.Equal(NewSet(1), set1.Minus(set2))
-	assert.Equal(NewSet(4, 5), set2.Minus(set3))
+	assert.Equal(New(1), set1.Minus(set2))
+	assert.Equal(New(4, 5), set2.Minus(set3))
 }
 
 func TestEachWithBreak(t *testing.T) {
-	// s := NewSet(1, 2, 3, 4, 5)
+	// s := New(1, 2, 3, 4, 5)
 
 	// var sum int
 
@@ -241,22 +243,93 @@ func TestEachWithBreak(t *testing.T) {
 	// assert.Equal(6, sum)
 }
 
-// func TestPop(t *testing.T) {
-// 	assert := internal.NewAssert(t, "TestPop")
+func TestPop(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestSet_Pop")
 
-// 	s := NewSet[int]()
+	s := New[int]()
 
-// 	val, ok := s.Pop()
-// 	assert.Equal(0, val)
-// 	assert.Equal(false, ok)
+	val, ok := s.Pop()
+	assert.Equal(0, val)
+	assert.Equal(false, ok)
 
-// 	s.Add(1)
-// 	s.Add(2)
-// 	s.Add(3)
+	s = New(1, 2, 3, 4, 5)
+	sl := s.ToSlice()
 
-// 	// s = NewSet(1, 2, 3, 4, 5)
+	val, ok = s.Pop()
+	assert.Equal(false, s.Contain(val))
+	assert.Equal(true, ok)
+	assert.Equal(len(sl)-1, s.Size())
 
-// 	val, ok = s.Pop()
-// 	assert.Equal(3, val)
-// 	assert.Equal(true, ok)
-// }
+	var found bool
+
+	for _, v := range sl {
+		if v == val {
+			found = true
+		}
+	}
+
+	assert.Equal(true, found)
+}
+
+func TestSet_ToSlice(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestSet_ToSlice")
+
+	set1 := FromSlice([]int{6, 3, 1, 5, 6, 7, 1})
+	set2 := FromSlice([]float64{-2.65, 4.25, 4.25 - 3.14, 0})
+	set3 := New[string]()
+
+	slice1 := set1.ToSlice()
+	slice2 := set2.ToSlice()
+	slice3 := set3.ToSlice()
+
+	sort.Ints(slice1)
+	sort.Float64s(slice2)
+
+	assert.Equal(5, len(slice1))
+	assert.Equal(4, len(slice2))
+	assert.Equal(0, len(slice3))
+
+	assert.Equal(true, reflect.DeepEqual(slice1, []int{1, 3, 5, 6, 7}))
+	assert.Equal(true, reflect.DeepEqual(slice2, []float64{-2.65, 0, 1.11, 4.25}))
+	assert.Equal("[]string", reflect.TypeOf(slice3).String())
+}
+
+func TestSet_ToSortedSlice(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestSet_ToSortedSlice")
+
+	set1 := FromSlice([]int{6, 3, 1, 5, 6, 7, 1})
+	set2 := FromSlice([]float64{-2.65, 4.25, 4.25 - 3.14, 0})
+
+	type Person struct {
+		Name string
+		Age  int
+	}
+	set3 := FromSlice([]Person{{"Tom", 20}, {"Jerry", 18}, {"Spike", 25}})
+
+	slice1 := set1.ToSortedSlice(func(v1, v2 int) bool {
+		return v1 < v2
+	})
+	slice2 := set2.ToSortedSlice(func(v1, v2 float64) bool {
+		return v2 < v1
+	})
+	slice3 := set3.ToSortedSlice(func(v1, v2 Person) bool {
+		return v1.Age < v2.Age
+	})
+
+	assert.Equal(5, len(slice1))
+	assert.Equal(4, len(slice2))
+	assert.Equal(3, len(slice3))
+
+	assert.Equal(true, reflect.DeepEqual(slice1, []int{1, 3, 5, 6, 7}))
+	assert.Equal(true, reflect.DeepEqual(slice2, []float64{4.25, 1.11, 0, -2.65}))
+	assert.Equal(true, reflect.DeepEqual(slice3, []Person{
+		{"Jerry", 18},
+		{"Tom", 20},
+		{"Spike", 25},
+	}))
+}

datastructure/tree/bstree.go

@@ -7,22 +7,22 @@ package datastructure
 import (
 	"math"
 
+	"github.com/duke-git/lancet/v2/constraints"
 	"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 T should implements Compare function in constraints.Comparator interface.
 type BSTree[T any] struct {
 	root       *datastructure.TreeNode[T]
-	comparator lancetconstraints.Comparator
+	comparator constraints.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] {
+func NewBSTree[T any](rootData T, comparator constraints.Comparator) *BSTree[T] {
 	root := datastructure.NewTreeNode(rootData)
 	return &BSTree[T]{root, comparator}
 }
@@ -87,7 +87,7 @@ func (t *BSTree[T]) HasSubTree(subTree *BSTree[T]) bool {
 }
 
 func hasSubTree[T any](superTreeRoot, subTreeRoot *datastructure.TreeNode[T],
-	comparator lancetconstraints.Comparator) bool {
+	comparator constraints.Comparator) bool {
 	result := false
 
 	if superTreeRoot != nil && subTreeRoot != nil {

datastructure/tree/tree_internal.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"math"
 
+	"github.com/duke-git/lancet/v2/constraints"
 	"github.com/duke-git/lancet/v2/datastructure"
-	"github.com/duke-git/lancet/v2/lancetconstraints"
 )
 
 func preOrderTraverse[T any](node *datastructure.TreeNode[T]) []T {
@@ -86,7 +86,7 @@ func levelOrderTraverse[T any](root *datastructure.TreeNode[T], traversal *[]T)
 	}
 }
 
-func insertTreeNode[T any](rootNode, newNode *datastructure.TreeNode[T], comparator lancetconstraints.Comparator) {
+func insertTreeNode[T any](rootNode, newNode *datastructure.TreeNode[T], comparator constraints.Comparator) {
 	if comparator.Compare(newNode.Value, rootNode.Value) == -1 {
 		if rootNode.Left == nil {
 			rootNode.Left = newNode
@@ -103,7 +103,7 @@ func insertTreeNode[T any](rootNode, newNode *datastructure.TreeNode[T], compara
 }
 
 // todo, delete root node failed
-func deleteTreeNode[T any](node *datastructure.TreeNode[T], data T, comparator lancetconstraints.Comparator) *datastructure.TreeNode[T] {
+func deleteTreeNode[T any](node *datastructure.TreeNode[T], data T, comparator constraints.Comparator) *datastructure.TreeNode[T] {
 	if node == nil {
 		return nil
 	}
@@ -216,7 +216,7 @@ func calculateDepth[T any](node *datastructure.TreeNode[T], depth int) int {
 	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 {
+func isSubTree[T any](superTreeRoot, subTreeRoot *datastructure.TreeNode[T], comparator constraints.Comparator) bool {
 	if subTreeRoot == nil {
 		return true
 	}

datetime/datetime.go

@@ -298,7 +298,7 @@ func IsWeekend(t time.Time) bool {
 }
 
 // NowDateOrTime return current datetime with specific format and timezone.
-// Play: todo
+// Play: https://go.dev/play/p/EZ-begEjtT0
 func NowDateOrTime(format string, timezone ...string) string {
 	tf, ok := timeFormat[strings.ToLower(format)]
 	if !ok {
@@ -318,7 +318,7 @@ func NowDateOrTime(format string, timezone ...string) string {
 }
 
 // Timestamp return current second timestamp.
-// Play: todo
+// Play: https://go.dev/play/p/iU5b7Vvjx6x
 func Timestamp(timezone ...string) int64 {
 	t := time.Now()
 
@@ -335,7 +335,7 @@ func Timestamp(timezone ...string) int64 {
 }
 
 // TimestampMilli return current mill second timestamp.
-// Play: todo
+// Play: https://go.dev/play/p/4gvEusOTu1T
 func TimestampMilli(timezone ...string) int64 {
 	t := time.Now()
 
@@ -351,7 +351,7 @@ func TimestampMilli(timezone ...string) int64 {
 }
 
 // TimestampMicro return current micro second timestamp.
-// Play: todo
+// Play: https://go.dev/play/p/2maANglKHQE
 func TimestampMicro(timezone ...string) int64 {
 	t := time.Now()
 
@@ -367,7 +367,7 @@ func TimestampMicro(timezone ...string) int64 {
 }
 
 // TimestampNano return current nano second timestamp.
-// Play: todo
+// Play: https://go.dev/play/p/A9Oq_COrcCF
 func TimestampNano(timezone ...string) int64 {
 	t := time.Now()
 
@@ -381,3 +381,12 @@ func TimestampNano(timezone ...string) int64 {
 
 	return t.UnixNano()
 }
+
+// TraceFuncTime: trace the func costed time,just call it at top of the func like `defer TraceFuncTime()()`
+func TraceFuncTime() func() {
+	pre := time.Now()
+	return func() {
+		elapsed := time.Since(pre)
+		fmt.Println("Costs Time:\t", elapsed)
+	}
+}

docs/.vitepress/common.ts

@@ -0,0 +1,89 @@
+import { defineConfig, HeadConfig } from 'vitepress'
+
+export const META_IMAGE = '/lancet_logo.png'
+export const isProduction = process.env.NETLIFY && process.env.CONTEXT === 'production'
+
+if (process.env.NETLIFY) {
+    console.log('Netlify build', process.env.CONTEXT)
+}
+
+const productionHead: HeadConfig[] = [
+    [
+        'script',
+        {
+            src: 'https://unpkg.com/thesemetrics@latest',
+            async: '',
+            type: 'text/javascript',
+        },
+    ],
+]
+
+const rControl = /[\u0000-\u001f]/g
+const rSpecial = /[\s~`!@#$%^&*()\-_+=[\]{}|\\;:"'“”‘’<>,.?/]+/g
+const rCombining = /[\u0300-\u036F]/g
+
+/**
+ * Default slugification function
+ */
+export const slugify = (str: string): string =>
+    str
+        .normalize('NFKD')
+        // Remove accents
+        .replace(rCombining, '')
+        // Remove control characters
+        .replace(rControl, '')
+        // Replace special characters
+        .replace(rSpecial, '-')
+        // ensure it doesn't start with a number
+        .replace(/^(\d)/, '_$1')
+
+export const commonConfig = defineConfig({
+    title: 'Lancet',
+    appearance: true,
+
+    markdown: {
+        theme: {
+            dark: 'dracula-soft',
+            light: 'vitesse-light',
+        },
+
+        attrs: {
+            leftDelimiter: '%{',
+            rightDelimiter: '}%',
+        },
+
+        anchor: {
+            slugify,
+        },
+    },
+
+    head: [
+        // ['link', { rel: 'icon', type: 'image/svg+xml', href: '/logo.svg' }],
+        ['link', { rel: 'icon', type: 'image/png', href: '/lancet_logo_mini.png' }],
+        ['meta', { name: 'theme-color', content: '#5f67ee' }],
+        ['meta', { name: 'og:type', content: 'website' }],
+        ['meta', { name: 'og:locale', content: 'zh' }],
+
+        ...(isProduction ? productionHead : []),
+    ],
+
+    themeConfig: {
+        logo: { src: '/lancet_logo_mini.png', width: 24, height: 24 },
+        outline: [2, 3],
+
+        search: {
+            provider: 'local',
+        },
+        socialLinks: [
+            {
+                icon: 'github',
+                link: 'https://github.com/duke-git/lancet',
+            },
+        ],
+
+        footer: {
+            copyright: 'Copyright © 2023-present Duke Du',
+            message: '备案号: 京ICP备2023022770号',
+        },
+    },
+})

docs/.vitepress/config.mts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitepress'
+import { commonConfig } from './common'
+import { zhConfig } from './zh'
+import { enConfig } from './en'
+
+// https://vitepress.dev/reference/site-config
+export default defineConfig({
+    ...commonConfig,
+
+    locales: {
+        root: { label: '简体中文', lang: 'zh-CN', link: '/', ...zhConfig },
+        en: { label: 'English', lang: 'en-US', link: '/en/', ...enConfig },
+    },
+})

docs/.vitepress/en.ts

@@ -0,0 +1,139 @@
+import type { DefaultTheme, LocaleSpecificConfig } from 'vitepress'
+
+export const META_URL = 'https://www.golancet.cn/en/'
+export const META_TITLE = 'Lancet'
+export const META_DESCRIPTION = 'A powerful util function library of Go'
+
+export const enConfig: LocaleSpecificConfig<DefaultTheme.Config> = {
+    description: META_DESCRIPTION,
+
+    head: [
+        ['meta', { property: 'og:url', content: META_URL }],
+        ['meta', { property: 'og:description', content: META_DESCRIPTION }],
+    ],
+
+    themeConfig: {
+        editLink: {
+            pattern: 'https://github.com/duke-git/lancet/edit/v2/docs/:path',
+            text: 'Suggest changes to this page',
+        },
+        nav: [
+            {
+                text: 'Home',
+                link: '/en/',
+                activeMatch: '^/en/',
+            },
+            {
+                text: 'Guide',
+                link: '/en/guide/introduction',
+                activeMatch: '^/en/guide/',
+            },
+            { text: 'API', link: '/en/api/overview', activeMatch: '^/en/api/' },
+            {
+                text: 'Links',
+                items: [
+                    {
+                        text: 'Discussion',
+                        link: 'https://github.com/duke-git/lancet/discussions',
+                    },
+                    {
+                        text: 'Changelog',
+                        link: 'https://github.com/duke-git/lancet/releases',
+                    },
+                    {
+                        text: 'Contribution',
+                        link: 'https://github.com/duke-git/lancet/blob/main/CONTRIBUTING.en-US.md',
+                    },
+                ],
+            },
+        ],
+
+        sidebar: {
+            '/en/guide/': [
+                {
+                    text: 'Introduction',
+                    collapsed: false,
+                    items: [
+                        {
+                            text: 'What is Lancet？',
+                            link: '/en/guide/introduction',
+                        },
+                        {
+                            text: 'Getting started',
+                            link: '/en/guide/getting_started',
+                        },
+                    ],
+                },
+                {
+                    text: 'Contribute Code',
+                    collapsed: false,
+                    items: [
+                        {
+                            text: 'Contribution guide',
+                            link: '/en/guide/contribution_guide',
+                        },
+                        {
+                            text: 'Contributors',
+                            link: '/en/guide/contributors',
+                        },
+                    ],
+                },
+                {
+                    text: 'API Reference',
+                    link: '/en/api/overview'
+                },
+            ],
+            '/en/api/': [
+                {
+                    text: 'Overview',
+                    items: [{ text: 'API overview', link: '/en/api/overview' }],
+                },
+                {
+                    text: 'Packages',
+                    collapsed: false,
+                    items: [
+                        { text: 'algorithm', link: '/en/api/packages/algorithm' },
+                        { text: 'compare', link: '/en/api/packages/compare' },
+                        { text: 'concurrency', link: '/en/api/packages/concurrency' },
+                        { text: 'condition', link: '/en/api/packages/condition' },
+                        { text: 'convertor', link: '/en/api/packages/convertor' },
+                        { text: 'cryptor', link: '/en/api/packages/cryptor' },
+                        {
+                            text: 'datastructure',
+                            collapsed: true,
+                            items: [
+                                { text: 'list', link: '/en/api/packages/datastructure/list' },
+                                { text: 'safelist', link: '/en/api/packages/datastructure/copyonwritelist' },
+                                { text: 'link', link: '/en/api/packages/datastructure/link' },
+                                { text: 'stack', link: '/en/api/packages/datastructure/stack' },
+                                { text: 'queue', link: '/en/api/packages/datastructure/queue' },
+                                { text: 'heap', link: '/en/api/packages/datastructure/heap' },
+                                { text: 'tree', link: '/en/api/packages/datastructure/tree' },
+                                { text: 'set', link: '/en/api/packages/datastructure/set' },
+                                { text: 'hashmap', link: '/en/api/packages/datastructure/hashmap' },
+                            ],
+                        },
+                        { text: 'datetime', link: '/en/api/packages/datetime' },
+                        { text: 'fileutil', link: '/en/api/packages/fileutil' },
+                        { text: 'formatter', link: '/en/api/packages/formatter' },
+                        { text: 'function', link: '/en/api/packages/function' },
+                        { text: 'mathutil', link: '/en/api/packages/mathutil' },
+                        { text: 'maputil', link: '/en/api/packages/maputil' },
+                        { text: 'netutil', link: '/en/api/packages/netutil' },
+                        { text: 'pointer', link: '/en/api/packages/pointer' },
+                        { text: 'random', link: '/en/api/packages/random' },
+                        { text: 'retry', link: '/en/api/packages/retry' },
+                        { text: 'slice', link: '/en/api/packages/slice' },
+                        { text: 'stream', link: '/en/api/packages/stream' },
+                        { text: 'struct', link: '/en/api/packages/struct' },
+                        { text: 'strutil', link: '/en/api/packages/strutil' },
+                        { text: 'system', link: '/en/api/packages/system' },
+                        { text: 'tuple', link: '/en/api/packages/tuple' },
+                        { text: 'validator', link: '/en/api/packages/validator' },
+                        { text: 'xerror', link: '/en/api/packages/xerror' },
+                    ],
+                },
+            ],
+        },
+    },
+}

docs/.vitepress/zh.ts

@@ -0,0 +1,152 @@
+import type { DefaultTheme, LocaleSpecificConfig } from 'vitepress'
+
+export const META_URL = 'https://www.golancet.cn'
+export const META_TITLE = 'Lancet'
+export const META_DESCRIPTION = '一个强大的Go语言工具函数库'
+
+export const zhConfig: LocaleSpecificConfig<DefaultTheme.Config> = {
+    description: META_DESCRIPTION,
+
+    head: [
+        ['meta', { property: 'og:url', content: META_URL }],
+        ['meta', { property: 'og:description', content: META_DESCRIPTION }],
+    ],
+
+    themeConfig: {
+        editLink: {
+            pattern: 'https://github.com/duke-git/lancet/edit/v2/docs/:path',
+            text: '对本页提出修改建议',
+        },
+        outline: {
+            label: '本页内容',
+        },
+
+        docFooter: {
+            prev: '上一页',
+            next: '下一页',
+        },
+
+        nav: [
+            {
+                text: '首页',
+                link: '/',
+                activeMatch: '^/',
+            },
+            {
+                text: '指南',
+                link: '/guide/introduction',
+                activeMatch: '^/guide/',
+            },
+            { text: 'API', link: '/api/overview', activeMatch: '^/api/' },
+            {
+                text: '相关链接',
+                items: [
+                    {
+                        text: '论坛',
+                        link: 'https://github.com/duke-git/lancet/discussions',
+                    },
+                    {
+                        text: '更新日志',
+                        link: 'https://github.com/duke-git/lancet/releases',
+                    },
+                    {
+                        text: '参与贡献',
+                        link: 'https://github.com/duke-git/lancet/blob/main/CONTRIBUTING.zh-CN.md',
+                    },
+                ],
+            },
+        ],
+
+        sidebar: {
+            '/guide/': [
+                {
+                    text: '介绍',
+                    collapsed: false,
+                    items: [
+                        {
+                            text: 'Lancet是什么？',
+                            link: '/guide/introduction',
+                        },
+                        {
+                            text: '开始',
+                            link: '/guide/getting_started',
+                        },
+                    ],
+                },
+                {
+                    text: '贡献代码',
+                    collapsed: false,
+                    items: [
+                        {
+                            text: '贡献指南',
+                            link: '/guide/contribution_guide',
+                        },
+                        {
+                            text: '贡献者',
+                            link: '/guide/contributors',
+                        },
+                    ],
+                },
+                {
+                    text: 'API手册',
+                    link: '/api/overview'
+                },
+            ],
+
+            '/api/': [
+                {
+                    text: '概览',
+                    items: [{ text: 'API概述', link: '/api/overview' }],
+                },
+                {
+                    text: 'API文档',
+                    collapsed: false,
+                    items: [
+                        { text: '算法', link: '/api/packages/algorithm' },
+                        { text: '比较器', link: '/api/packages/compare' },
+                        { text: '并发处理', link: '/api/packages/concurrency' },
+                        { text: '条件判断', link: '/api/packages/condition' },
+                        { text: '类型转换', link: '/api/packages/convertor' },
+                        { text: '加密&解密', link: '/api/packages/cryptor' },
+                        {
+                            text: '数据结构',
+                            collapsed: true,
+                            items: [
+                                { text: '线性表', link: '/api/packages/datastructure/list' },
+                                {
+                                    text: '线性表(线程安全)',
+                                    link: '/api/packages/datastructure/copyonwritelist',
+                                },
+                                { text: '链表', link: '/api/packages/datastructure/link' },
+                                { text: '栈', link: '/api/packages/datastructure/stack' },
+                                { text: '队列', link: '/api/packages/datastructure/queue' },
+                                { text: '堆', link: '/api/packages/datastructure/heap' },
+                                { text: '树', link: '/api/packages/datastructure/tree' },
+                                { text: '集合', link: '/api/packages/datastructure/set' },
+                                { text: 'HashMap', link: '/api/packages/datastructure/hashmap' },
+                            ],
+                        },
+                        { text: '日期&时间', link: '/api/packages/datetime' },
+                        { text: '文件', link: '/api/packages/fileutil' },
+                        { text: '格式化工具', link: '/api/packages/formatter' },
+                        { text: '函数', link: '/api/packages/function' },
+                        { text: '数学工具', link: '/api/packages/mathutil' },
+                        { text: 'Map', link: '/api/packages/maputil' },
+                        { text: '网络', link: '/api/packages/netutil' },
+                        { text: '指针', link: '/api/packages/pointer' },
+                        { text: '随机数', link: '/api/packages/random' },
+                        { text: '重试', link: '/api/packages/retry' },
+                        { text: '切片', link: '/api/packages/slice' },
+                        { text: '流', link: '/api/packages/stream' },
+                        { text: '结构体', link: '/api/packages/struct' },
+                        { text: '字符串', link: '/api/packages/strutil' },
+                        { text: '系统', link: '/api/packages/system' },
+                        { text: '元组', link: '/api/packages/tuple' },
+                        { text: '验证器', link: '/api/packages/validator' },
+                        { text: '错误处理', link: '/api/packages/xerror' },
+                    ],
+                },
+            ],
+        },
+    },
+}

docs/api/overview.md

@@ -0,0 +1,69 @@
+---
+outline: deep
+---
+
+# API概述
+
+<b>lancet（柳叶刀）是一个功能强大、全面、高效、可复用的go语言工具函数库。包含25个包，超过600个工具函数。功能涵盖字符串处理、切片处理、网络、并发、加解密、文件处理、时间/日期、流处理、迭代器等等。</b>
+
+
+<style>
+.package-title {
+    color: black;
+    font-size: 18px;
+    text-align: center;
+    font-weight: bold;
+}
+.package-container {
+    font-size: 16px;
+    border: 1px dashed;
+    padding: 10px;
+    text-align: center;
+}
+
+.package-cell {
+    height: 40px;
+    width: 140px;
+    display: inline-block;
+    vertical-align: middle;
+    line-height: 40px;
+    background: #10b981;
+    border: 1px solid;
+    margin-right: 10px;
+    margin-bottom: 10px;
+    border-radius: 6px;
+    font-weight: bold;
+}
+</style>
+
+<div>
+    <p class="package-title">lancet功能模块</p>
+    <div class="package-container">
+        <div class="package-cell">algorithm</div>
+        <div class="package-cell">compare</div>
+        <div class="package-cell">concurrency</div>
+        <div class="package-cell">condition</div>
+        <div class="package-cell">convertor</div>
+        <div class="package-cell">cryptor</div>
+        <div class="package-cell">datastructure</div>
+        <div class="package-cell">datetime</div>
+        <div class="package-cell">fileutil</div>
+        <div class="package-cell">formatter</div>
+        <div class="package-cell">function</div>
+        <div class="package-cell">iterator</div>
+        <div class="package-cell">maputil</div>
+        <div class="package-cell">mathutil</div>
+        <div class="package-cell">netutil</div>
+        <div class="package-cell">pointer</div>
+        <div class="package-cell">random</div>
+        <div class="package-cell">retry</div>
+        <div class="package-cell">slice</div>
+        <div class="package-cell">stream</div>
+        <div class="package-cell">structs</div>
+        <div class="package-cell">strutil</div>
+        <div class="package-cell">system</div>
+        <div class="package-cell">tuple</div>
+        <div class="package-cell">validator</div>
+        <div class="package-cell">xerror</div>
+    </div>
+</div>

docs/api/packages/algorithm.md

@@ -43,15 +43,15 @@ import (
 
 ### <span id="BubbleSort">BubbleSort</span>
 
-<p>冒泡排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>冒泡排序，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func BubbleSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GNdv7Jg2Taj)</span></b>
 
 ```go
 package main
@@ -91,15 +91,15 @@ func main() {
 
 ### <span id="InsertionSort">InsertionSort</span>
 
-<p>插入排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>插入排序，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func InsertionSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/G5LJiWgJJW6)</span></b>
 
 ```go
 package main
@@ -117,7 +117,7 @@ type people struct {
 // PeopleAageComparator sort people slice by age field
 type peopleAgeComparator struct{}
 
-// Compare implements github.com/duke-git/lancet/lancetconstraints/constraints.go/Comparator
+// Compare implements github.com/duke-git/lancet/constraints/constraints.go/Comparator
 func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
     p1, _ := v1.(people)
     p2, _ := v2.(people)
@@ -154,15 +154,15 @@ func main() {
 
 ### <span id="SelectionSort">SelectionSort</span>
 
-<p>选择排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>选择排序，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func SelectionSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/oXovbkekayS)</span></b>
 
 ```go
 package main
@@ -202,15 +202,15 @@ func main() {
 
 ### <span id="ShellSort">ShellSort</span>
 
-<p>希尔排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>希尔排序，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func ShellSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3ibkszpJEu3)</span></b>
 
 ```go
 package main
@@ -250,15 +250,15 @@ func main() {
 
 ### <span id="QuickSort">QuickSort</span>
 
-<p>快速排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>快速排序，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func QuickSort[T any](slice []T comparator lancetconstraints.Comparator)
+func QuickSort[T any](slice []T comparator constraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/7Y7c1Elk3ax)</span></b>
 
 ```go
 package main
@@ -298,15 +298,15 @@ func main() {
 
 ### <span id="HeapSort">HeapSort</span>
 
-<p>堆排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>堆排序，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func HeapSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/u6Iwa1VZS_f)</span></b>
 
 ```go
 package main
@@ -346,15 +346,15 @@ func main() {
 
 ### <span id="MergeSort">MergeSort</span>
 
-<p>归并排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>归并排序，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func MergeSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ydinn9YzUJn)</span></b>
 
 ```go
 package main
@@ -394,15 +394,15 @@ func main() {
 
 ### <span id="CountSort">CountSort</span>
 
-<p>计数排序，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>计数排序，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func CountSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+func CountSort[T any](slice []T, comparator constraints.Comparator) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tB-Umgm0DrP)</span></b>
 
 ```go
 package main
@@ -443,15 +443,15 @@ func main() {
 
 ### <span id="BinarySearch">BinarySearch</span>
 
-<p>二分递归查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>二分递归查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
+func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator constraints.Comparator) int
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/t6MeGiUSN47)</span></b>
 
 ```go
 package main
@@ -494,15 +494,15 @@ func main() {
 
 ### <span id="BinaryIterativeSearch">BinaryIterativeSearch</span>
 
-<p>二分迭代查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包lancetconstraints.Comparator。</p>
+<p>二分迭代查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包constraints.Comparator。</p>
 
 <b>函数签名:</b>
 
 ```go
-func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
+func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator constraints.Comparator) int
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Anozfr8ZLH3)</span></b>
 
 ```go
 package main
@@ -553,7 +553,7 @@ func main() {
 func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/IsS7rgn5s3x)</span></b>
 
 ```go
 package main
@@ -596,7 +596,7 @@ func (l *LRUCache[K, V]) Delete(key K) bool
 func (l *LRUCache[K, V]) Len() int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/-EZjgOURufP)</span></b>
 
 ```go
 package main

docs/api/packages/compare.md

@@ -30,10 +30,12 @@ import (
 -   [GreaterThan](#GreaterThan)
 -   [LessOrEqual](#LessOrEqual)
 -   [GreaterOrEqual](#GreaterOrEqual)
+-   [InDelta](#InDelta)
+
 
 <div STYLE="page-break-after: always;"></div>
 
-## Documentation
+## 文档
 
 ### <span id="Equal">Equal</span>
 
@@ -45,7 +47,7 @@ import (
 func Equal(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/wmVxR-to4lz)</span></b>
 
 ```go
 package main
@@ -94,7 +96,7 @@ func main() {
 func EqualValue(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fxnna_LLD9u)</span></b>
 
 ```go
 package main
@@ -133,7 +135,7 @@ func main() {
 func LessThan(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cYh7FQQj0ne)</span></b>
 
 ```go
 package main
@@ -182,7 +184,7 @@ func main() {
 func GreaterThan(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9-NYDFZmIMp)</span></b>
 
 ```go
 package main
@@ -234,7 +236,7 @@ func main() {
 func LessOrEqual(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/e4T_scwoQzp)</span></b>
 
 ```go
 package main
@@ -283,7 +285,7 @@ func main() {
 func GreaterOrEqual(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/vx8mP0U8DFk)</span></b>
 
 ```go
 package main
@@ -324,3 +326,50 @@ func main() {
     // false
 }
 ```
+
+### <span id="InDelta">InDelta</span>
+
+<p>检查增量内两个值是否相等。</p>
+
+<b>函数签名:</b>
+
+```go
+func InDelta[T constraints.Integer | constraints.Float](left, right T, delta float64) bool
+```
+
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/TuDdcNtMkjo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := InDelta(1, 1, 0)
+    result2 := InDelta(1, 2, 0)
+
+    result3 := InDelta(2.0/3.0, 0.66667, 0.001)
+    result4 := InDelta(2.0/3.0, 0.0, 0.001)
+
+    result5 := InDelta(float64(74.96)-float64(20.48), 54.48, 0)
+    result6 := InDelta(float64(74.96)-float64(20.48), 54.48, 1e-14)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+
+    // Output:
+    // true
+    // false
+    // true
+    // false
+    // false
+    // true
+}
+```

docs/api/packages/concurrency.md

@@ -1,15 +1,17 @@
 # Concurrency
-并发包包含一些支持并发编程的功能。例如：goroutine, channel等。
+
+并发包包含一些支持并发编程的功能。例如：goroutine, channel 等。
 
 <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)
+-   [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"
@@ -19,25 +21,28 @@ import (
 <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)
+
+-   [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>
@@ -46,7 +51,8 @@ import (
 type Channel[T any] struct
 func NewChannel[T any]() *Channel[T]
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/7aB4KyMMp9A)</span></b>
 
 ```go
 package main
@@ -70,7 +76,8 @@ func main() {
 ```go
 func (c *Channel[T]) Bridge(ctx context.Context, chanStream <-chan <-chan T) <-chan T
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qmWSy1NVF-Y)</span></b>
 
 ```go
 package main
@@ -122,7 +129,8 @@ func main() {
 ```go
 func (c *Channel[T]) FanIn(ctx context.Context, channels ...<-chan T) <-chan T
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2VYFMexEvTm)</span></b>
 
 ```go
 package main
@@ -161,7 +169,8 @@ func main() {
 ```go
 func (c *Channel[T]) Generate(ctx context.Context, values ...T) <-chan T
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/7aB4KyMMp9A)</span></b>
 
 ```go
 package main
@@ -199,7 +208,8 @@ func main() {
 ```go
 func (c *Channel[T]) Repeat(ctx context.Context, values ...T) <-chan T
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/k5N_ALVmYjE)</span></b>
 
 ```go
 package main
@@ -238,7 +248,8 @@ func main() {
 ```go
 func (c *Channel[T]) RepeatFn(ctx context.Context, fn func() T) <-chan T
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4J1zAWttP85)</span></b>
 
 ```go
 package main
@@ -279,7 +290,8 @@ func main() {
 ```go
 func (c *Channel[T]) Or(channels ...<-chan T) <-chan T
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Wqz9rwioPww)</span></b>
 
 ```go
 package main
@@ -322,7 +334,8 @@ func main() {
 ```go
 func (c *Channel[T]) OrDone(ctx context.Context, channel <-chan T) <-chan T
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/lm_GoS6aDjo)</span></b>
 
 ```go
 package main
@@ -360,7 +373,8 @@ func main() {
 ```go
 func (c *Channel[T]) Take(ctx context.Context, valueStream <-chan T, number int) <-chan T
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9Utt-1pDr2J)</span></b>
 
 ```go
 package main
@@ -406,7 +420,8 @@ func main() {
 ```go
 func (c *Channel[T]) Tee(ctx context.Context, in <-chan T) (<-chan T, <-chan T)
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3TQPKnCirrP)</span></b>
 
 ```go
 package main
@@ -436,4 +451,4 @@ func main() {
     // 1
     // 1
 }
-```
+```

docs/api/packages/condition.md

@@ -18,7 +18,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
-## Index
+## 目录
 
 - [Bool](#Bool)
 - [And](#And)
@@ -31,7 +31,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
-## 目录
+## 文档
 
 ### <span id="Bool">Bool</span>
 <p>返回传入参数的bool值.<br/>
@@ -45,7 +45,7 @@ slices和map的length大于0时，返回true，否则返回false<br/>
 ```go
 func Bool[T any](value T) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ETzeDJRSvhm)</span></b>
 
 ```go
 package main
@@ -109,7 +109,7 @@ func main() {
 ```go
 func And[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/W1SSUmt6pvr)</span></b>
 
 ```go
 package main
@@ -135,7 +135,7 @@ func main() {
 ```go
 func Or[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UlQTxHaeEkq)</span></b>
 
 ```go
 package main
@@ -161,7 +161,7 @@ func main() {
 ```go
 func Xor[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/gObZrW7ZbG8)</span></b>
 
 ```go
 package main
@@ -187,7 +187,7 @@ func main() {
 ```go
 func Nor[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/g2j08F_zZky)</span></b>
 
 ```go
 package main
@@ -213,7 +213,7 @@ func main() {
 ```go
 func Xnor[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OuDB9g51643)</span></b>
 
 ```go
 package main
@@ -239,7 +239,7 @@ func main() {
 ```go
 func Nand[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/vSRMLxLIbq8)</span></b>
 
 ```go
 package main
@@ -265,7 +265,7 @@ func main() {
 ```go
 func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ElllPZY0guT)</span></b>
 
 ```go
 package main

docs/api/packages/convertor.md

@@ -43,6 +43,10 @@ import (
 -   [ToInterface](#ToInterface)
 -   [Utf8ToGbk](#Utf8ToGbk)
 -   [GbkToUtf8](#GbkToUtf8)
+-   [ToStdBase64](#ToStdBase64)
+-   [ToUrlBase64](#ToUrlBase64)
+-   [ToRawStdBase64](#ToRawStdBase64)
+-   [ToRawUrlBase64](#ToRawUrlBase64)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -58,7 +62,7 @@ import (
 func ColorHexToRGB(colorHex string) (red, green, blue int)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/o7_ft-JCJBV)</span></b>
 
 ```go
 package main
@@ -89,7 +93,7 @@ func main() {
 func ColorRGBToHex(red, green, blue int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nzKS2Ro87J1)</span></b>
 
 ```go
 package main
@@ -122,7 +126,7 @@ func main() {
 func ToBool(s string) (bool, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ARht2WnGdIN)</span></b>
 
 ```go
 package main
@@ -163,7 +167,7 @@ func main() {
 func ToBytes(data any) ([]byte, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fAMXYFDvOvr)</span></b>
 
 ```go
 package main
@@ -196,7 +200,7 @@ func main() {
 func ToChar(s string) []string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/JJ1SvbFkVdM)</span></b>
 
 ```go
 package main
@@ -232,7 +236,7 @@ func main() {
 func ToChannel[T any](array []T) <-chan T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/hOx_oYZbAnL)</span></b>
 
 ```go
 package main
@@ -269,7 +273,7 @@ func main() {
 func ToFloat(value any) (float64, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4YTmPCibqHJ)</span></b>
 
 ```go
 package main
@@ -314,7 +318,7 @@ func main() {
 func ToInt(value any) (int64, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9_h9vIt-QZ_b)</span></b>
 
 ```go
 package main
@@ -356,7 +360,7 @@ func main() {
 func ToJson(value any) (string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2rLIkMmXWvR)</span></b>
 
 ```go
 package main
@@ -391,7 +395,7 @@ func main() {
 func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tVFy7E-t24l)</span></b>
 
 ```go
 package main
@@ -432,7 +436,7 @@ func main() {
 func ToPointer[T any](value T) *T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ASf_etHNlw1)</span></b>
 
 ```go
 package main
@@ -461,7 +465,7 @@ func main() {
 func ToString(value any) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nF1zOOslpQq)</span></b>
 
 ```go
 package main
@@ -509,7 +513,7 @@ func main() {
 func StructToMap(value any) (map[string]any, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KYGYJqNUBOI)</span></b>
 
 ```go
 package main
@@ -547,7 +551,7 @@ func main() {
 func MapToSlice[T any, K comparable, V any](aMap map[K]V, iteratee func(K, V) T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dmX4Ix5V6Wl)</span></b>
 
 ```go
 package main
@@ -577,7 +581,7 @@ func main() {
 func EncodeByte(data any) ([]byte, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/DVmM1G5JfuP)</span></b>
 
 ```go
 package main
@@ -606,7 +610,7 @@ func main() {
 func DecodeByte(data []byte, target any) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/zI6xsmuQRbn)</span></b>
 
 ```go
 package main
@@ -642,7 +646,7 @@ func main() {
 func DeepClone[T any](src T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/j4DP5dquxnk)</span></b>
 
 ```go
 package main
@@ -706,7 +710,7 @@ func main() {
 func CopyProperties[T, U any](dst T, src U) (err error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/oZujoB5Sgg5)</span></b>
 
 ```go
 package main
@@ -785,7 +789,7 @@ func main() {
 func ToInterface(v reflect.Value) (value interface{}, ok bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/syqw0-WG7Xd)</span></b>
 
 ```go
 package main
@@ -820,7 +824,7 @@ func main() {
 func Utf8ToGbk(bs []byte) ([]byte, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9FlIaFLArIL)</span></b>
 
 ```go
 package main
@@ -854,7 +858,7 @@ func main() {
 func GbkToUtf8(bs []byte) ([]byte, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OphmHCN_9u8)</span></b>
 
 ```go
 package main
@@ -876,3 +880,272 @@ func main() {
     // hello
 }
 ```
+
+### <span id="ToStdBase64">ToStdBase64</span>
+
+<p>将值转换为StdBase64编码的字符串。error类型的数据也会把error的原因进行编码，复杂的结构会转为JSON格式的字符串</p>
+
+<b>函数签名:</b>
+
+```go
+func ToStdBase64(value any) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_fLJqJD3NMo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    afterEncode := convertor.ToStdBase64(nil)
+    fmt.Println(afterEncode)
+
+    afterEncode = convertor.ToStdBase64("")
+    fmt.Println(afterEncode)
+
+    stringVal := "hello"
+    afterEncode = convertor.ToStdBase64(stringVal)
+    fmt.Println(afterEncode)
+
+    byteSliceVal := []byte("hello")
+    afterEncode = convertor.ToStdBase64(byteSliceVal)
+    fmt.Println(afterEncode)
+
+    intVal := 123
+    afterEncode = convertor.ToStdBase64(intVal)
+    fmt.Println(afterEncode)
+
+    mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+        A string
+        B int
+    }{"hello", 3}}
+    afterEncode = convertor.ToStdBase64(mapVal)
+    fmt.Println(afterEncode)
+
+    floatVal := 123.456
+    afterEncode = convertor.ToStdBase64(floatVal)
+    fmt.Println(afterEncode)
+
+    boolVal := true
+    afterEncode = convertor.ToStdBase64(boolVal)
+    fmt.Println(afterEncode)
+
+    errVal := errors.New("err")
+    afterEncode = convertor.ToStdBase64(errVal)
+    fmt.Println(afterEncode)
+
+    // Output:
+    //
+    //
+    // aGVsbG8=
+    // aGVsbG8=
+    // MTIz
+    // eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ==
+    // MTIzLjQ1Ng==
+    // dHJ1ZQ==
+    // ZXJy
+}
+
+```
+
+### <span id="ToUrlBase64">ToUrlBase64</span>
+
+<p>值转换为 ToUrlBase64 编码的字符串。error 类型的数据也会把 error 的原因进行编码，复杂的结构会转为 JSON 格式的字符串</p>
+
+<b>函数签名:</b>
+
+```go
+func ToUrlBase64(value any) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/C_d0GlvEeUR)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    afterEncode := convertor.ToUrlBase64(nil)
+    fmt.Println(afterEncode)
+
+
+    stringVal := "hello"
+    afterEncode = convertor.ToUrlBase64(stringVal)
+    fmt.Println(afterEncode)
+
+    byteSliceVal := []byte("hello")
+    afterEncode = convertor.ToUrlBase64(byteSliceVal)
+    fmt.Println(afterEncode)
+
+    intVal := 123
+    afterEncode = convertor.ToUrlBase64(intVal)
+    fmt.Println(afterEncode)
+
+    mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+        A string
+        B int
+    }{"hello", 3}}
+    afterEncode = convertor.ToUrlBase64(mapVal)
+    fmt.Println(afterEncode)
+
+    floatVal := 123.456
+    afterEncode = convertor.ToUrlBase64(floatVal)
+    fmt.Println(afterEncode)
+
+    boolVal := true
+    afterEncode = convertor.ToUrlBase64(boolVal)
+    fmt.Println(afterEncode)
+
+    errVal := errors.New("err")
+    afterEncode = convertor.ToUrlBase64(errVal)
+    fmt.Println(afterEncode)
+
+    // Output:
+    //
+    // aGVsbG8=
+    // aGVsbG8=
+    // MTIz
+    // eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ==
+    // MTIzLjQ1Ng==
+    // dHJ1ZQ==
+    // ZXJy
+}
+
+```
+
+### <span id="ToRawStdBase64">ToRawStdBase64</span>
+
+<p>值转换为 ToRawStdBase64 编码的字符串。error 类型的数据也会把 error 的原因进行编码，复杂的结构会转为 JSON 格式的字符串</p>
+
+<b>函数签名:</b>
+
+```go
+func ToRawStdBase64(value any) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/wSAr3sfkDcv)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+
+    stringVal := "hello"
+    afterEncode = convertor.ToRawStdBase64(stringVal)
+    fmt.Println(afterEncode)
+
+    byteSliceVal := []byte("hello")
+    afterEncode = convertor.ToRawStdBase64(byteSliceVal)
+    fmt.Println(afterEncode)
+
+    intVal := 123
+    afterEncode = convertor.ToRawStdBase64(intVal)
+    fmt.Println(afterEncode)
+
+    mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+        A string
+        B int
+    }{"hello", 3}}
+    afterEncode = convertor.ToRawStdBase64(mapVal)
+    fmt.Println(afterEncode)
+
+    floatVal := 123.456
+    afterEncode := convertor.ToRawStdBase64(floatVal)
+    fmt.Println(afterEncode)
+
+    boolVal := true
+    afterEncode = convertor.ToRawStdBase64(boolVal)
+    fmt.Println(afterEncode)
+
+    errVal := errors.New("err")
+    afterEncode = convertor.ToRawStdBase64(errVal)
+    fmt.Println(afterEncode)
+
+    // Output:
+    // aGVsbG8
+    // aGVsbG8
+    // MTIz
+    // eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ
+    // MTIzLjQ1Ng
+    // dHJ1ZQ
+    // ZXJy
+}
+```
+
+### <span id="ToRawUrlBase64">ToRawUrlBase64</span>
+
+<p>值转换为 ToRawUrlBase64 编码的字符串。error 类型的数据也会把 error 的原因进行编码，复杂的结构会转为 JSON 格式的字符串</p>
+
+<b>函数签名:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HwdDPFcza1O)</span></b>
+
+```go
+func ToRawUrlBase64(value any) string
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+
+    stringVal := "hello"
+    afterEncode := convertor.ToRawUrlBase64(stringVal)
+    fmt.Println(afterEncode)
+
+    byteSliceVal := []byte("hello")
+    afterEncode = convertor.ToRawUrlBase64(byteSliceVal)
+    fmt.Println(afterEncode)
+
+    intVal := 123
+    afterEncode = convertor.ToRawUrlBase64(intVal)
+    fmt.Println(afterEncode)
+
+    mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+        A string
+        B int
+    }{"hello", 3}}
+    afterEncode = convertor.ToRawUrlBase64(mapVal)
+    fmt.Println(afterEncode)
+
+    floatVal := 123.456
+    afterEncode = convertor.ToRawUrlBase64(floatVal)
+    fmt.Println(afterEncode)
+
+    boolVal := true
+    afterEncode = convertor.ToRawUrlBase64(boolVal)
+    fmt.Println(afterEncode)
+
+    errVal := errors.New("err")
+    afterEncode = convertor.ToRawUrlBase64(errVal)
+    fmt.Println(afterEncode)
+
+    // Output:
+    // aGVsbG8
+    // aGVsbG8
+    // MTIz
+    // eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ
+    // MTIzLjQ1Ng
+    // dHJ1ZQ
+    // ZXJy
+}
+```

docs/api/packages/cryptor.md

@@ -1,16 +1,18 @@
 # Cryptor
-cryptor加密包支持数据加密和解密，获取md5，hash值。支持base64, md5, hmac, aes, des, rsa。
+
+cryptor 包包含数据加密和解密功能。支持 base64, md5, hmac, hash, aes, des, rsa。
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 源码:
 
-- [https://github.com/duke-git/lancet/blob/main/cryptor/basic.go](https://github.com/duke-git/lancet/blob/main/cryptor/basic.go)
-- [https://github.com/duke-git/lancet/blob/main/cryptor/crypto.go](https://github.com/duke-git/lancet/blob/main/cryptor/crypto.go)
+-   [https://github.com/duke-git/lancet/blob/main/cryptor/basic.go](https://github.com/duke-git/lancet/blob/main/cryptor/basic.go)
+-   [https://github.com/duke-git/lancet/blob/main/cryptor/crypto.go](https://github.com/duke-git/lancet/blob/main/cryptor/crypto.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 用法:
+
 ```go
 import (
     "github.com/duke-git/lancet/v2/cryptor"
@@ -20,56 +22,57 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## 目录
-- [AesEcbEncrypt](#AesEcbEncrypt)
-- [AesEcbDecrypt](#AesEcbDecrypt)
-- [AesCbcEncrypt](#AesCbcEncrypt)
-- [AesCbcDecrypt](#AesCbcDecrypt)
-- [AesCtrCrypt](#AesCtrCrypt)
-- [AesCfbEncrypt](#AesCfbEncrypt)
-- [AesCfbDecrypt](#AesCfbDecrypt)
-- [AesOfbEncrypt](#AesOfbEncrypt)
-- [AesOfbDecrypt](#AesOfbDecrypt)
-- [Base64StdEncode](#Base64StdEncode)
-- [Base64StdDecode](#Base64StdDecode)
-- [DesEcbEncrypt](#DesEcbEncrypt)
-- [DesEcbDecrypt](#DesEcbDecrypt)
-- [DesCbcEncrypt](#DesCbcEncrypt)
-- [DesCbcDecrypt](#DesCbcDecrypt)
-- [DesCtrCrypt](#DesCtrCrypt)
-- [DesCfbEncrypt](#DesCfbEncrypt)
-- [DesCfbDecrypt](#DesCfbDecrypt)
-- [DesOfbEncrypt](#DesOfbEncrypt)
-- [DesOfbDecrypt](#DesOfbDecrypt)
-- [HmacMd5](#HmacMd5)
-- [HmacMd5WithBase64](#HmacMd5WithBase64)
-- [HmacSha1](#HmacSha1)
-- [HmacSha1WithBase64](#HmacSha1WithBase64)
-- [HmacSha256](#HmacSha256)
-- [HmacSha256WithBase64](#HmacSha256WithBase64)
-- [HmacSha512](#HmacSha512)
-- [HmacSha512WithBase64](#HmacSha512WithBase64)
-- [Md5String](#Md5String)
-- [Md5StringWithBase64](#Md5StringWithBase64)
-- [Md5Byte](#Md5Byte)
-- [Md5ByteWithBase64](#Md5ByteWithBase64)
-- [Md5File](#Md5File)
-- [Sha1](#Sha1)
-- [Sha1WithBase64](#Sha1WithBase64)
-- [Sha256](#Sha256)
-- [Sha256WithBase64](#Sha256WithBase64)
-- [Sha512](#Sha512)
-- [Sha512WithBase64](#Sha512WithBase64)
-- [GenerateRsaKey](#GenerateRsaKey)
-- [RsaEncrypt](#RsaEncrypt)
-- [RsaDecrypt](#RsaDecrypt)
 
+-   [AesEcbEncrypt](#AesEcbEncrypt)
+-   [AesEcbDecrypt](#AesEcbDecrypt)
+-   [AesCbcEncrypt](#AesCbcEncrypt)
+-   [AesCbcDecrypt](#AesCbcDecrypt)
+-   [AesCtrCrypt](#AesCtrCrypt)
+-   [AesCfbEncrypt](#AesCfbEncrypt)
+-   [AesCfbDecrypt](#AesCfbDecrypt)
+-   [AesOfbEncrypt](#AesOfbEncrypt)
+-   [AesOfbDecrypt](#AesOfbDecrypt)
+-   [Base64StdEncode](#Base64StdEncode)
+-   [Base64StdDecode](#Base64StdDecode)
+-   [DesEcbEncrypt](#DesEcbEncrypt)
+-   [DesEcbDecrypt](#DesEcbDecrypt)
+-   [DesCbcEncrypt](#DesCbcEncrypt)
+-   [DesCbcDecrypt](#DesCbcDecrypt)
+-   [DesCtrCrypt](#DesCtrCrypt)
+-   [DesCfbEncrypt](#DesCfbEncrypt)
+-   [DesCfbDecrypt](#DesCfbDecrypt)
+-   [DesOfbEncrypt](#DesOfbEncrypt)
+-   [DesOfbDecrypt](#DesOfbDecrypt)
+-   [HmacMd5](#HmacMd5)
+-   [HmacMd5WithBase64](#HmacMd5WithBase64)
+-   [HmacSha1](#HmacSha1)
+-   [HmacSha1WithBase64](#HmacSha1WithBase64)
+-   [HmacSha256](#HmacSha256)
+-   [HmacSha256WithBase64](#HmacSha256WithBase64)
+-   [HmacSha512](#HmacSha512)
+-   [HmacSha512WithBase64](#HmacSha512WithBase64)
+-   [Md5String](#Md5String)
+-   [Md5StringWithBase64](#Md5StringWithBase64)
+-   [Md5Byte](#Md5Byte)
+-   [Md5ByteWithBase64](#Md5ByteWithBase64)
+-   [Md5File](#Md5File)
+-   [Sha1](#Sha1)
+-   [Sha1WithBase64](#Sha1WithBase64)
+-   [Sha256](#Sha256)
+-   [Sha256WithBase64](#Sha256WithBase64)
+-   [Sha512](#Sha512)
+-   [Sha512WithBase64](#Sha512WithBase64)
+-   [GenerateRsaKey](#GenerateRsaKey)
+-   [RsaEncrypt](#RsaEncrypt)
+-   [RsaDecrypt](#RsaDecrypt)
+-   [GenerateRsaKeyPair](#GenerateRsaKeyPair)
+-   [RsaEncryptOAEP](#RsaEncryptOAEP)
+-   [RsaDecryptOAEP](#RsaDecryptOAEP)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 文档
 
-
-
 ### <span id="AesEcbEncrypt">AesEcbEncrypt</span>
 
 <p>使用AES ECB算法模式加密数据. 参数`key`的长度是16, 24 or 32。</p>
@@ -79,7 +82,8 @@ import (
 ```go
 func AesEcbEncrypt(data, key []byte) []byte
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/zI6xsmuQRbn)</span></b>
 
 ```go
 package main
@@ -112,7 +116,8 @@ func main() {
 ```go
 func AesEcbDecrypt(encrypted, key []byte) []byte
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/zI6xsmuQRbn)</span></b>
 
 ```go
 package main
@@ -145,7 +150,8 @@ func main() {
 ```go
 func AesCbcEncrypt(data, key []byte) []byte
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/IOq_g8_lKZD)</span></b>
 
 ```go
 package main
@@ -179,7 +185,7 @@ func main() {
 func AesCbcDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/IOq_g8_lKZD)</span></b>
 
 ```go
 package main
@@ -213,7 +219,7 @@ func main() {
 func AesCtrCrypt(data, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/SpaZO0-5Nsp)</span></b>
 
 ```go
 package main
@@ -247,7 +253,7 @@ func main() {
 func AesCfbEncrypt(data, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tfkF10B13kH)</span></b>
 
 ```go
 package main
@@ -281,7 +287,7 @@ func main() {
 func AesCfbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tfkF10B13kH)</span></b>
 
 ```go
 package main
@@ -315,7 +321,7 @@ func main() {
 func AesOfbEncrypt(data, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VtHxtkUj-3F)</span></b>
 
 ```go
 package main
@@ -338,6 +344,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="AesCfbDecrypt">AesOfbDecrypt</span>
 
 <p>使用AES OFB算法模式解密数据，参数`key`的长度是16, 24 or 32。</p>
@@ -348,7 +355,7 @@ func main() {
 func AesOfbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VtHxtkUj-3F)</span></b>
 
 ```go
 package main
@@ -381,7 +388,8 @@ func main() {
 ```go
 func Base64StdEncode(s string) string
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VOaUyQUreoK)</span></b>
 
 ```go
 package main
@@ -399,6 +407,7 @@ func main() {
     // aGVsbG8=
 }
 ```
+
 ### <span id="Base64StdDecode">Base64StdDecode</span>
 
 <p>解码base64字符串。</p>
@@ -409,7 +418,7 @@ func main() {
 func Base64StdDecode(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/RWQylnJVgIe)</span></b>
 
 ```go
 package main
@@ -438,7 +447,7 @@ func main() {
 func DesEcbEncrypt(data, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8qivmPeZy4P)</span></b>
 
 ```go
 package main
@@ -462,6 +471,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesEcbDecrypt">DesEcbDecrypt</span>
 
 <p>使用DES ECB算法模式解决密数据，参数`key`的长度是8。</p>
@@ -472,7 +482,7 @@ func main() {
 func DesEcbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8qivmPeZy4P)</span></b>
 
 ```go
 package main
@@ -507,7 +517,7 @@ func main() {
 func DesCbcEncrypt(data, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4cC4QvWfe3_1)</span></b>
 
 ```go
 package main
@@ -541,7 +551,7 @@ func main() {
 func DesCbcDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4cC4QvWfe3_1)</span></b>
 
 ```go
 package main
@@ -564,6 +574,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesCtrCrypt">DesCtrCrypt</span>
 
 <p>使用DES CTR算法模式加密/解密数据，参数`key`的长度是8</p>
@@ -574,7 +585,7 @@ func main() {
 func DesCtrCrypt(data, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9-T6OjKpcdw)</span></b>
 
 ```go
 package main
@@ -608,7 +619,7 @@ func main() {
 func DesCfbEncrypt(data, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/y-eNxcFBlxL)</span></b>
 
 ```go
 package main
@@ -631,6 +642,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesCfbDecrypt">DesCfbDecrypt</span>
 
 <p>使用DES CFB算法模式解决密数据，参数`key`的长度是8。</p>
@@ -641,7 +653,7 @@ func main() {
 func DesCfbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/y-eNxcFBlxL)</span></b>
 
 ```go
 package main
@@ -664,6 +676,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesOfbEncrypt">DesOfbEncrypt</span>
 
 <p>使用DES OFB算法模式加密数据，参数`key`的长度是8。</p>
@@ -674,7 +687,7 @@ func main() {
 func DesOfbEncrypt(data, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/74KmNadjN1J)</span></b>
 
 ```go
 package main
@@ -697,6 +710,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesOfbDecrypt">DesOfbDecrypt</span>
 
 <p>使用DES OFB算法模式解密数据，参数`key`的长度是8。</p>
@@ -707,7 +721,7 @@ func main() {
 func DesOfbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/74KmNadjN1J)</span></b>
 
 ```go
 package main
@@ -741,7 +755,7 @@ func main() {
 func HmacMd5(str, key string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uef0q1fz53I)</span></b>
 
 ```go
 package main
@@ -773,7 +787,7 @@ func main() {
 func HmacMd5WithBase64(str, key string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UY0ng2AefFC)</span></b>
 
 ```go
 package main
@@ -794,6 +808,7 @@ func main() {
     // 6DQwbquJLYclJdSRinpjmg==
 }
 ```
+
 ### <span id="HmacSha1">HmacSha1</span>
 
 <p>获取字符串的sha1 hmac值。</p>
@@ -804,7 +819,7 @@ func main() {
 func HmacSha1(str, key string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/1UI4oQ4WXKM)</span></b>
 
 ```go
 package main
@@ -836,7 +851,7 @@ func main() {
 func HmacSha1WithBase64(str, key string) string
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/47JmmGrnF7B)</span></b>
 
 ```go
 package main
@@ -858,7 +873,6 @@ func main() {
 }
 ```
 
-
 ### <span id="HmacSha256">HmacSha256</span>
 
 <p>获取字符串sha256 hmac值。</p>
@@ -869,7 +883,7 @@ func main() {
 func HmacSha256(str, key string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HhpwXxFhhC0)</span></b>
 
 ```go
 package main
@@ -901,7 +915,7 @@ func main() {
 func HmacSha256WithBase64(str, key string) string
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/EKbkUvPTLwO)</span></b>
 
 ```go
 package main
@@ -933,7 +947,7 @@ func main() {
 func HmacSha512(str, key string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/59Od6m4A0Ud)</span></b>
 
 ```go
 package main
@@ -965,7 +979,7 @@ func main() {
 func HmacSha512WithBase64(str, key string) string
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/c6dSe3E2ydU)</span></b>
 
 ```go
 package main
@@ -977,17 +991,16 @@ import (
 
 func main() {
     str := "hello"
-	key := "12345"
+    key := "12345"
 
-	hms := cryptor.HmacSha512WithBase64(str, key)
-	fmt.Println(hms)
+    hms := cryptor.HmacSha512WithBase64(str, key)
+    fmt.Println(hms)
 
-	// Output:
-	// 3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A==
+    // Output:
+    // 3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A==
 }
 ```
 
-
 ### <span id="Md5String">Md5String</span>
 
 <p>获取字符串md5值。</p>
@@ -998,7 +1011,7 @@ func main() {
 func Md5String(str string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/1bLcVetbTOI)</span></b>
 
 ```go
 package main
@@ -1029,7 +1042,7 @@ func main() {
 func Md5StringWithBase64(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Tcb-Z7LN2ax)</span></b>
 
 ```go
 package main
@@ -1041,10 +1054,10 @@ import (
 
 func main() {
     md5Str := cryptor.Md5StringWithBase64("hello")
-	fmt.Println(md5Str)
+    fmt.Println(md5Str)
 
-	// Output:
-	// XUFAKrxLKna5cZ2REBfFkg==
+    // Output:
+    // XUFAKrxLKna5cZ2REBfFkg==
 }
 ```
 
@@ -1058,7 +1071,7 @@ func main() {
 func Md5Byte(data []byte) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/suraalH8lyC)</span></b>
 
 ```go
 package main
@@ -1070,10 +1083,10 @@ import (
 
 func main() {
     md5Str := cryptor.Md5Byte([]byte{'a'})
-	fmt.Println(md5Str)
+    fmt.Println(md5Str)
 
-	// Output:
-	// 0cc175b9c0f1b6a831c399e269772661
+    // Output:
+    // 0cc175b9c0f1b6a831c399e269772661
 }
 ```
 
@@ -1087,7 +1100,7 @@ func main() {
 func Md5ByteWithBase64(data []byte) string
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Lx4gH7Vdr5_y)</span></b>
 
 ```go
 package main
@@ -1099,10 +1112,10 @@ import (
 
 func main() {
     md5Str := cryptor.Md5ByteWithBase64([]byte("hello"))
-	fmt.Println(md5Str)
+    fmt.Println(md5Str)
 
-	// Output:
-	// XUFAKrxLKna5cZ2REBfFkg==
+    // Output:
+    // XUFAKrxLKna5cZ2REBfFkg==
 }
 ```
 
@@ -1142,7 +1155,7 @@ func main() {
 func Sha1(str string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_m_uoD1deMT)</span></b>
 
 ```go
 package main
@@ -1173,7 +1186,7 @@ func main() {
 func Sha1WithBase64(str string) string
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fSyx-Gl2l2-)</span></b>
 
 ```go
 package main
@@ -1185,10 +1198,10 @@ import (
 
 func main() {
     result := cryptor.Sha1WithBase64("hello")
-	fmt.Println(result)
+    fmt.Println(result)
 
-	// Output:
-	// qvTGHdzF6KLavt4PO0gs2a6pQ00=
+    // Output:
+    // qvTGHdzF6KLavt4PO0gs2a6pQ00=
 }
 ```
 
@@ -1202,7 +1215,7 @@ func main() {
 func Sha256(str string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tU9tfBMIAr1)</span></b>
 
 ```go
 package main
@@ -1233,7 +1246,7 @@ func main() {
 func Sha256WithBase64(str string) string
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/85IXJHIal1k)</span></b>
 
 ```go
 package main
@@ -1245,10 +1258,10 @@ import (
 
 func main() {
     result := cryptor.Sha256WithBase64("hello")
-	fmt.Println(result)
+    fmt.Println(result)
 
-	// Output:
-	// LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=
+    // Output:
+    // LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=
 }
 ```
 
@@ -1262,7 +1275,7 @@ func main() {
 func Sha512(str string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3WsvLYZxsHa)</span></b>
 
 ```go
 package main
@@ -1293,7 +1306,7 @@ func main() {
 func Sha512WithBase64(str string) string
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/q_fY2rA-k5I)</span></b>
 
 ```go
 package main
@@ -1305,10 +1318,10 @@ import (
 
 func main() {
     result := cryptor.Sha512WithBase64("hello")
-	fmt.Println(result)
+    fmt.Println(result)
 
-	// Output:
-	// m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
+    // Output:
+    // m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
 }
 ```
 
@@ -1322,7 +1335,7 @@ func main() {
 func GenerateRsaKey(keySize int, priKeyFile, pubKeyFile string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/zutRHrDqs0X)</span></b>
 
 ```go
 package main
@@ -1350,7 +1363,7 @@ func main() {
 func RsaEncrypt(data []byte, pubKeyFileName string) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uef0q1fz53I)</span></b>
 
 ```go
 package main
@@ -1365,11 +1378,11 @@ func main() {
     if err != nil {
         return
     }
-      
+
     data := []byte("hello")
     encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
     decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
-      
+
     fmt.Println(string(decrypted))
 
     // Output:
@@ -1377,7 +1390,6 @@ func main() {
 }
 ```
 
-
 ### <span id="RsaDecrypt">RsaDecrypt</span>
 
 <p>用私钥文件rsa解密数据。</p>
@@ -1388,7 +1400,7 @@ func main() {
 func RsaDecrypt(data []byte, privateKeyFileName string) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uef0q1fz53I)</span></b>
 
 ```go
 package main
@@ -1403,14 +1415,125 @@ func main() {
     if err != nil {
         return
     }
-      
+
     data := []byte("hello")
     encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
     decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
-      
+
     fmt.Println(string(decrypted))
 
     // Output:
     // hello
 }
-```
+```
+
+### <span id="GenerateRsaKeyPair">GenerateRsaKeyPair</span>
+
+<p>创建rsa公钥私钥和key。</p>
+
+<b>函数签名:</b>
+
+```go
+func GenerateRsaKeyPair(keySize int) (*rsa.PrivateKey, *rsa.PublicKey)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sSVmkfENKMz)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    pri, pub := cryptor.GenerateRsaKeyPair(1024)
+}
+```
+
+### <span id="RsaEncryptOAEP">RsaEncryptOAEP</span>
+
+<p>rsa OAEP加密。</p>
+
+<b>函数签名:</b>
+
+```go
+func RsaEncryptOAEP(data []byte, label []byte, key rsa.PublicKey) ([]byte, error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sSVmkfENKMz)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    pri, pub := cryptor.GenerateRsaKeyPair(1024)
+
+    data := []byte("hello world")
+    label := []byte("123456")
+
+    encrypted, err := cryptor.RsaEncryptOAEP(data, label, *pub)
+    if err != nil {
+        return
+    }
+
+    decrypted, err := cryptor.RsaDecryptOAEP([]byte(encrypted), label, *pri)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(string(decrypted))
+
+    // Output:
+    // hello world
+}
+```
+
+### <span id="RsaDecryptOAEP">RsaDecryptOAEP</span>
+
+<p>rsa OAEP解密。</p>
+
+<b>函数签名:</b>
+
+```go
+func RsaDecryptOAEP(ciphertext []byte, label []byte, key rsa.PrivateKey) ([]byte, error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sSVmkfENKMz)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    pri, pub := cryptor.GenerateRsaKeyPair(1024)
+
+    data := []byte("hello world")
+    label := []byte("123456")
+
+    encrypted, err := cryptor.RsaEncryptOAEP(data, label, *pub)
+    if err != nil {
+        return
+    }
+
+    decrypted, err := cryptor.RsaDecryptOAEP([]byte(encrypted), label, *pri)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(string(decrypted))
+
+    // Output:
+    // hello world
+}
+```

docs/api/packages/datastructure/copyonwritelist.md

@@ -0,0 +1,525 @@
+# CopyOnWriteList
+
+CopyOnWriteList 是一个线程安全的 List 实现，底层使用 go 切片。写入时，会复制一份新的切片，写入完成后，再将新的切片赋值给原来的切片。读取时，直接读取原来的切片。
+
+## 源码
+
+-   [https://github.com/duke-git/lancet/blob/main/datastructure/list/copyonwritelist.go](https://github.com/duke-git/lancet/blob/main/datastructure/list/copyonwritelist.go)
+
+## 用法
+
+```go
+import (
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [NewCopyOnWriteList](#NewCopyOnWriteList)
+-   [Size](#Size)
+-   [Get](#Get)
+-   [Set](#Set)
+-   [Remove](#Remove)
+-   [IndexOf](#IndexOf)
+-   [LastIndexOf](#LastIndexOf)
+-   [IndexOfFunc](#IndexOfFunc)
+-   [LastIndexOfFunc](#LastIndexOfFunc)
+-   [IsEmpty](#IsEmpty)
+-   [Contain](#Contain)
+-   [ValueOf](#ValueOf)
+-   [Add](#Add)
+-   [AddAll](#AddAll)
+-   [AddByIndex](#AddByIndex)
+-   [DeleteAt](#DeleteAt)
+-   [DeleteIf](#DeleteIf)
+-   [DeleteBy](#DeleteBy)
+-   [DeleteRange](#DeleteRange)
+-   [Equal](#Equal)
+
+## 文档
+
+### NewCopyOnWriteList
+
+返回一个具有空切片的 CopyOnWriteList。
+
+```go
+type CopyOnWriteList[T any] struct {
+    data []T
+    lock sync.Locker
+}
+
+func NewCopyOnWriteList() *CopyOnWriteList
+
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l)
+}
+
+```
+
+### Size
+
+返回 CopyOnWriteList 的长度。
+
+```go
+func (l *CopyOnWriteList[T]) Size() int
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Size())
+}
+
+```
+
+### Get
+
+返回列表中指定位置的元素
+
+```go
+func (c *CopyOnWriteList[T]) Get(index int) *T
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+	fmt.Println(l.Get(2))
+}
+
+```
+
+### Set
+
+将此列表中指定位置的元素替换为指定元素。
+
+```go
+func (c *CopyOnWriteList[T]) Set(index int, e T) (oldValue *T, ok bool)
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Set(2, 4))
+}
+
+```
+
+### Remove
+
+### IndexOf
+
+返回列表中值的索引，如果没有找到返回-1。
+
+```go
+func (c *CopyOnWriteList[T]) IndexOf(e T) int
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.IndexOf(1))
+}
+
+```
+
+### LastIndexOf
+
+返回指定元素在此列表中最后出现的索引，如果此列表不包含该元素，则返回-1。
+
+```go
+func (c *CopyOnWriteList[T]) LastIndexOf(e T) int
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3,1})
+	fmt.Println(l.LastIndexOf(1))
+}
+
+```
+
+### <span id="IndexOfFunc">IndexOfFunc</span>
+<p>返回第一个满足判断函数f(v)的元素的索引，如果找不到则返回-1。</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *CopyOnWriteList[T]) IndexOfFunc(f func(T) bool) int 
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1, 2, 3})
+
+    fmt.Println(l.IndexOfFunc(func(a int) bool { return a == 1 })) //0
+    fmt.Println(l.IndexOfFunc(func(a int) bool { return a == 0 })) //-1
+}
+```
+
+### <span id="LastIndexOfFunc">LastIndexOfFunc</span>
+<p>返回最后一个满足判断函数f(v)的元素的索引，如果找不到则返回-1。</p>
+
+<b>函数签名:</b>
+
+```go
+func (l *CopyOnWriteList[T]) LastIndexOfFunc(f func(T) bool) int
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1, 2, 3, 1})
+
+    fmt.Println(l.LastIndexOfFunc(func(a int) bool { return a == 1 })) // 3
+    fmt.Println(l.LastIndexOfFunc(func(a int) bool { return a == 0 })) //-1
+}
+```
+
+### IsEmpty
+
+如果此列表不包含任何元素，则返回 true。
+
+```go
+func (c *CopyOnWriteList[T]) IsEmpty() bool
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{})
+	fmt.Println(l.IsEmpty())
+}
+```
+
+### Contain
+
+判断 CopyOnWriteList 是否包含某个元素
+
+```go
+func (c *CopyOnWriteList[T]) Contain(e T) bool
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Contain(1))
+}
+```
+
+### ValueOf
+
+返回列表中索引处的值指针
+
+```go
+func (c *CopyOnWriteList[T]) ValueOf(index int) []T
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.ValueOf(2))
+}
+
+```
+
+### Add
+
+将指定的元素追加到此列表的末尾。
+
+```go
+func (c *CopyOnWriteList[T]) Add(e T) bool
+```
+
+#### 示例
+
+```go
+
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+	l.Add(4)
+	fmt.Println(l.getList())
+}
+
+```
+
+### AddAll
+
+将指定集合中的所有元素追加到此列表的末尾
+
+```go
+func (c *CopyOnWriteList[T]) AddAll(e []T) bool
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    l.AddAll([]int{4,5,6})
+    fmt.Println(l.getList())
+}
+
+```
+
+### AddByIndex
+
+将指定元素插入此列表中的指定位置。
+
+```go
+func (c *CopyOnWriteList[T]) AddByIndex(index int, e T) bool
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+	list.AddByIndex(2, 6)
+	fmt.Println(l.getList())
+}
+
+```
+
+### DeleteAt
+
+移除此列表中指定位置的元素。
+
+```go
+func (c *CopyOnWriteList[T]) DeleteAt(index int) (oldValue *T, ok bool)
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+	list.DeleteAt(2)
+	fmt.Println(l.getList())
+}
+```
+
+### DeleteIf
+
+从此列表中删除第一个出现的指定元素(如果该元素存在)。
+
+```go
+func (c *CopyOnWriteList[T]) DeleteIf(f func(T) bool) (oldValue *T, ok bool)
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.DeleteIf(func(i int) bool {
+        return i == 2
+    })
+    fmt.Println(l.getList())
+}
+```
+
+### DeleteBy
+
+从此列表中删除第一个出现的指定元素(如果该元素存在)。
+
+```go
+func (c *CopyOnWriteList[T]) DeleteBy(e T) (*T bool)
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.DeleteBy(2)
+    fmt.Println(l.getList())
+}
+```
+
+### DeleteRange
+
+从该列表中删除索引介于 fromIndex(包含)和 toIndex(不包含)之间的所有元素。
+(左闭右开)。
+
+```go
+func (c *CopyOnWriteList[T]) DeleteRange(start int, end int)
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3,4,5,6,7,8,9})
+    list.DeleteRange(2, 5)
+    fmt.Println(l.getList())
+}
+```
+
+### Equal
+
+如果指定的对象等于此列表，则返回 true。
+
+```go
+func (c *CopyOnWriteList[T]) Equal(e []T) bool
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3,4,5,6,7,8,9})
+    fmt.Println(l.Equal([]int{1,2,3,4,5,6,7,8,9}))
+}
+```

docs/api/packages/datastructure/hashmap.md

@@ -31,6 +31,7 @@ import (
 - [Iterate](#Iterate)
 - [Keys](#Keys)
 - [Values](#Values)
+- [FilterByValue](#FilterByValue)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -38,7 +39,7 @@ import (
 
 ### <span id="NewHashMap">NewHashMap</span>
 
-<p>新建默认容量（1 << 10）的HashMap指针实例</p>
+<p>新建默认容量（1 &lt&lt 10）的HashMap指针实例</p>
 
 <b>函数签名:</b>
 
@@ -276,7 +277,7 @@ func main() {
 
 ### <span id="Values">Values</span>
 
-<p>返回hashmap所有值的切片 (随机顺序).</p>
+<p>返回hashmap所有值的切片 (随机顺序)。</p>
 
 <b>函数签名:</b>
 
@@ -306,3 +307,40 @@ func main() {
 ```
 
 
+### <span id="FilterByValue">FilterByValue</span>
+
+<p>返回一个过滤后的HashMap。 如果任何值与 perdicate 函数不匹配，则返回 nil，否则返回包含选定值的 HashMap。</p>
+
+<b>函数签名:</b>
+
+```go
+func (hm *HashMap) FilterByValue(perdicate func(value any) bool) *HashMap
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := hashmap.NewHashMap()
+
+    hm.Put("a", 1)
+    hm.Put("b", 2)
+    hm.Put("c", 3)
+    hm.Put("d", 4)
+    hm.Put("e", 5)
+    hm.Put("f", 6)
+
+    filteredHM := hm.FilterByValue(func(value any) bool {
+        return value.(int) == 1 || value.(int) == 3
+    })
+
+    fmt.Println(filteredHM.Size()) //2
+}
+```

docs/api/packages/datastructure/heap.md

@@ -44,9 +44,9 @@ MaxHeap是通过slice实现的二叉堆树，根节点的key既大于等于左
 ```go
 type MaxHeap[T any] struct {
 	data       []T
-	comparator lancetconstraints.Comparator
+	comparator constraints.Comparator
 }
-func NewMaxHeap[T any](comparator lancetconstraints.Comparator) *MaxHeap[T]
+func NewMaxHeap[T any](comparator constraints.Comparator) *MaxHeap[T]
 ```
 <b>示例:</b>
 

docs/api/packages/datastructure/optional.md

@@ -0,0 +1,412 @@
+# Optional
+Optional类型代表一个可选的值，它要么包含一个实际值，要么为空。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码
+
+- [https://github.com/duke-git/lancet/blob/main/datastructure/optional/optional.go](https://github.com/duke-git/lancet/blob/main/datastructure/optional/optional.go)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法
+```go
+import (
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+- [Of](#Of)
+- [FromNillable](#FromNillable)
+- [Default](#Default)
+- [IsNotNil](#IsNotNil)
+- [IsNil](#IsNil)
+- [IsNotNil](#IsNotNil)
+- [IfNotNilOrElse](#IfNotNilOrElse)
+- [Umwarp](#Umwarp)
+- [OrElse](#OrElse)
+- [OrElseGet](#OrElseGet)
+- [OrElseTrigger](#OrElseTrigger)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+### <span id="Of">Of</span>
+<p>返回一个包含非空值的Optional。</p>
+
+<b>函数签名:</b>
+
+```go
+func Of[T any](value T) Optional[T]
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    value := 42
+    opt := optional.Of(value)
+
+    fmt.Println(opt.Get())
+
+    // Output:
+    // 42
+}
+```
+
+### <span id="FromNillable">FromNillable</span>
+<p>返回一个包含给定值的Optional，该值可能为空 (nil)。</p>
+
+<b>函数签名:</b>
+
+```go
+func FromNillable[T any](value *T) Optional[T]
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    var value *int = nil
+    opt := optional.FromNillable(value)
+
+    fmt.Println(opt.IsNotNil())
+
+    value = new(int)
+    *value = 42
+    opt = optional.FromNillable(value)
+
+    fmt.Println(opt.IsNotNil())
+
+
+    // Output:
+    // false
+    // true
+}
+```
+
+
+### <span id="Default">Default</span>
+<p>返回一个空Optional实例。</p>
+
+<b>函数签名:</b>
+
+```go
+func Default[T any]() Optional[T]
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    optDefault := optional.Default[int]()
+    fmt.Println(optDefault.IsNil())
+
+    // Output:
+    // true
+}
+```
+
+
+### <span id="IsNil">IsNil</span>
+<p>验证Optional是否为空。</p>
+
+<b>函数签名:</b>
+
+```go
+func (o Optional[T]) IsNil() bool
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    optDefault := optional.Default[int]()
+    fmt.Println(optDefault.IsNil())
+
+    // Output:
+    // true
+}
+```
+
+### <span id="IsNotNil">IsNotNil</span>
+<p>检查当前Optional内是否存在值。</p>
+
+<b>函数签名:</b>
+
+```go
+func (o Optional[T]) IsNotNil() bool
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    var value *int = nil
+    opt := optional.FromNillable(value)
+
+    fmt.Println(opt.IsNotNil())
+
+    value = new(int)
+    *value = 42
+    opt = optional.FromNillable(value)
+
+    fmt.Println(opt.IsNotNil())
+
+
+    // Output:
+    // false
+    // true
+}
+```
+
+### <span id="IfNotNil">IfNotNil</span>
+<p>如果值存在，则使用action方法执行给定的操作。</p>
+
+<b>函数签名:</b>
+
+```go
+func (o Optional[T]) IfNotNil(action func(value T))
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+     "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    called := false
+    action := func(value int) { called = true }
+
+    optDefault := optional.Default[int]()
+    optDefault.IfNotNil(action)
+
+    fmt.Println(called)
+
+    called = false // Reset for next test
+    optWithValue := optional.Of(42)
+    optWithValue.IfNotNil(action)
+
+    fmt.Println(optWithValue.IsNotNil())
+
+    // Output:
+    // false
+    // true
+}
+```
+
+
+### <span id="IfNotNilOrElse">IfNotNilOrElse</span>
+<p>根据是否存在值执行相应的操作：有值则执行指定操作，没有值则执行默认操作。</p>
+
+<b>函数签名:</b>
+
+```go
+func (o Optional[T]) IfNotNilOrElse(action func(value T), fallbackAction func())
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    calledWithValue := false
+    valueAction := func(value int) { calledWithValue = true }
+    emptyAction := func() { t.Errorf("Empty action should not be called when value is present") }
+
+    optWithValue := optional.Of(42)
+    optWithValue.IfNotNilOrElse(valueAction, emptyAction)
+
+    fmt.Println(calledWithValue)
+
+    calledWithEmpty := false
+    valueAction = func(value int) { t.Errorf("Value action should not be called when value is not present") }
+    emptyAction = func() { calledWithEmpty = true }
+
+    optDefault := optional.Default[int]()
+    optDefault.IfNotNilOrElse(valueAction, emptyAction)
+
+    fmt.Println(calledWithEmpty)
+
+    // Output:
+    // true
+    // true
+}
+```
+
+### <span id="Unwrap">Unwrap</span>
+<p>如果存在，返回该值，否则引发panic。</p>
+
+<b>函数签名:</b>
+
+```go
+func (o Optional[T]) Unwrap() T
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    value := 42
+    opt := optional.Of(value)
+
+    fmt.Println(opt.Unwrap())
+
+    // Output:
+    // 42
+}
+```
+
+
+### <span id="OrElse">OrElse</span>
+<p>检查Optional值是否存在，如果存在，则直接返回该值。如果不存在，返回参数other值。</p>
+
+<b>函数签名:</b>
+
+```go
+func (o Optional[T]) OrElse(other T) T
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    optDefault := optional.Empty[int]()
+    val := optDefault.OrElse(100)
+    fmt.Println(val)
+
+    optWithValue := optional.Of(42)
+    val = optWithValue.OrElse(100)
+    fmt.Println(val)
+
+    // Output:
+    // 100
+    // 42
+}
+```
+
+
+### <span id="OrElseGet">OrElseGet</span>
+<p>检查Optional值是否存在，如果存在，则直接返回该值。如果不存在，则调用一个提供的函数 (supplier)，并返回该函数的执行结果。</p>
+
+<b>函数签名:</b>
+
+```go
+func (o Optional[T]) OrElseGet(action func() T) T
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    optDefault := optional.Default[int]()
+    action := func() int { return 100 }
+
+    val := optDefault.OrElseGet(action)
+    fmt.Println(val)
+
+    // Output:
+    // 100
+}
+```
+
+### <span id="OrElseTrigger">OrElseTrigger</span>
+<p>检查Optional值是否存在，如果存在，则直接返回该值，否则返回错误。</p>
+
+<b>函数签名:</b>
+
+```go
+ OrElseTrigger(errorHandler func() error) (T, error)
+```
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    optDefault := optional.Default[int]()
+    _, err := optDefault.OrElseTrigger(func() error { return errors.New("no value") })
+    
+    fmt.Println(err.Error())
+
+    optWithValue := optional.Of(42)
+    val, err := optWithValue.OrElseTrigger(func() error { return errors.New("no value") })
+
+    fmt.Println(val)
+    fmt.Println(err)
+
+    // Output:
+    // no value
+    // 42
+    // nil
+}
+```

docs/api/packages/datastructure/queue.md

@@ -1100,12 +1100,12 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func NewPriorityQueue[T any](capacity int, comparator lancetconstraints.Comparator) *PriorityQueue[T]
+func NewPriorityQueue[T any](capacity int, comparator constraints.Comparator) *PriorityQueue[T]
 
 type PriorityQueue[T any] struct {
 	items      []T
 	size       int
-	comparator lancetconstraints.Comparator
+	comparator constraints.Comparator
 }
 ```
 <b>示例:</b>

docs/api/packages/datastructure/set.md

@@ -1,6 +1,6 @@
 # Set
 
-Set 集合数据结构，类似列表。Set 中元素不重复。
+集合数据结构，类似列表。Set中元素不重复。
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -22,8 +22,8 @@ import (
 
 ## 目录
 
--   [NewSet](#NewSet)
--   [NewSetFromSlice](#NewSetFromSlice)
+-   [New](#New)
+-   [FromSlice](#FromSlice)
 -   [Values](#Values)
 -   [Add](#Add)
 -   [AddIfNotExist](#AddIfNotExist)
@@ -40,20 +40,23 @@ import (
 -   [Intersection](#Intersection)
 -   [SymmetricDifference](#SymmetricDifference)
 -   [Minus](#Minus)
+-   [Pop](#Pop)
+-   [ToSlice](#ToSlice)
+-   [ToSortedSlice](#ToSortedSlice)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 文档
 
-### <span id="NewSet">NewSet</span>
+### <span id="New">New</span>
 
 <p>返回Set结构体对象</p>
 
 <b>函数签名:</b>
 
 ```go
-type Set[T comparable] map[T]bool
-func NewSet[T comparable](items ...T) Set[T]
+type Set[T comparable] map[T]struct{}
+func New[T comparable](items ...T) Set[T]
 ```
 
 <b>示例:</b>
@@ -67,19 +70,19 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int](1,2,2,3)
+    st := set.New[int](1,2,2,3)
     fmt.Println(st.Values()) //1,2,3
 }
 ```
 
-### <span id="NewSetFromSlice">NewSetFromSlice</span>
+### <span id="FromSlice">FromSlice</span>
 
 <p>基于切片创建集合</p>
 
 <b>函数签名:</b>
 
 ```go
-func NewSetFromSlice[T comparable](items []T) Set[T]
+func FromSlice[T comparable](items []T) Set[T]
 ```
 
 <b>示例:</b>
@@ -93,14 +96,15 @@ import (
 )
 
 func main() {
-    st := set.NewSetFromSlice([]int{1, 2, 2, 3})
+    st := set.FromSlice([]int{1, 2, 2, 3})
     fmt.Println(st.Values()) //1,2,3
 }
 ```
 
-### <span id="Values">Values</span>
+### <span id="Values">Values<sup>deprecated</sup></span>
 
-<p>获取集合中所有元素的切片</p>
+<p>获取集合中所有元素的切片<br>
+<a href='#ToSlice'>ToSlice()</a> 方法提供与 Values 方法相同的功能</p>
 
 <b>函数签名:</b>
 
@@ -119,7 +123,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int](1,2,2,3)
+    st := set.New[int](1,2,2,3)
     fmt.Println(st.Values()) //1,2,3
 }
 ```
@@ -145,7 +149,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2, 3)
 
     fmt.Println(st.Values()) //1,2,3
@@ -173,7 +177,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2, 3)
 
     r1 := st.AddIfNotExist(1)
@@ -206,7 +210,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2)
 
     ok := st.AddIfNotExistBy(3, func(val int) bool {
@@ -245,7 +249,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2, 3)
 
     set.Delete(3)
@@ -274,7 +278,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2, 3)
 
     fmt.Println(st.Contain(1)) //true
@@ -303,9 +307,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(1, 2)
-    set3 := set.NewSet(1, 2, 3, 4)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(1, 2)
+    set3 := set.New(1, 2, 3, 4)
 
     fmt.Println(set1.ContainAll(set2)) //true
     fmt.Println(set1.ContainAll(set3)) //false
@@ -333,7 +337,7 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
 
     fmt.Println(set1.Size()) //3
 }
@@ -360,7 +364,7 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
     set2 := set1.Clone()
 
     fmt.Println(set1.Size() == set2.Size()) //true
@@ -389,9 +393,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(1, 2, 3)
-    set3 := set.NewSet(1, 2, 3, 4)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(1, 2, 3)
+    set3 := set.New(1, 2, 3, 4)
 
     fmt.Println(set1.Equal(set2)) //true
     fmt.Println(set1.Equal(set3)) //false
@@ -419,7 +423,7 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
     arr := []int{}
     set.Iterate(func(item int) {
         arr = append(arr, item)
@@ -450,7 +454,7 @@ import (
 )
 
 func main() {
-    s := set.NewSet(1, 2, 3, 4, 5)
+    s := set.New(1, 2, 3, 4, 5)
 
     var sum int
 
@@ -487,8 +491,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet()
+    set1 := set.New(1, 2, 3)
+    set2 := set.New()
 
     fmt.Println(set1.IsEmpty()) //false
     fmt.Println(set2.IsEmpty()) //true
@@ -516,8 +520,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.Union(set2)
 
     fmt.Println(set3.Values()) //1,2,3,4,5
@@ -545,8 +549,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.Intersection(set2)
 
     fmt.Println(set3.Values()) //2,3
@@ -574,8 +578,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.SymmetricDifference(set2)
 
     fmt.Println(set3.Values()) //1,4,5
@@ -603,9 +607,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
-    set3 := set.NewSet(2, 3)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
+    set3 := set.New(2, 3)
 
     res1 := set1.Minus(set2)
     fmt.Println(res1.Values()) //1
@@ -636,7 +640,7 @@ import (
 )
 
 func main() {
-    s := set.NewSet[int]()
+    s := set.New[int]()
     s.Add(1)
     s.Add(2)
     s.Add(3)
@@ -647,3 +651,58 @@ func main() {
     fmt.Println(ok) // true
 }
 ```
+
+### <span id="ToSlice">ToSlice</span>
+
+<p>以切片的形式返回集合中所有的元素（无序）</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) ToSlice() (v T, ok bool)
+```
+
+<b>示例:</b>
+
+```go
+func main() {
+    s := set.New(1, 2, 3, 4, 5)
+
+    val := s.ToSlice()
+    fmt.Println(val) // [2 3 4 5 1]
+}
+```
+
+### <span id="ToSortedSlice">ToSortedSlice</span>
+
+<p>以切片的形式返回集合中所有的元素（按给定的规则排序）</p>
+
+<b>函数签名:</b>
+
+```go
+func (s Set[T]) ToSortedSlice() (v T, ok bool)
+```
+
+<b>示例:</b>
+
+```go
+func main() {
+    s1 := set.New(1, 2, 3, 4, 5)
+    type Person struct {
+		Name string
+		Age  int
+	}
+	s2 := FromSlice([]Person{{"Tom", 20}, {"Jerry", 18}, {"Spike", 25}})
+
+    res1 := s1.ToSortedSlice(func(v1, v2 int) bool {
+		return v1 < v2
+	})
+    
+    res2 := s2.ToSortedSlice(func(v1, v2 Person) bool {
+		return v1.Age < v2.Age
+	})
+    
+    fmt.Println(res1) // [1 2 3 4 5]
+    fmt.Println(res2) // [{Jerry 18} {Tom 20} {Spike 25}]
+}
+```

docs/api/packages/datastructure/tree.md

@@ -41,7 +41,7 @@ import (
 ## 文档
 
 ## 1. BSTree
-BSTree是一种二叉搜索树数据结构，其中每个节点有两个孩子，分别称为左孩子和右孩子。 在 BSTree 中：leftNode < rootNode < rightNode。 T类型应该实现lancetconstraints.Comparator。
+BSTree是一种二叉搜索树数据结构，其中每个节点有两个孩子，分别称为左孩子和右孩子。 在 BSTree 中：leftNode < rootNode < rightNode。 T类型应该实现constraints.Comparator。
 
 ### <span id="NewBSTree">NewBSTree</span>
 <p>返回BSTree指针实例</p>
@@ -49,11 +49,11 @@ BSTree是一种二叉搜索树数据结构，其中每个节点有两个孩子
 <b>函数签名:</b>
 
 ```go
-func NewBSTree[T any](rootData T, comparator lancetconstraints.Comparator) *BSTree[T]
+func NewBSTree[T any](rootData T, comparator constraints.Comparator) *BSTree[T]
 
 type BSTree[T any] struct {
 	root       *datastructure.TreeNode[T]
-	comparator lancetconstraints.Comparator
+	comparator constraints.Comparator
 }
 
 type TreeNode[T any] struct {

docs/api/packages/datetime.md

@@ -106,7 +106,7 @@ import (
 func AddDay(t time.Time, day int64) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dIGbs_uTdFa)</span></b>
 
 ```go
 package main
@@ -145,7 +145,7 @@ func main() {
 func AddHour(t time.Time, hour int64) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/rcMjd7OCsi5)</span></b>
 
 ```go
 package main
@@ -184,7 +184,7 @@ func main() {
 func AddMinute(t time.Time, minute int64) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nT1heB1KUUK)</span></b>
 
 ```go
 package main
@@ -223,7 +223,7 @@ func main() {
 func AddYear(t time.Time, year int64) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/MqW2ujnBx10)</span></b>
 
 ```go
 package main
@@ -262,7 +262,7 @@ func main() {
 func BeginOfMinute(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ieOLVJ9CiFT)</span></b>
 
 ```go
 package main
@@ -294,7 +294,7 @@ func main() {
 func BeginOfHour(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GhdGFnDWpYs)</span></b>
 
 ```go
 package main
@@ -326,7 +326,7 @@ func main() {
 func BeginOfDay(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/94m_UT6cWs9)</span></b>
 
 ```go
 package main
@@ -358,7 +358,7 @@ func main() {
 func BeginOfWeek(t time.Time, beginFrom ...time.Weekday) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ynjoJPz7VNV)</span></b>
 
 ```go
 package main
@@ -390,7 +390,7 @@ func main() {
 func BeginOfMonth(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/bWXVFsmmzwL)</span></b>
 
 ```go
 package main
@@ -422,7 +422,7 @@ func main() {
 func BeginOfYear(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/i326DSwLnV8)</span></b>
 
 ```go
 package main
@@ -454,7 +454,7 @@ func main() {
 func EndOfMinute(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/yrL5wGzPj4z)</span></b>
 
 ```go
 package main
@@ -486,7 +486,7 @@ func main() {
 func EndOfHour(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/6ce3j_6cVqN)</span></b>
 
 ```go
 package main
@@ -518,7 +518,7 @@ func main() {
 func EndOfDay(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/eMBOvmq5Ih1)</span></b>
 
 ```go
 package main
@@ -550,7 +550,7 @@ func main() {
 func EndOfWeek(t time.Time, endWith ...time.Weekday) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/i08qKXD9flf)</span></b>
 
 ```go
 package main
@@ -582,7 +582,7 @@ func main() {
 func EndOfMonth(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_GWh10B3Nqi)</span></b>
 
 ```go
 package main
@@ -614,7 +614,7 @@ func main() {
 func EndOfYear(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/G01cKlMCvNm)</span></b>
 
 ```go
 package main
@@ -646,7 +646,7 @@ func main() {
 func GetNowDate() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/PvfkPpcpBBf)</span></b>
 
 ```go
 package main
@@ -675,7 +675,7 @@ func main() {
 func GetNowTime() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/l7BNxCkTmJS)</span></b>
 
 ```go
 package main
@@ -704,7 +704,7 @@ func main() {
 func GetNowDateTime() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pI4AqngD0al)</span></b>
 
 ```go
 package main
@@ -733,7 +733,7 @@ func main() {
 func GetTodayStartTime() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/84siyYF7t99)</span></b>
 
 ```go
 package main
@@ -762,7 +762,7 @@ func main() {
 func GetTodayEndTime() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jjrLnfoqgn3)</span></b>
 
 ```go
 package main
@@ -791,7 +791,7 @@ func main() {
 func GetZeroHourTimestamp() int64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/QmL2oIaGE3q)</span></b>
 
 ```go
 package main
@@ -820,7 +820,7 @@ func main() {
 func GetNightTimestamp() int64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UolysR3MYP1)</span></b>
 
 ```go
 package main
@@ -849,7 +849,7 @@ func main() {
 func FormatTimeToStr(t time.Time, format string, timezone ...string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_Ia7M8H_OvE)</span></b>
 
 ```go
 package main
@@ -888,7 +888,7 @@ func main() {
 func FormatStrToTime(str, format string, timezone ...string) (time.Time, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/1h9FwdU8ql4)</span></b>
 
 ```go
 package main
@@ -927,7 +927,7 @@ type theTime struct {
 func NewUnixNow() *theTime
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/U4PPx-9D0oz)</span></b>
 
 ```go
 package main
@@ -959,7 +959,7 @@ type theTime struct {
 func NewUnix(unix int64) *theTime
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/psoSuh_kLRt)</span></b>
 
 ```go
 package main
@@ -991,7 +991,7 @@ type theTime struct {
 func NewFormat(t string) (*theTime, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VkW08ZOaXPZ)</span></b>
 
 ```go
 package main
@@ -1023,7 +1023,7 @@ type theTime struct {
 func NewISO8601(iso8601 string) (*theTime, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/mkhOHQkdeA2)</span></b>
 
 ```go
 package main
@@ -1052,7 +1052,7 @@ func main() {
 func (t *theTime) ToUnix() int64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_LUiwAdocjy)</span></b>
 
 ```go
 package main
@@ -1081,7 +1081,7 @@ func main() {
 func (t *theTime) ToFormat() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VkW08ZOaXPZ)</span></b>
 
 ```go
 package main
@@ -1110,7 +1110,7 @@ func main() {
 func (t *theTime) ToFormatForTpl(tpl string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nyXxXcQJ8L5)</span></b>
 
 ```go
 package main
@@ -1140,7 +1140,7 @@ func main() {
 func (t *theTime) ToIso8601() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/mkhOHQkdeA2)</span></b>
 
 ```go
 package main
@@ -1170,7 +1170,7 @@ func main() {
 func IsLeapYear(year int) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/xS1eS2ejGew)</span></b>
 
 ```go
 package main
@@ -1203,7 +1203,7 @@ func main() {
 func BetweenSeconds(t1 time.Time, t2 time.Time) int64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/n3YDRyfyXJu)</span></b>
 
 ```go
 package main
@@ -1240,7 +1240,7 @@ func main() {
 func DayOfYear(t time.Time) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/0hjqhTwFNlH)</span></b>
 
 ```go
 package main
@@ -1281,7 +1281,7 @@ func main() {
 func IsWeekend(t time.Time) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cupRM5aZOIY)</span></b>
 
 ```go
 package main
@@ -1321,7 +1321,7 @@ func main() {
 func NowDateOrTime(format string, timezone ...string) string
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/EZ-begEjtT0)</span></b>
 
 ```go
 package main
@@ -1355,7 +1355,7 @@ func main() {
 func Timestamp(timezone ...string) int64
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/iU5b7Vvjx6x)</span></b>
 
 ```go
 package main
@@ -1386,7 +1386,7 @@ func main() {
 func TimestampMilli(timezone ...string) int64
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4gvEusOTu1T)</span></b>
 
 ```go
 package main
@@ -1416,7 +1416,7 @@ func main() {
 func TimestampMicro(timezone ...string) int64
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2maANglKHQE)</span></b>
 
 ```go
 package main
@@ -1446,7 +1446,7 @@ func main() {
 func TimestampNano(timezone ...string) int64
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/A9Oq_COrcCF)</span></b>
 
 ```go
 package main

docs/api/packages/fileutil.md

@@ -26,6 +26,7 @@ import (
 -   [CreateFile](#CreateFile)
 -   [CreateDir](#CreateDir)
 -   [CopyFile](#CopyFile)
+-   [CopyDir](#CopyDir)
 -   [CurrentPath](#CurrentPath)
 -   [FileMode](#FileMode)
 -   [MiMeType](#MiMeType)
@@ -45,8 +46,12 @@ import (
 -   [Sha](#Sha)
 -   [ReadCsvFile](#ReadCsvFile)
 -   [WriteCsvFile](#WriteCsvFile)
+-   [WriteMapsToCsv](#WriteMapsToCsv)
 -   [WriteStringToFile](#WriteStringToFile)
 -   [WriteBytesToFile](#WriteBytesToFile)
+-   [ReadFile](#ReadFile)
+-   [ChunkRead](#ChunkRead)
+-   [ParallelChunkRead](#ParallelChunkRead)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -62,7 +67,7 @@ import (
 func ClearFile(path string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/NRZ0ZT-G94H)</span></b>
 
 ```go
 package main
@@ -90,7 +95,7 @@ func main() {
 func CreateFile(path string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/lDt8PEsTNKI)</span></b>
 
 ```go
 package main
@@ -116,7 +121,7 @@ func main() {
 func CreateDir(absPath string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qUuCe1OGQnM)</span></b>
 
 ```go
 package main
@@ -142,7 +147,7 @@ func main() {
 func CopyFile(srcPath string, dstPath string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Jg9AMJMLrJi)</span></b>
 
 ```go
 package main
@@ -160,6 +165,34 @@ func main() {
 }
 ```
 
+### <span id="CopyDir">CopyDir</span>
+
+<p>拷贝文件夹到目标路径，会递归复制文件夹下所有的文件及文件夹，并且访问权限也与源文件夹保持一致。当dstPath存在时会返回error</p>
+
+<b>函数签名:</b>
+
+```go
+func CopyDir(srcPath string, dstPath string) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YAyFTA_UuPb)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    err := fileutil.CopyFile("./test_src", "./test_dest")
+    if err != nil {
+        fmt.Println(err)
+    }
+}
+```
+
 ### <span id="CurrentPath">CurrentPath</span>
 
 <p>返回当前位置的绝对路径。</p>
@@ -170,7 +203,7 @@ func main() {
 func CurrentPath() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/s74a9iBGcSw)</span></b>
 
 ```go
 package main
@@ -196,7 +229,7 @@ func main() {
 func FileMode(path string) (fs.FileMode, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2l2hI42fA3p)</span></b>
 
 ```go
 package main
@@ -225,7 +258,7 @@ func main() {
 func MiMeType(file any) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/bd5sevSUZNu)</span></b>
 
 ```go
 package main
@@ -256,7 +289,7 @@ func main() {
 func IsExist(path string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nKKXt8ZQbmh)</span></b>
 
 ```go
 package main
@@ -283,7 +316,7 @@ func main() {
 func IsLink(path string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/TL-b-Kzvf44)</span></b>
 
 ```go
 package main
@@ -309,7 +342,7 @@ func main() {
 func IsDir(path string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/WkVwEKqtOWk)</span></b>
 
 ```go
 package main
@@ -338,7 +371,7 @@ func main() {
 func ListFileNames(path string) ([]string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Tjd7Y07rejl)</span></b>
 
 ```go
 package main
@@ -364,7 +397,7 @@ func main() {
 func RemoveFile(path string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/P2y0XW8a1SH)</span></b>
 
 ```go
 package main
@@ -392,7 +425,7 @@ func main() {
 func ReadFileToString(path string) (string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cmfwp_5SQTp)</span></b>
 
 ```go
 package main
@@ -425,7 +458,7 @@ func main() {
 func ReadFileByLine(path string)([]string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/svJP_7ZrBrD)</span></b>
 
 ```go
 package main
@@ -459,7 +492,7 @@ func main() {
 func Zip(fpath string, destPath string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/j-3sWBp8ik_P)</span></b>
 
 ```go
 package main
@@ -487,7 +520,7 @@ func main() {
 func ZipAppendEntry(fpath string, destPath string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cxvaT8TRNQp)</span></b>
 
 ```go
 package main
@@ -515,7 +548,7 @@ func main() {
 func UnZip(zipFile string, destPath string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/g0w34kS7B8m)</span></b>
 
 ```go
 package main
@@ -543,7 +576,7 @@ func main() {
 func IsZipFile(filepath string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9M0g2j_uF_e)</span></b>
 
 ```go
 package main
@@ -569,7 +602,7 @@ func main() {
 func FileSize(path string) (int64, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/H9Z05uD-Jjc)</span></b>
 
 ```go
 package main
@@ -601,7 +634,7 @@ func main() {
 func MTime(filepath string) (int64, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/s_Tl7lZoAaY)</span></b>
 
 ```go
 package main
@@ -633,7 +666,7 @@ func main() {
 func Sha(filepath string, shaType ...int) (string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VfEEcO2MJYf)</span></b>
 
 ```go
 package main
@@ -668,10 +701,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func ReadCsvFile(filepath string) ([][]string, error)
+func ReadCsvFile(filepath string, delimiter ...rune) ([][]string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OExTkhGEd3_u)</span></b>
 
 ```go
 package main
@@ -700,10 +733,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func WriteCsvFile(filepath string, records [][]string, append bool) error
+func WriteCsvFile(filepath string, records [][]string, append bool, delimiter ...rune) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dAXm58Q5U1o)</span></b>
 
 ```go
 package main
@@ -742,6 +775,59 @@ func main() {
 }
 ```
 
+### <span id="WriteMapsToCsv">WriteMapsToCsv</span>
+
+<p>将map切片写入csv文件中。</p>
+
+<b>函数签名:</b>
+
+```go
+// filepath: CSV文件路径。
+// records: 写入文件的map切片。map值必须为基本类型。会以map键的字母顺序写入。
+// appendToExistingFile: 是否为追加写模式。
+// delimiter: CSV文件分割符。
+// headers: CSV文件表头顺序（需要与map key保持一致)，不指定时按字母排序。
+func WriteMapsToCsv(filepath string, records []map[string]any, appendToExistingFile bool, delimiter rune, headers ...[]string) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/umAIomZFV1c)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    fpath := "./test.csv"
+    fileutil.CreateFile(fpath)
+
+    f, _ := os.OpenFile(fpath, os.O_WRONLY|os.O_TRUNC, 0777)
+    defer f.Close()
+
+    records := []map[string]any{
+        {"Name": "Lili", "Age": "22", "Gender": "female"},
+        {"Name": "Jim", "Age": "21", "Gender": "male"},
+    }
+
+    headers := []string{"Name", "Age", "Gender"}
+    err := fileutil.WriteMapsToCsv(csvFilePath, records, false, ';', headers)
+
+    if err != nil {
+        log.Fatal(err)
+    }
+
+    content, err := fileutil.ReadCsvFile(csvFilePath, ';')
+
+    fmt.Println(content)
+
+    // Output:
+    // [[Name Age Gender] [Lili 22 female] [Jim 21 male]]
+}
+```
+
 ### <span id="WriteBytesToFile">WriteBytesToFile</span>
 
 <p>将bytes写入文件。</p>
@@ -752,7 +838,7 @@ func main() {
 func WriteBytesToFile(filepath string, content []byte) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/s7QlDxMj3P8)</span></b>
 
 ```go
 package main
@@ -801,7 +887,7 @@ func main() {
 func WriteStringToFile(filepath string, content string, append bool) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GhLS6d8lH_g)</span></b>
 
 ```go
 package main
@@ -839,3 +925,155 @@ func main() {
     // hello
 }
 ```
+
+### <span id="ReadFile">ReadFile</span>
+
+<p>读取文件或者URL。</p>
+
+<b>函数签名:</b>
+
+```go
+func ReadFile(path string) (reader io.ReadCloser, closeFn func(), err error) 
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uNep3Tr8fqF)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    reader, fn, err := fileutil.ReadFile("https://httpbin.org/robots.txt")
+    if err != nil {
+        return
+    }
+    defer fn()
+
+    dat, err := io.ReadAll(reader)
+    if err != nil {
+        return
+    }
+    
+    fmt.Println(string(dat))
+    
+    // Output:
+    // User-agent: *
+    // Disallow: /deny
+}
+```
+
+### <span id="ChunkRead">ChunkRead</span>
+
+<p>从文件的指定偏移读取块并返回块内所有行。</p>
+
+<b>函数签名:</b>
+
+```go
+func ChunkRead(file *os.File, offset int64, size int, bufPool *sync.Pool) ([]string, error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/r0hPmKWhsgf)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    const mb = 1024 * 1024
+    const defaultChunkSizeMB = 100 
+
+    // test1.csv file content:
+    // Lili,22,female
+    // Jim,21,male
+    filePath := "./testdata/test1.csv" // 替换为你的文件路径
+    f, err := os.Open(filePath)
+    if err != nil {
+        return
+    }
+
+    defer f.Close()
+
+    var bufPool = sync.Pool{
+        New: func() interface{} {
+            return make([]byte, 0, defaultChunkSizeMB*mb)
+        },
+    }
+
+    lines, err := fileutil.ChunkRead(f, 0, 100, &bufPool)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(lines[0])
+    fmt.Println(lines[1])
+
+    // Output:
+    // Lili,22,female
+    // Jim,21,male
+}
+```
+
+### <span id="ParallelChunkRead">ParallelChunkRead</span>
+
+<p>并行读取文件并将每个块的行发送到指定通道。</p>
+
+<b>函数签名:</b>
+
+```go
+// filePath:文件路径
+// chunkSizeMB: 分块的大小（单位MB，设置为0时使用默认100MB）,设置过大反而不利，视情调整
+// maxGoroutine: 并发读取分块的数量，设置为0时使用CPU核心数
+// linesCh: 用于接收返回结果的通道。
+func ParallelChunkRead(filePath string, linesCh chan<- []string, chunkSizeMB, maxGoroutine int) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/teMXnCsdSEw)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    const mb = 1024 * 1024
+    const defaultChunkSizeMB = 100 // 默认值
+
+    numParsers := runtime.NumCPU()
+
+    linesCh := make(chan []string, numParsers)
+    
+    // test1.csv file content:
+    // Lili,22,female
+    // Jim,21,male
+    filePath := "./testdata/test1.csv"
+
+    go fileutil.ParallelChunkRead(filePath, linesCh, defaultChunkSizeMB, numParsers)
+
+    var totalLines int
+    for lines := range linesCh {
+        totalLines += len(lines)
+
+        for _, line := range lines {
+            fmt.Println(line)
+        }
+    }
+
+    fmt.Println(totalLines)
+
+    // Output:
+    // Lili,22,female
+    // Jim,21,male
+    // 2
+}
+```

docs/api/packages/formatter.md

@@ -45,7 +45,7 @@ import (
 func Comma[T constraints.Float | constraints.Integer | string](value T, symbol string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/eRD5k2vzUVX)</span></b>
 
 ```go
 package main
@@ -81,7 +81,7 @@ func main() {
 func Pretty(v any) (string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YsciGj3FH2x)</span></b>
 
 ```go
 package main
@@ -120,7 +120,7 @@ func main() {
 func PrettyToWriter(v any, out io.Writer) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/LPLZ3lDi5ma)</span></b>
 
 ```go
 package main
@@ -163,7 +163,7 @@ func main() {
 func DecimalBytes(size float64, precision ...int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/FPXs1suwRcs)</span></b>
 
 ```go
 package main
@@ -202,7 +202,7 @@ func main() {
 func BinaryBytes(size float64, precision ...int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/G9oHHMCAZxP)</span></b>
 
 ```go
 package main
@@ -241,7 +241,7 @@ func main() {
 func ParseDecimalBytes(size string) (uint64, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Am98ybWjvjj)</span></b>
 
 ```go
 package main
@@ -280,7 +280,7 @@ func main() {
 func ParseBinaryBytes(size string) (uint64, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/69v1tTT62x8)</span></b>
 
 ```go
 package main

docs/api/packages/function.md

@@ -0,0 +1,693 @@
+# Function
+
+function 函数包控制函数执行流程，包含部分函数式编程。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+-   [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/predicate.go](https://github.com/duke-git/lancet/blob/main/function/predicate.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/v2/function"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [After](#After)
+-   [Before](#Before)
+-   [CurryFn](#CurryFn)
+-   [Compose](#Compose)
+-   [Debounced](#Debounced)
+-   [Delay](#Delay)
+-   [Schedule](#Schedule)
+-   [Pipeline](#Pipeline)
+-   [Watcher](#Watcher)
+-   [And](#And)
+-   [Or](#Or)
+-   [Negate](#Negate)
+-   [Nor](#Nor)
+-   [Xnor](#Xnor)
+-   [Nand](#Nand)
+-   [AcceptIf](#AcceptIf)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+### <span id="After">After</span>
+
+<p>创建一个函数，当他被调用n或更多次之后将马上触发fn</p>
+
+<b>函数签名:</b>
+
+```go
+func After(n int, fn any) func(args ...any) []reflect.Value
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/eRD5k2vzUVX)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    fn := function.After(2, func() {
+        fmt.Println("hello")
+    })
+
+    fn()
+    fn()
+
+    // Output:
+    // hello
+}
+```
+
+### <span id="Before">Before</span>
+
+<p>创建一个函数，调用次数不超过n次，之后再调用这个函数，将返回一次最后调用fn的结果</p>
+
+<b>函数签名:</b>
+
+```go
+func Before(n int, fn any) func(args ...any) []reflect.Value
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/0HqUDIFZ3IL)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    fn := function.Before(2, func() {
+        fmt.Println("hello")
+    })
+
+    fn()
+    fn()
+    fn()
+    fn()
+
+    // Output:
+    // hello
+    // hello
+}
+```
+
+### <span id="CurryFn">CurryFn</span>
+
+<p>创建柯里化函数</p>
+
+<b>函数签名:</b>
+
+```go
+type CurryFn[T any] func(...T) T
+func (cf CurryFn[T]) New(val T) func(...T) T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/5HopfDwANKX)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    add := func(a, b int) int {
+        return a + b
+    }
+
+    var addCurry function.CurryFn[int] = func(values ...int) int {
+        return add(values[0], values[1])
+    }
+    add1 := addCurry.New(1)
+
+    result := add1(2)
+
+    fmt.Println(result)
+
+    // Output:
+    // 3
+}
+```
+
+### <span id="Compose">Compose</span>
+
+<p>从右至左组合函数列表fnList，返回组合后的函数</p>
+
+<b>函数签名:</b>
+
+```go
+func Compose[T any](fnList ...func(...T) T) func(...T) T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KKfugD4PKYF)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    toUpper := func(strs ...string) string {
+        return strings.ToUpper(strs[0])
+    }
+    toLower := func(strs ...string) string {
+        return strings.ToLower(strs[0])
+    }
+    transform := function.Compose(toUpper, toLower)
+
+    result := transform("aBCde")
+
+    fmt.Println(result)
+
+    // Output:
+    // ABCDE
+}
+```
+
+### <span id="Debounced">Debounced</span>
+
+<p>创建一个debounced函数，该函数延迟调用fn直到自上次调用debounced函数后等待持续时间过去。</p>
+
+<b>函数签名:</b>
+
+```go
+func Debounced(fn func(), duration time.Duration) func()
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/absuEGB_GN7)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    count := 0
+
+    add := func() {
+        count++
+    }
+
+    debouncedAdd := function.Debounced(add, 50*time.Microsecond)
+
+    debouncedAdd()
+    debouncedAdd()
+    debouncedAdd()
+    debouncedAdd()
+
+    time.Sleep(100 * time.Millisecond)
+
+    fmt.Println(count)
+
+    debouncedAdd()
+
+    time.Sleep(100 * time.Millisecond)
+
+    fmt.Println(count)
+
+    // Output:
+    // 1
+    // 2
+}
+```
+
+### <span id="Delay">Delay</span>
+
+<p>延迟delay时间后调用函数</p>
+
+<b>函数签名:</b>
+
+```go
+func Delay(delay time.Duration, fn any, args ...any)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Ivtc2ZE-Tye)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    var print = func(s string) {
+        fmt.Println(s)
+    }
+
+    function.Delay(2*time.Second, print, "hello")
+
+    // Output:
+    // hello
+}
+```
+
+### <span id="Schedule">Schedule</span>
+
+<p>每次持续时间调用函数，直到关闭返回的 bool chan</p>
+
+<b>函数签名:</b>
+
+```go
+func Schedule(d time.Duration, fn any, args ...any) chan bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/hbON-Xeyn5N)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    count := 0
+
+    increase := func() {
+        count++
+    }
+
+    stop := function.Schedule(2*time.Second, increase)
+
+    time.Sleep(2 * time.Second)
+    close(stop)
+
+    fmt.Println(count)
+
+    // Output:
+    // 2
+}
+```
+
+### <span id="Pipeline">Pipeline</span>
+
+<p>执行函数pipeline.</p>
+
+<b>函数签名:</b>
+
+```go
+func Pipeline[T any](funcs ...func(T) T) func(T) T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/mPdUVvj6HD6)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    addOne := func(x int) int {
+        return x + 1
+    }
+    double := func(x int) int {
+        return 2 * x
+    }
+    square := func(x int) int {
+        return x * x
+    }
+
+    fn := function.Pipeline(addOne, double, square)
+
+    result := fn(2)
+
+    fmt.Println(result)
+
+    // Output:
+    // 36
+}
+```
+
+### <span id="Watcher">Watcher</span>
+
+<p>Watcher用于记录代码执行时间。可以启动/停止/重置手表定时器。获取函数执行的时间。</p>
+
+<b>函数签名:</b>
+
+```go
+type Watcher struct {
+    startTime int64
+    stopTime  int64
+    excuting  bool
+}
+func NewWatcher() *Watcher
+func (w *Watcher) Start()
+func (w *Watcher) Stop()
+func (w *Watcher) Reset()
+func (w *Watcher) GetElapsedTime() time.Duration
+
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/l2yrOpCLd1I)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    w := function.NewWatcher()
+
+    w.Start()
+
+    longRunningTask()
+
+    fmt.Println(w.excuting) //true
+
+    w.Stop()
+
+    eapsedTime := w.GetElapsedTime().Milliseconds()
+
+    fmt.Println(eapsedTime)
+
+    w.Reset()
+
+}
+
+func longRunningTask() {
+    var slice []int64
+    for i := 0; i < 10000000; i++ {
+        slice = append(slice, int64(i))
+    }
+}
+
+```
+
+### <span id="And">And</span>
+
+<p>返回一个复合谓词判断函数，该判断函数表示一组谓词的逻辑and操作。只有当所有谓词判断函数对于给定的值都返回true时，返回true, 否则返回false。</p>
+
+<b>函数签名:</b>
+
+```go
+func And[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dTBHJMQ0zD2)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    isNumericAndLength5 := function.And(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return len(s) == 5 },
+    )
+
+    fmt.Println(isNumericAndLength5("12345"))
+    fmt.Println(isNumericAndLength5("1234"))
+    fmt.Println(isNumericAndLength5("abcde"))
+
+    // Output:
+    // true
+    // false
+    // false
+}
+```
+
+### <span id="Or">Or</span>
+
+<p>返回一个复合谓词判断函数，该判断函数表示一组谓词的逻辑or操作。只有当所有谓词判断函数对于给定的值都返回false时，返回false, 否则返回true。</p>
+
+<b>函数签名:</b>
+
+```go
+func Or[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/LitCIsDFNDA)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    containsDigitOrSpecialChar := function.Or(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return strings.ContainsAny(s, "!@#$%") },
+    )
+
+    fmt.Println(containsDigitOrSpecialChar("hello!"))
+    fmt.Println(containsDigitOrSpecialChar("hello"))
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="Negate">Negate</span>
+
+<p>返回一个谓词函数，该谓词函数表示当前谓词的逻辑否定。</p>
+
+<b>函数签名:</b>
+
+```go
+func Negate[T any](predicate func(T) bool) func(T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jbI8BtgFnVE)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    // Define some simple predicates for demonstration
+    isUpperCase := func(s string) bool {
+        return strings.ToUpper(s) == s
+    }
+    isLowerCase := func(s string) bool {
+        return strings.ToLower(s) == s
+    }
+    isMixedCase := function.Negate(function.Or(isUpperCase, isLowerCase))
+
+    fmt.Println(isMixedCase("ABC"))
+    fmt.Println(isMixedCase("AbC"))
+
+    // Output:
+    // false
+    // true
+}
+```
+
+
+### <span id="Nor">Nor</span>
+
+<p>返回一个组合谓词函数，表示给定值上所有谓词逻辑非或 (nor) 的结果。只有当所有谓词函数对给定值都返回false时，该组合谓词函数才返回true。</p>
+
+<b>函数签名:</b>
+
+```go
+func Nor[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2KdCoBEOq84)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    match := function.Nor(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return len(s) == 5 },
+    )
+
+    fmt.Println(match("dbcdckkeee"))
+
+
+    match = function.Nor(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return len(s) == 5 },
+    )
+
+    fmt.Println(match("0123456789"))
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="Nand">Nand</span>
+
+<p>返回一个复合谓词函数，表示给定谓词函数列表的逻辑非与 (NAND)。仅当列表中所有函数对给定参数返回false时，才返回true，否则返回false。</p>
+
+<b>函数签名:</b>
+
+```go
+func Nand[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Rb-FdNGpgSO)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    isNumericAndLength5 := function.Nand(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return len(s) == 5 },
+    )
+
+    fmt.Println(isNumericAndLength5("12345"))
+    fmt.Println(isNumericAndLength5("1234"))
+    fmt.Println(isNumericAndLength5("abcdef"))
+
+    // Output:
+    // false
+    // false
+    // true
+}
+```
+
+### <span id="Xnor">Xnor</span>
+
+<p>返回一个复合谓词函数，表示给定一组谓词函数的逻辑异或 (XNOR)。只有当所有 谓词函数对给参数都返回true或false时，该谓词函数才返回true。</p>
+
+<b>函数签名:</b>
+
+```go
+func Xnor[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/FJxko8SFbqc)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    isEven := func(i int) bool { return i%2 == 0 }
+    isPositive := func(i int) bool { return i > 0 }
+
+    match := function.Xnor(isEven, isPositive)
+
+    fmt.Println(match(2))
+    fmt.Println(match(-3))
+    fmt.Println(match(3))
+
+    // Output:
+    // true
+    // true
+    // false
+}
+```
+
+### <span id="AcceptIf">AcceptIf</span>
+
+<p>AcceptIf函数会返回另一个函数，该函数的签名与 apply 函数相同，但同时还会包含一个布尔值来表示成功或失败。</p>
+
+<b>函数签名:</b>
+
+```go
+func AcceptIf[T any](predicate func(T) bool, apply func(T) T) func(T) (T, bool)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/XlXHHtzCf7d)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    adder := function.AcceptIf(
+        function.And(
+            func(x int) bool {
+                return x > 10
+            }, func(x int) bool {
+                return x%2 == 0
+            }),
+        func(x int) int {
+            return x + 1
+        },
+    )
+
+    result, ok := adder(20)
+    fmt.Println(result)
+    fmt.Println(ok)
+
+    result, ok = adder(21)
+    fmt.Println(result)
+    fmt.Println(ok)
+
+    // Output:
+    // 21
+    // true
+    // 0
+    // false
+}
+
+```

docs/api/packages/maputil.md

@@ -44,6 +44,8 @@ import (
 -   [Minus](#Minus)
 -   [IsDisjoint](#IsDisjoint)
 -   [HasKey](#HasKey)
+-   [ToSortedSlicesDefault](#ToSortedSlicesDefault)
+-   [ToSortedSlicesWithComparator](#ToSortedSlicesWithComparator)
 -   [NewConcurrentMap](#NewConcurrentMap)
 -   [ConcurrentMap_Get](#ConcurrentMap_Get)
 -   [ConcurrentMap_Set](#ConcurrentMap_Set)
@@ -53,7 +55,6 @@ import (
 -   [ConcurrentMap_Has](#ConcurrentMap_Has)
 -   [ConcurrentMap_Range](#ConcurrentMap_Range)
 
-
 <div STYLE="page-break-after: always;"></div>
 
 ## API 文档:
@@ -68,7 +69,7 @@ import (
 func MapTo(src any, dst any) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4K7KBEPgS5M)</span></b>
 
 ```go
 package main
@@ -125,7 +126,7 @@ func main() {
 func ForEach[K comparable, V any](m map[K]V, iteratee func(key K, value V))
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OaThj6iNVXK)</span></b>
 
 ```go
 package main
@@ -166,7 +167,7 @@ func main() {
 func Filter[K comparable, V any](m map[K]V, predicate func(key K, value V) bool) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fSvF3wxuNG7)</span></b>
 
 ```go
 package main
@@ -211,7 +212,7 @@ func main() {
 func FilterByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/7ov6BJHbVqh)</span></b>
 
 ```go
 package main
@@ -249,7 +250,7 @@ func main() {
 func FilterByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/P3-9MdcXegR)</span></b>
 
 ```go
 package main
@@ -287,7 +288,7 @@ func main() {
 func OmitBy[K comparable, V any](m map[K]V, predicate func(key K, value V) bool) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YJM4Hj5hNwm)</span></b>
 
 ```go
 package main
@@ -328,7 +329,7 @@ func main() {
 func OmitByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jXGrWDBfSRp)</span></b>
 
 ```go
 package main
@@ -366,7 +367,7 @@ func main() {
 func OmitByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/XB7Y10uw20_U)</span></b>
 
 ```go
 package main
@@ -404,7 +405,7 @@ func main() {
 func Intersect[K comparable, V any](maps ...map[K]V) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Zld0oj3sjcC)</span></b>
 
 ```go
 package main
@@ -459,7 +460,7 @@ func main() {
 func Keys[K comparable, V any](m map[K]V) []K
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/xNB5bTb97Wd)</span></b>
 
 ```go
 package main
@@ -498,7 +499,7 @@ func main() {
 func Merge[K comparable, V any](maps ...map[K]V) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/H95LENF1uB-)</span></b>
 
 ```go
 package main
@@ -537,7 +538,7 @@ func main() {
 func Minus[K comparable, V any](mapA, mapB map[K]V) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3u5U9K7YZ9m)</span></b>
 
 ```go
 package main
@@ -579,7 +580,7 @@ func main() {
 func Values[K comparable, V any](m map[K]V) []V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/CBKdUc5FTW6)</span></b>
 
 ```go
 package main
@@ -616,7 +617,7 @@ func main() {
 func KeysBy[K comparable, V any, T any](m map[K]V, mapper func(item K) T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/hI371iB8Up8)</span></b>
 
 ```go
 package main
@@ -657,7 +658,7 @@ func main() {
 func ValuesBy[K comparable, V any, T any](m map[K]V, mapper func(item V) T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sg9-oRidh8f)</span></b>
 
 ```go
 package main
@@ -706,7 +707,7 @@ func main() {
 func MapKeys[K comparable, V any, T comparable](m map[K]V, iteratee func(key K, value V) T) map[T]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8scDxWeBDKd)</span></b>
 
 ```go
 package main
@@ -745,7 +746,7 @@ func main() {
 func MapValues[K comparable, V any, T any](m map[K]V, iteratee func(key K, value V) T) map[K]T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/g92aY3fc7Iw)</span></b>
 
 ```go
 package main
@@ -788,7 +789,7 @@ type Entry[K comparable, V any] struct {
 func Entries[K comparable, V any](m map[K]V) []Entry[K, V]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Ltb11LNcElY)</span></b>
 
 ```go
 package main
@@ -833,7 +834,7 @@ type Entry[K comparable, V any] struct {
 func FromEntries[K comparable, V any](entries []Entry[K, V]) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/C8L4ul9TVwf)</span></b>
 
 ```go
 package main
@@ -867,7 +868,7 @@ func main() {
 func Transform[K1 comparable, V1 any, K2 comparable, V2 any](m map[K1]V1, iteratee func(key K1, value V1) (K2, V2)) map[K2]V2
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/P6ovfToM3zj)</span></b>
 
 ```go
 package main
@@ -906,7 +907,7 @@ func main() {
 func IsDisjoint[K comparable, V any](mapA, mapB map[K]V) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/N9qgYg_Ho6f)</span></b>
 
 ```go
 package main
@@ -961,7 +962,7 @@ if haskey {
 func HasKey[K comparable, V any](m map[K]V, key K) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/isZZHOsDhFc)</span></b>
 
 ```go
 package main
@@ -977,8 +978,8 @@ func main() {
         "b": 2,
     }
 
-    result1 := HasKey(m, "a")
-    result2 := HasKey(m, "c")
+    result1 := maputil.HasKey(m, "a")
+    result2 := maputil.HasKey(m, "c")
 
     fmt.Println(result1)
     fmt.Println(result2)
@@ -989,6 +990,98 @@ func main() {
 }
 ```
 
+### <span id="ToSortedSlicesDefault">ToSortedSlicesDefault</span>
+
+<p>将map的key和value转化成两个根据key的值从小到大排序的切片，value切片中元素的位置与key对应。</p>
+
+<b>函数签名:</b>
+
+```go
+func ToSortedSlicesDefault[K constraints.Ordered, V any](m map[K]V) ([]K, []V)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[int]string{
+		1: "a",
+		3: "c",
+		2: "b",
+	}
+
+	keys, values := ToSortedSlicesDefault(m)
+
+	fmt.Println(keys)
+	fmt.Println(values)
+
+	// Output:
+	// [1 2 3]
+	// [a b c]
+}
+```
+
+### <span id="ToSortedSlicesWithComparator">ToSortedSlicesWithComparator</span>
+
+<p>将map的key和value转化成两个使用比较器函数根据key的值自定义排序规则的切片，value切片中元素的位置与key对应。</p>
+
+<b>函数签名:</b>
+
+```go
+func ToSortedSlicesWithComparator[K comparable, V any](m map[K]V, comparator func(a, b K) bool) ([]K, []V) 
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m1 := map[time.Time]string{
+		time.Date(2024, 3, 31, 0, 0, 0, 0, time.UTC): "today",
+		time.Date(2024, 3, 30, 0, 0, 0, 0, time.UTC): "yesterday",
+		time.Date(2024, 4, 1, 0, 0, 0, 0, time.UTC):  "tomorrow",
+	}
+
+	keys1, values1 := ToSortedSlicesWithComparator(m1, func(a, b time.Time) bool {
+		return a.Before(b)
+	})
+
+	m2 := map[int]string{
+		1: "a",
+		3: "c",
+		2: "b",
+	}
+	keys2, values2 := ToSortedSlicesWithComparator(m2, func(a, b int) bool {
+		return a > b
+	})
+
+	fmt.Println(keys2)
+	fmt.Println(values2)
+
+	fmt.Println(keys1)
+	fmt.Println(values1)
+
+	// Output:
+	// [2024-03-30 00:00:00 +0000 UTC 2024-03-31 00:00:00 +0000 UTC 2024-04-01 00:00:00 +0000 UTC]
+	// [yesterday today tomorrow]
+	// [3 2 1]
+	// [c b a]
+}
+```
+
 ### <span id="NewConcurrentMap">NewConcurrentMap</span>
 
 <p>ConcurrentMap协程安全的map结构。</p>
@@ -1000,7 +1093,7 @@ func main() {
 func NewConcurrentMap[K comparable, V any](shardCount int) *ConcurrentMap[K, V]
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3PenTPETJT0)</span></b>
 
 ```go
 package main
@@ -1026,7 +1119,7 @@ func main() {
 func (cm *ConcurrentMap[K, V]) Set(key K, value V)
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3PenTPETJT0)</span></b>
 
 ```go
 package main
@@ -1050,13 +1143,16 @@ func main() {
     }
     wg1.Wait()
 
-
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
     for j := 0; j < 5; j++ {
         go func(n int) {
             val, ok := cm.Get(fmt.Sprintf("%d", n))
             fmt.Println(val, ok)
+			wg2.Done()
         }(j)
     }
+	wg2.Wait()
 
     // output: (order may change)
     // 1 true
@@ -1077,7 +1173,7 @@ func main() {
 func (cm *ConcurrentMap[K, V]) Get(key K) (V, bool)
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3PenTPETJT0)</span></b>
 
 ```go
 package main
@@ -1101,13 +1197,16 @@ func main() {
     }
     wg1.Wait()
 
-
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
     for j := 0; j < 5; j++ {
         go func(n int) {
             val, ok := cm.Get(fmt.Sprintf("%d", n))
             fmt.Println(val, ok)
+			wg2.Done()
         }(j)
     }
+	wg2.Wait()
 
     // output: (order may change)
     // 1 true
@@ -1128,7 +1227,7 @@ func main() {
 func (cm *ConcurrentMap[K, V]) GetOrSet(key K, value V) (actual V, ok bool)
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/aDcDApOK01a)</span></b>
 
 ```go
 package main
@@ -1172,7 +1271,7 @@ func main() {
 func (cm *ConcurrentMap[K, V]) Delete(key K)
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uTIJZYhpVMS)</span></b>
 
 ```go
 package main
@@ -1196,17 +1295,18 @@ func main() {
     }
     wg1.Wait()
 
-
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
     for j := 0; j < 5; j++ {
         go func(n int) {
             cm.Delete(fmt.Sprintf("%d", n))
             wg2.Done()
         }(i)
     }
+    wg2.Wait()
 }
 ```
 
-
 ### <span id="ConcurrentMap_GetAndDelete">ConcurrentMap_GetAndDelete</span>
 
 <p>获取key，然后删除。</p>
@@ -1217,7 +1317,7 @@ func main() {
 func (cm *ConcurrentMap[K, V]) GetAndDelete(key K) (actual V, ok bool)
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ZyxeIXSZUiM)</span></b>
 
 ```go
 package main
@@ -1241,7 +1341,8 @@ func main() {
     }
     wg1.Wait()
 
-
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
     for j := 0; j < 5; j++ {
         go func(n int) {
             val, ok := cm.GetAndDelete(fmt.Sprintf("%d", n))
@@ -1249,12 +1350,14 @@ func main() {
 
             _, ok = cm.Get(fmt.Sprintf("%d", n))
             fmt.Println(val, ok) //false
+
+            wg2.Done()
         }(j)
     }
+    wg2.Wait()
 }
 ```
 
-
 ### <span id="ConcurrentMap_Has">ConcurrentMap_Has</span>
 
 <p>验证是否包含key。</p>
@@ -1265,7 +1368,7 @@ func main() {
 func (cm *ConcurrentMap[K, V]) Has(key K) bool
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/C8L4ul9TVwf)</span></b>
 
 ```go
 package main
@@ -1280,7 +1383,6 @@ func main() {
 
     var wg1 sync.WaitGroup
     wg1.Add(5)
-
     for i := 0; i < 5; i++ {
         go func(n int) {
             cm.Set(fmt.Sprintf("%d", n), n)
@@ -1289,17 +1391,21 @@ func main() {
     }
     wg1.Wait()
 
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
 
     for j := 0; j < 5; j++ {
         go func(n int) {
             ok := cm.Has(fmt.Sprintf("%d", n))
             fmt.Println(ok) // true
+
+            wg2.Done()
         }(j)
     }
+    wg2.Wait()
 }
 ```
 
-
 ### <span id="ConcurrentMap_Range">ConcurrentMap_Range</span>
 
 <p>为map中每个键和值顺序调用迭代器。 如果iterator返回false，则停止迭代。</p>
@@ -1310,7 +1416,7 @@ func main() {
 func (cm *ConcurrentMap[K, V]) Range(iterator func(key K, value V) bool)
 ```
 
-<b>实例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/iqcy7P8P0Pr)</span></b>
 
 ```go
 package main
@@ -1341,4 +1447,3 @@ func main() {
     })
 }
 ```
-

docs/api/packages/mathutil.md

@@ -34,6 +34,10 @@ import (
 -   [RoundToFloat](#RoundToFloat)
 -   [RoundToString](#RoundToString)
 -   [TruncRound](#TruncRound)
+-   [CeilToFloat](#CeilToFloat)
+-   [CeilToString](#CeilToString)
+-   [FloorToFloat](#FloorToFloat)
+-   [FloorToString](#FloorToString)
 -   [Range](#Range)
 -   [RangeWithStep](#RangeWithStep)
 -   [AngleToRadian](#AngleToRadian)
@@ -47,10 +51,11 @@ import (
 -   [Log](#Log)
 -   [Sum](#Sum)
 -   [Abs](#Abs)
+-   [Div](#Div)
 
 <div STYLE="page-break-after: always;"></div>
 
-## Documentation
+## 文档
 
 ### <span id="Average">Average</span>
 
@@ -62,7 +67,7 @@ import (
 func Average[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HFd70x4DrMj)</span></b>
 
 ```go
 package main
@@ -97,7 +102,7 @@ func main() {
 func Exponent(x, n int64) int64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Vv7LBwER-pz)</span></b>
 
 ```go
 package main
@@ -133,7 +138,7 @@ func main() {
 func Fibonacci(first, second, n int) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/IscseUNMuUc)</span></b>
 
 ```go
 package main
@@ -169,7 +174,7 @@ func main() {
 func Factorial(x uint) uint
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tt6LdOK67Nx)</span></b>
 
 ```go
 package main
@@ -205,7 +210,7 @@ func main() {
 func Max[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cN8DHI0rTkH)</span></b>
 
 ```go
 package main
@@ -238,7 +243,7 @@ func main() {
 func MaxBy[T any](slice []T, comparator func(T, T) bool) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pbe2MT-7DV2)</span></b>
 
 ```go
 package main
@@ -282,7 +287,7 @@ func main() {
 func Min[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pbe2MT-7DV2)</span></b>
 
 ```go
 package main
@@ -315,7 +320,7 @@ func main() {
 func MinBy[T any](slice []T, comparator func(T, T) bool) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/N9qgYg_Ho6f)</span></b>
 
 ```go
 package main
@@ -359,7 +364,7 @@ func main() {
 func Percent(val, total float64, n int) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/s0NdFCtwuyd)</span></b>
 
 ```go
 package main
@@ -392,10 +397,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func RoundToFloat(x float64, n int) float64
+func RoundToFloat[T constraints.Float | constraints.Integer](x T, n int) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ghyb528JRJL)</span></b>
 
 ```go
 package main
@@ -428,10 +433,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func RoundToString(x float64, n int) string
+func RoundToString[T constraints.Float | constraints.Integer](x T, n int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/kZwpBRAcllO)</span></b>
 
 ```go
 package main
@@ -464,10 +469,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func TruncRound(x float64, n int) float64
+func TruncRound[T constraints.Float | constraints.Integer](x T, n int) T 
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/aumarSHIGzP)</span></b>
 
 ```go
 package main
@@ -493,6 +498,150 @@ func main() {
 }
 ```
 
+### <span id="CeilToFloat">CeilToFloat</span>
+
+<p>向上舍入（进一法），保留n位小数。</p>
+
+<b>函数签名:</b>
+
+```go
+func CeilToFloat[T constraints.Float | constraints.Integer](x T, n int) float64
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8hOeSADZPCo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.CeilToFloat(3.14159, 1)
+    result2 := mathutil.CeilToFloat(3.14159, 2)
+    result3 := mathutil.CeilToFloat(5, 4)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+
+    // Output:
+    // 3.2
+    // 3.15
+    // 5
+}
+```
+
+### <span id="CeilToString">CeilToString</span>
+
+<p>向上舍入（进一法），保留n位小数，返回字符串。</p>
+
+<b>函数签名:</b>
+
+```go
+func CeilToString[T constraints.Float | constraints.Integer](x T, n int) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/wy5bYEyUKKG)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.CeilToString(3.14159, 1)
+    result2 := mathutil.CeilToString(3.14159, 2)
+    result3 := mathutil.CeilToString(5, 4)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+
+    // Output:
+    // 3.2
+    // 3.15
+    // 5.0000
+}
+```
+
+### <span id="FloorToFloat">FloorToFloat</span>
+
+<p>向下舍入（去尾法），保留n位小数。</p>
+
+<b>函数签名:</b>
+
+```go
+func FloorToFloat[T constraints.Float | constraints.Integer](x T, n int) float64
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/vbCBrQHZEED)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.FloorToFloat(3.14159, 1)
+    result2 := mathutil.FloorToFloat(3.14159, 2)
+    result3 := mathutil.FloorToFloat(5, 4)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+
+    // Output:
+    // 3.1
+    // 3.14
+    // 5
+}
+```
+
+### <span id="FloorToString">FloorToString</span>
+
+<p>向下舍入（去尾法），保留n位小数，返回字符串。</p>
+
+<b>函数签名:</b>
+
+```go
+func FloorToString[T constraints.Float | constraints.Integer](x T, n int) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Qk9KPd2IdDb)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.FloorToString(3.14159, 1)
+    result2 := mathutil.FloorToString(3.14159, 2)
+    result3 := mathutil.FloorToString(5, 4)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+
+    // Output:
+    // 3.1
+    // 3.14
+    // 5.0000
+}
+```
+
 ### <span id="Range">Range</span>
 
 <p>根据指定的起始值和数量，创建一个数字切片。</p>
@@ -503,7 +652,7 @@ func main() {
 func Range[T constraints.Integer | constraints.Float](start T, count int) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9ke2opxa8ZP)</span></b>
 
 ```go
 package main
@@ -542,7 +691,7 @@ func main() {
 func RangeWithStep[T constraints.Integer | constraints.Float](start, end, step T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/akLWz0EqOSM)</span></b>
 
 ```go
 package main
@@ -581,7 +730,7 @@ func main() {
 func AngleToRadian(angle float64) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/CIvlICqrHql)</span></b>
 
 ```go
 package main
@@ -617,7 +766,7 @@ func main() {
 func RadianToAngle(radian float64) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dQtmOTUOMgi)</span></b>
 
 ```go
 package main
@@ -653,7 +802,7 @@ func main() {
 func PointDistance(x1, y1, x2, y2 float64) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/RrG4JIaziM8)</span></b>
 
 ```go
 package main
@@ -683,7 +832,7 @@ func main() {
 func IsPrime(n int) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Rdd8UTHZJ7u)</span></b>
 
 ```go
 package main
@@ -722,7 +871,7 @@ func main() {
 func GCD[T constraints.Integer](integers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/CiEceLSoAKB)</span></b>
 
 ```go
 package main
@@ -764,7 +913,7 @@ func main() {
 func LCM[T constraints.Integer](integers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/EjcZxfY7G_g)</span></b>
 
 ```go
 package main
@@ -800,7 +949,7 @@ func main() {
 func Cos(radian float64, precision ...int) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Sm89LoIfvFq)</span></b>
 
 ```go
 package main
@@ -842,7 +991,7 @@ func main() {
 func Sin(radian float64, precision ...int) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/TWMQlMywDsP)</span></b>
 
 ```go
 package main
@@ -884,7 +1033,7 @@ func main() {
 func Log(n, base float64) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_d4bi8oyhat)</span></b>
 
 ```go
 package main
@@ -920,7 +1069,7 @@ func main() {
 func Sum[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/1To2ImAMJA7)</span></b>
 
 ```go
 package main
@@ -953,7 +1102,7 @@ func main() {
 func Abs[T constraints.Integer | constraints.Float](x T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fsyBh1Os-1d)</span></b>
 
 ```go
 package main
@@ -965,16 +1114,52 @@ import (
 
 func main() {
     result1 := Abs(-1)
-	result2 := Abs(-0.1)
-	result3 := Abs(float32(0.2))
+    result2 := Abs(-0.1)
+    result3 := Abs(float32(0.2))
 
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
 
-	// Output:
-	// 1
-	// 0.1
-	// 0.2
+    // Output:
+    // 1
+    // 0.1
+    // 0.2
 }
 ```
+
+### <span id="Div">Div</span>
+
+<p>除法运算。</p>
+
+<b>函数签名:</b>
+
+```go
+func Div[T constraints.Float | constraints.Integer](x T, y T) float64
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/WLxDdGXXYat)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/mathutil"
+)
+
+func main() {
+    result1 := mathutil.Div(9, 4)
+    result2 := mathutil.Div(1, 2)
+    result3 := mathutil.Div(0, 666)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+
+    // Output:
+    // 2.25
+    // 0.5
+    // 0
+}
+```

docs/api/packages/netutil.md

@@ -63,7 +63,7 @@ import (
 func ConvertMapToQueryString(param map[string]any) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jnNt_qoSnRi)</span></b>
 
 ```go
 package main
@@ -98,7 +98,7 @@ func main() {
 func EncodeUrl(urlStr string) (string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/bsZ6BRC4uKI)</span></b>
 
 ```go
 package main
@@ -133,7 +133,7 @@ func main() {
 func GetInternalIp() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fxnna_LLD9u)</span></b>
 
 ```go
 package main
@@ -165,7 +165,7 @@ func main() {
 func GetIps() []string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/NUFfcEmukx1)</span></b>
 
 ```go
 package main
@@ -195,7 +195,7 @@ func main() {
 func GetMacAddrs() []string {
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Rq9UUBS_Xp1)</span></b>
 
 ```go
 package main
@@ -239,7 +239,7 @@ type PublicIpInfo struct {
 }
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YDxIfozsRHR)</span></b>
 
 ```go
 package main
@@ -269,7 +269,7 @@ func main() {
 func GetRequestPublicIp(req *http.Request) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/kxU-YDc_eBo)</span></b>
 
 ```go
 package main
@@ -307,7 +307,7 @@ func main() {
 func IsPublicIP(IP net.IP) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nmktSQpJZnn)</span></b>
 
 ```go
 package main
@@ -344,7 +344,7 @@ func main() {
 func IsInternalIP(IP net.IP) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sYGhXbgO4Cb)</span></b>
 
 ```go
 package main
@@ -388,7 +388,7 @@ type HttpRequest struct {
 }
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -445,7 +445,7 @@ func NewHttpClientWithConfig(config *HttpClientConfig) *HttpClient
 
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -476,7 +476,7 @@ func main() {
 func (client *HttpClient) SendRequest(request *HttpRequest) (*http.Response, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -530,7 +530,7 @@ func main() {
 func (client *HttpClient) DecodeResponse(resp *http.Response, target any) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -584,7 +584,7 @@ func main() {
 func StructToUrlValues(targetStruct any) url.Values
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pFqMkM40w9z)</span></b>
 
 ```go
 package main
@@ -966,7 +966,7 @@ func main() {
 func IsPingConnected(host string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/q8OzTijsA87)</span></b>
 
 ```go
 package main
@@ -999,7 +999,7 @@ func main() {
 func IsTelnetConnected(host string, port string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/yiLCGtQv_ZG)</span></b>
 
 ```go
 package main

docs/api/packages/pointer.md

@@ -42,7 +42,7 @@ import (
 func Of[T any](v T) *T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HFd70x4DrMj)</span></b>
 
 ```go
 package main
@@ -75,7 +75,7 @@ func main() {
 func Unwrap[T any](p *T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cgeu3g7cjWb)</span></b>
 
 ```go
 package main
@@ -111,7 +111,7 @@ func main() {
 func ExtractPointer(value any) any
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/D7HFjeWU2ZP)</span></b>
 
 ```go
 package main
@@ -146,7 +146,7 @@ func main() {
 UnwarpOr[T any](p *T, fallback T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/mmNaLC38W8C)</span></b>
 
 ```go
 package main
@@ -191,7 +191,7 @@ func main() {
 UnwarpOrDefault[T any](p *T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ZnGIHf8_o4E)</span></b>
 
 ```go
 package main

docs/api/packages/random.md

@@ -29,8 +29,11 @@ import (
 -   [RandLower](#RandLower)
 -   [RandNumeral](#RandNumeral)
 -   [RandNumeralOrLetter](#RandNumeralOrLetter)
+-   [RandSymbolChar](#RandSymbolChar)
 -   [UUIdV4](#UUIdV4)
 -   [RandUniqueIntSlice](#RandUniqueIntSlice)
+-   [RandFloat](#RandFloat)
+-   [RandFloats](#RandFloats)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -46,7 +49,7 @@ import (
 func RandBytes(length int) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/EkiLESeXf8d)</span></b>
 
 ```go
 package main
@@ -72,7 +75,7 @@ func main() {
 func RandInt(min, max int) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pXyyAAI5YxD)</span></b>
 
 ```go
 package main
@@ -98,7 +101,7 @@ func main() {
 func RandString(length int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/W2xvRUXA7Mi)</span></b>
 
 ```go
 package main
@@ -124,7 +127,7 @@ func main() {
 func RandUpper(length int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/29QfOh0DVuh)</span></b>
 
 ```go
 package main
@@ -150,7 +153,7 @@ func main() {
 func RandLower(length int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/XJtZ471cmtI)</span></b>
 
 ```go
 package main
@@ -176,7 +179,7 @@ func main() {
 func RandNumeral(length int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/g4JWVpHsJcf)</span></b>
 
 ```go
 package main
@@ -202,7 +205,7 @@ func main() {
 func RandNumeralOrLetter(length int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/19CEQvpx2jD)</span></b>
 
 ```go
 package main
@@ -218,6 +221,32 @@ func main() {
 }
 ```
 
+### <span id="RandSymbolChar">RandSymbolChar</span>
+
+<p>生成给定长度的随机符号字符串。</p>
+
+<b>函数签名:</b>
+
+```go
+func RandSymbolChar(length int) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Im6ZJxAykOm)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    randStr := random.RandSymbolChar(6)
+    fmt.Println(randStr) // 随机特殊字符字符串，例如: @#(_")
+}
+```
+
 ### <span id="UUIdV4">UUIdV4</span>
 
 <p>生成UUID v4字符串</p>
@@ -228,7 +257,7 @@ func main() {
 func UUIdV4() (string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_Z9SFmr28ft)</span></b>
 
 ```go
 package main
@@ -257,7 +286,7 @@ func main() {
 func RandUniqueIntSlice(n, min, max int) []int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uBkRSOz73Ec)</span></b>
 
 ```go
 package main
@@ -272,3 +301,55 @@ func main() {
     fmt.Println(result) //[0 4 7 1 5] (random)
 }
 ```
+
+### <span id="RandFloat">RandFloat</span>
+
+<p>生成随机float64数字，可以指定范围和精度。</p>
+
+<b>函数签名:</b>
+
+```go
+func RandFloat(min, max float64, precision int) float64
+```
+
+<b>实例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/zbD_tuobJtr)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    floatNumber := random.RandFloat(1.0, 5.0, 2)
+    fmt.Println(floatNumber) //2.14 (random number)
+}
+```
+
+### <span id="RandFloats">RandFloats</span>
+
+<p>生成随机float64数字切片，指定长度，范围和精度.</p>
+
+<b>函数签名:</b>
+
+```go
+func RandFloats(n int, min, max float64, precision int) []float64
+```
+
+<b>实例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/I3yndUQ-rhh)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    floatNumbers := random.RandFloats(5, 1.0, 5.0, 2)
+    fmt.Println(floatNumber) //[3.42 3.99 1.3 2.38 4.23] (random)
+}
+```

docs/api/packages/retry.md

@@ -0,0 +1,464 @@
+# Retry
+
+retry 重试执行函数直到函数运行成功或被 context cancel。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+-   [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>
+
+## 用法:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/retry"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [Context](#Context)
+-   [Retry](#Retry)
+-   [RetryFunc](#RetryFunc)
+-   [RetryDuration](#RetryDuration)
+-   [RetryTimes](#RetryTimes)
+-   [BackoffStrategy](#BackoffStrategy)
+-   [RetryWithCustomBackoff](#RetryWithCustomBackoff)
+-   [RetryWithLinearBackoff](#RetryWithLinearBackoff)
+-   [RetryWithExponentialWithJitterBackoff](#RetryWithExponentialWithJitterBackoff)
+
+<div STYLE="page-break-after: always;"></div>
+
+
+## 文档
+
+### <span id="Context">Context</span>
+
+<p>设置重试context参数</p>
+
+<b>函数签名:</b>
+
+```go
+func Context(ctx context.Context)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/xnAOOXv9GkS)</span></b>
+
+```go
+import (
+    "context"
+    "errors"
+    "fmt"
+    "lancet-demo/retry"
+    "time"
+)
+
+func main() {
+    ctx, cancel := context.WithCancel(context.TODO())
+
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number > 3 {
+            cancel()
+        }
+        return errors.New("error occurs")
+    }
+
+    duration := retry.RetryDuration(time.Microsecond*50)
+
+    retry.Retry(increaseNumber,
+        duration,
+        retry.Context(ctx),
+    )
+
+    fmt.Println(number)
+
+    // Output:
+    // 4
+}
+```
+
+### <span id="RetryFunc">RetryFunc</span>
+
+<p>被重试执行的函数</p>
+
+<b>函数签名:</b>
+
+```go
+type RetryFunc func() error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nk2XRmagfVF)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "errors"
+    "log"
+    "github.com/duke-git/lancet/v2/retry"
+)
+
+func main() {
+    number := 0
+    var increaseNumber retry.RetryFunc = func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
+
+    duration := retry.RetryDuration(time.Microsecond*50)
+
+    err := retry.Retry(increaseNumber, duration)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(number)
+
+    // Output:
+    // 3
+}
+```
+
+### <span id="RetryTimes">RetryTimes</span>
+
+<p>设置重试次数，默认5</p>
+
+<b>函数签名:</b>
+
+```go
+func RetryTimes(n uint)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ssfVeU2SwLO)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "errors"
+    "log"
+    "github.com/duke-git/lancet/v2/retry"
+)
+
+func main() {
+    number := 0
+
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
+
+    err := retry.Retry(increaseNumber, retry.RetryTimes(2))
+    if err != nil {
+        fmt.Println(err)
+    }
+
+    // Output:
+    // function main.main.func1 run failed after 2 times retry
+}
+```
+
+### <span id="RetryDuration">RetryDuration</span>
+
+<p>设置重试间隔时间，默认3秒</p>
+
+<b>函数签名:</b>
+
+```go
+func RetryDuration(d time.Duration)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nk2XRmagfVF)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "errors"
+    "log"
+    "github.com/duke-git/lancet/v2/retry"
+)
+
+func main() {
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
+
+    duration := retry.RetryDuration(time.Microsecond*50)
+
+    err := retry.Retry(increaseNumber, duration)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(number)
+
+    // Output:
+    // 3
+}
+```
+
+### <span id="Retry">Retry</span>
+
+<p>重试执行函数retryFunc，直到函数运行成功，或被context停止</p>
+
+<b>函数签名:</b>
+
+```go
+func Retry(retryFunc RetryFunc, opts ...Option) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nk2XRmagfVF)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "errors"
+    "log"
+    "github.com/duke-git/lancet/v2/retry"
+)
+
+func main() {
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
+
+    duration := retry.RetryDuration(time.Microsecond*50)
+
+    err := retry.Retry(increaseNumber, duration)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(number)
+
+    // Output:
+    // 3
+}
+```
+
+### <span id="BackoffStrategy">BackoffStrategy</span>
+
+<p>定义计算退避间隔的方法的接口。</p>
+
+<b>函数签名:</b>
+
+```go
+// BackoffStrategy is an interface that defines a method for calculating backoff intervals.
+type BackoffStrategy interface {
+    // CalculateInterval returns the time.Duration after which the next retry attempt should be made.
+    CalculateInterval() time.Duration
+}
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "errors"
+    "log"
+    "github.com/duke-git/lancet/v2/retry"
+)
+
+type ExampleCustomBackoffStrategy struct {
+    interval time.Duration
+}
+
+func (c *ExampleCustomBackoffStrategy) CalculateInterval() time.Duration {
+    return c.interval + 1
+}
+
+func main() {
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
+
+    err := retry,Retry(increaseNumber, retry.RetryWithCustomBackoff(&示例CustomBackoffStrategy{interval: time.Microsecond * 50}))
+    if err != nil {
+        return
+    }
+
+    fmt.Println(number)
+
+    // Output:
+    // 3
+}
+```
+
+### <span id="RetryWithCustomBackoff">RetryWithCustomBackoff</span>
+
+<p>设置自定义退避策略。</p>
+
+<b>函数签名:</b>
+
+```go
+func RetryWithCustomBackoff(backoffStrategy BackoffStrategy) Option 
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "errors"
+    "log"
+    "github.com/duke-git/lancet/v2/retry"
+)
+
+type ExampleCustomBackoffStrategy struct {
+    interval time.Duration
+}
+
+func (c *ExampleCustomBackoffStrategy) CalculateInterval() time.Duration {
+    return c.interval + 1
+}
+
+func main() {
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
+
+    err := retry,Retry(increaseNumber, retry.RetryWithCustomBackoff(&示例CustomBackoffStrategy{interval: time.Microsecond * 50}))
+    if err != nil {
+        return
+    }
+
+    fmt.Println(number)
+
+    // Output:
+    // 3
+}
+```
+
+
+### <span id="RetryWithLinearBackoff">RetryWithLinearBackoff</span>
+
+<p>设置线性策略退避。</p>
+
+<b>函数签名:</b>
+
+```go
+func RetryWithLinearBackoff(interval time.Duration) Option
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "errors"
+    "log"
+    "github.com/duke-git/lancet/v2/retry"
+)
+
+func main() {
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
+
+    err := retry.Retry(increaseNumber, retry.RetryWithLinearBackoff(time.Microsecond*50))
+    if err != nil {
+        return
+    }
+
+    fmt.Println(number)
+
+    // Output:
+    // 3
+}
+```
+
+
+### <span id="RetryWithExponentialWithJitterBackoff">RetryWithExponentialWithJitterBackoff</span>
+
+<p>设置指数策略退避。</p>
+
+<b>函数签名:</b>
+
+```go
+func RetryWithExponentialWithJitterBackoff(interval time.Duration, base uint64, maxJitter time.Duration) Option
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "errors"
+    "log"
+    "github.com/duke-git/lancet/v2/retry"
+)
+
+func main() {
+    number := 0
+    increaseNumber := func() error {
+        number++
+        if number == 3 {
+            return nil
+        }
+        return errors.New("error occurs")
+    }
+
+    err := retry.Retry(increaseNumber, retry.RetryWithExponentialWithJitterBackoff(time.Microsecond*50, 2, time.Microsecond*25))
+    if err != nil {
+        return
+    }
+
+    fmt.Println(number)
+
+    // Output:
+    // 3
+}
+```

docs/api/packages/slice.md

@@ -35,6 +35,7 @@ import (
 -   [DifferenceBy](#DifferenceBy)
 -   [DifferenceWith](#DifferenceWith)
 -   [DeleteAt](#DeleteAt)
+-   [DeleteRange](#DeleteRange)
 -   [Drop](#Drop)
 -   [DropRight](#DropRight)
 -   [DropWhile](#DropWhile)
@@ -77,7 +78,7 @@ import (
 -   [IsSortedByKey](#IsSortedByKey)
 -   [Sort](#Sort)
 -   [SortBy](#SortBy)
--   [SortByField<sup>deprecated</sup>](#SortByField)
+-   [SortByField](#SortByField)
 -   [Some](#Some)
 -   [StringSlice<sup>deprecated</sup>](#StringSlice)
 -   [SymmetricDifference](#SymmetricDifference)
@@ -91,9 +92,15 @@ import (
 -   [Without](#Without)
 -   [KeyBy](#KeyBy)
 -   [Join](#Join)
+-   [Partition](#Partition)
+-   [SetToDefaultIf](#SetToDefaultIf)
+-   [Break](#Break)
+-   [RightPadding](#RightPadding)
+-   [LeftPadding](#LeftPadding)
 
 <div STYLE="page-break-after: always;"></div>
 
+
 ## 文档
 
 ### <span id="AppendIfAbsent">AppendIfAbsent</span>
@@ -106,7 +113,7 @@ import (
 func AppendIfAbsent[T comparable](slice []T, item T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GNdv7Jg2Taj)</span></b>
 
 ```go
 import (
@@ -137,7 +144,7 @@ func main() {
 func Contain[T comparable](slice []T, target T) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_454yEHcNjf)</span></b>
 
 ```go
 import (
@@ -168,7 +175,7 @@ func main() {
 func ContainBy[T any](slice []T, predicate func(item T) bool) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/49tkHfX4GNc)</span></b>
 
 ```go
 import (
@@ -213,7 +220,7 @@ func main() {
 func ContainSubSlice[T comparable](slice, subSlice []T) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/bcuQ3UT6Sev)</span></b>
 
 ```go
 import (
@@ -244,7 +251,7 @@ func main() {
 func Chunk[T any](slice []T, size int) [][]T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/b4Pou5j2L_C)</span></b>
 
 ```go
 import (
@@ -286,7 +293,7 @@ func main() {
 func Compact[T comparable](slice []T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pO5AnxEr3TK)</span></b>
 
 ```go
 import (
@@ -323,7 +330,7 @@ func main() {
 func Concat[T any](slice []T, slices ...[]T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/gPt-q7zr5mk)</span></b>
 
 ```go
 import (
@@ -354,7 +361,7 @@ func main() {
 func Count[T comparable](slice []T, item T) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Mj4oiEnQvRJ)</span></b>
 
 ```go
 import (
@@ -387,7 +394,7 @@ func main() {
 func CountBy[T any](slice []T, predicate func(index int, item T) bool) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tHOccTMDZCC)</span></b>
 
 ```go
 import (
@@ -421,7 +428,7 @@ func main() {
 func Difference[T comparable](slice, comparedSlice []T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VXvadzLzhDa)</span></b>
 
 ```go
 import (
@@ -452,7 +459,7 @@ func main() {
 func DifferenceBy[T comparable](slice []T, comparedSlice []T, iteratee func(index int, item T) T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/DiivgwM5OnC)</span></b>
 
 ```go
 import (
@@ -487,7 +494,7 @@ func main() {
 func DifferenceWith[T any](slice []T, comparedSlice []T, comparator func(value, otherValue T) bool) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/v2U2deugKuV)</span></b>
 
 ```go
 import (
@@ -514,15 +521,15 @@ func main() {
 
 ### <span id="DeleteAt">DeleteAt</span>
 
-<p>删除切片中指定开始索引到结束索引的元素</p>
+<p>删除切片中指定索引的元素（不修改原切片）。</p>
 
 <b>函数签名:</b>
 
 ```go
-func DeleteAt[T any](slice []T, start int, end ...int)
+func DeleteAt[T any](slice []T, index int) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/800B1dPBYyd)</span></b>
 
 ```go
 import (
@@ -531,18 +538,66 @@ import (
 )
 
 func main() {
-    result1 := slice.DeleteAt([]string{"a", "b", "c"}, -1)
-    result2 := slice.DeleteAt([]string{"a", "b", "c"}, 0)
-    result3 := slice.DeleteAt([]string{"a", "b", "c"}, 0, 2)
+    chars := []string{"a", "b", "c", "d", "e"}
+
+    result1 := slice.DeleteAt(chars, 0)
+    result2 := slice.DeleteAt(chars, 4)
+    result3 := slice.DeleteAt(chars, 5)
+    result4 := slice.DeleteAt(chars, 6)
 
     fmt.Println(result1)
     fmt.Println(result2)
     fmt.Println(result3)
+    fmt.Println(result4)
 
     // Output:
-    // [a b c]
-    // [b c]
-    // [c]
+    // [b c d e]
+    // [a b c d]
+    // [a b c d]
+    // [a b c d]
+
+}
+```
+
+### <span id="DeleteRange">DeleteRange</span>
+
+<p>删除切片中指定索引范围的元素（不修改原切片）。</p>
+
+<b>函数签名:</b>
+
+```go
+func DeleteRange[T any](slice []T, start, end int) []T 
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/945HwiNrnle)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    chars := []string{"a", "b", "c", "d", "e"}
+
+    result1 := DeleteRange(chars, 0, 0)
+    result2 := DeleteRange(chars, 0, 1)
+    result3 := DeleteRange(chars, 0, 3)
+    result4 := DeleteRange(chars, 0, 4)
+    result5 := DeleteRange(chars, 0, 5)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+
+    // Output:
+    // [a b c d e]
+    // [b c d e]
+    // [d e]
+    // [e]
+    // []
 
 }
 ```
@@ -557,7 +612,7 @@ func main() {
 func Drop[T any](slice []T, n int) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jnPO2yQsT8H)</span></b>
 
 ```go
 import (
@@ -594,7 +649,7 @@ func main() {
 func DropRight[T any](slice []T, n int) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8bcXvywZezG)</span></b>
 
 ```go
 import (
@@ -631,7 +686,7 @@ func main() {
 func DropWhile[T any](slice []T, predicate func(item T) bool) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4rt252UV_qs)</span></b>
 
 ```go
 import (
@@ -671,7 +726,7 @@ func main() {
 func DropRightWhile[T any](slice []T, predicate func(item T) bool) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/6wyK3zMY56e)</span></b>
 
 ```go
 import (
@@ -713,7 +768,7 @@ func main() {
 func Every[T any](slice []T, predicate func(index int, item T) bool) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/R8U6Sl-j8cD)</span></b>
 
 ```go
 import (
@@ -747,7 +802,7 @@ func main() {
 func Equal[T comparable](slice1, slice2 []T) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/WcRQJ37ifPa)</span></b>
 
 ```go
 import (
@@ -782,7 +837,7 @@ func main() {
 func EqualWith[T, U any](slice1 []T, slice2 []U, comparator func(T, U) bool) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/b9iygtgsHI1)</span></b>
 
 ```go
 import (
@@ -817,7 +872,7 @@ func main() {
 func Filter[T any](slice []T, predicate func(index int, item T) bool) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/SdPna-7qK4T)</span></b>
 
 ```go
 import (
@@ -851,7 +906,7 @@ func main() {
 func Find[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/CBKeBoHVLgq)</span></b>
 
 ```go
 import (
@@ -887,7 +942,7 @@ func main() {
 func FindBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/n1lysBYl-GB)</span></b>
 
 ```go
 import (
@@ -923,7 +978,7 @@ func main() {
 func FindLast[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/FFDPV_j7URd)</span></b>
 
 ```go
 import (
@@ -959,7 +1014,7 @@ func main() {
 func FindLastBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8iqomzyCl_s)</span></b>
 
 ```go
 import (
@@ -995,7 +1050,7 @@ func main() {
 func Flatten(slice any) any
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/hYa3cBEevtm)</span></b>
 
 ```go
 import (
@@ -1025,7 +1080,7 @@ func main() {
 func FlattenDeep(slice any) any
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/yjYNHPyCFaF)</span></b>
 
 ```go
 import (
@@ -1055,7 +1110,7 @@ func main() {
 func ForEach[T any](slice []T, iteratee func(index int, item T))
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/DrPaa4YsHRF)</span></b>
 
 ```go
 import (
@@ -1090,7 +1145,7 @@ func main() {
 func ForEachWithBreak[T any](slice []T, iteratee func(index int, item T) bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qScs39f3D9W)</span></b>
 
 ```go
 import (
@@ -1128,7 +1183,7 @@ func main() {
 func GroupBy[T any](slice []T, groupFn func(index int, item T) bool) ([]T, []T)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/QVkPxzPR0iA)</span></b>
 
 ```go
 import (
@@ -1164,7 +1219,7 @@ func main() {
 func GroupWith[T any, U comparable](slice []T, iteratee func(T) U) map[U][]T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ApCvMNTLO8a)</span></b>
 
 ```go
 import (
@@ -1198,7 +1253,7 @@ func main() {
 func IntSlice(slice any) []int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UQDj-on9TGN)</span></b>
 
 ```go
 import (
@@ -1227,7 +1282,7 @@ func main() {
 func InterfaceSlice(slice any) []any
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/FdQXF0Vvqs-)</span></b>
 
 ```go
 import (
@@ -1256,7 +1311,7 @@ func main() {
 func Intersection[T comparable](slices ...[]T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/anJXfB5wq_t)</span></b>
 
 ```go
 import (
@@ -1287,7 +1342,7 @@ func main() {
 func InsertAt[T any](slice []T, index int, value any) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/hMLNxPEGJVE)</span></b>
 
 ```go
 import (
@@ -1327,7 +1382,7 @@ func main() {
 func IndexOf[T comparable](slice []T, item T) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/MRN1f0FpABb)</span></b>
 
 ```go
 import (
@@ -1360,7 +1415,7 @@ func main() {
 func LastIndexOf[T comparable](slice []T, item T) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/DokM4cf1IKH)</span></b>
 
 ```go
 import (
@@ -1393,7 +1448,7 @@ func main() {
 func Map[T any, U any](slice []T, iteratee func(index int, item T) U) []U
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/biaTefqPquw)</span></b>
 
 ```go
 import (
@@ -1427,7 +1482,7 @@ func main() {
 func FilterMap[T any, U any](slice []T, iteratee func(index int, item T) (U, bool)) []U
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/J94SZ_9MiIe)</span></b>
 
 ```go
 import (
@@ -1464,7 +1519,7 @@ func main() {
 func FlatMap[T any, U any](slice []T, iteratee func(index int, item T) []U) []U
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_QARWlWs1N_F)</span></b>
 
 ```go
 import (
@@ -1497,7 +1552,7 @@ func main() {
 func Merge[T any](slices ...[]T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/lbjFp784r9N)</span></b>
 
 ```go
 import (
@@ -1528,7 +1583,7 @@ func main() {
 func Reverse[T any](slice []T)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8uI8f1lwNrQ)</span></b>
 
 ```go
 import (
@@ -1558,7 +1613,7 @@ func main() {
 func Reduce[T any](slice []T, iteratee func(index int, item1, item2 T) T, initial T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_RfXJJWIsIm)</span></b>
 
 ```go
 import (
@@ -1592,7 +1647,7 @@ func main() {
 func ReduceBy[T any, U any](slice []T, initial U, reducer func(index int, item T, agg U) U) U
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YKDpLi7gtee)</span></b>
 
 ```go
 import (
@@ -1628,7 +1683,7 @@ func main() {
 func ReduceRight[T any, U any](slice []T, initial U, reducer func(index int, item T, agg U) U) U
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qT9dZC03A1K)</span></b>
 
 ```go
 import (
@@ -1658,7 +1713,7 @@ func main() {
 func Replace[T comparable](slice []T, old T, new T, n int) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/P5mZp7IhOFo)</span></b>
 
 ```go
 import (
@@ -1700,7 +1755,7 @@ func main() {
 func ReplaceAll[T comparable](slice []T, old T, new T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/CzqXMsuYUrx)</span></b>
 
 ```go
 import (
@@ -1728,7 +1783,7 @@ func main() {
 func Repeat[T any](item T, n int) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/1CbOmtgILUU)</span></b>
 
 ```go
 import (
@@ -1756,7 +1811,7 @@ func main() {
 func Shuffle[T any](slice []T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YHvhnWGU3Ge)</span></b>
 
 ```go
 import (
@@ -1785,7 +1840,7 @@ func main() {
 func IsAscending[T constraints.Ordered](slice []T) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9CtsFjet4SH)</span></b>
 
 ```go
 import (
@@ -1819,7 +1874,7 @@ func main() {
 func IsDescending[T constraints.Ordered](slice []T) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/U_LljFXma14)</span></b>
 
 ```go
 import (
@@ -1853,7 +1908,7 @@ func main() {
 func IsSorted[T constraints.Ordered](slice []T) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nCE8wPLwSA-)</span></b>
 
 ```go
 import (
@@ -1887,7 +1942,7 @@ func main() {
 func IsSortedByKey[T any, K constraints.Ordered](slice []T, iteratee func(item T) K) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tUoGB7DOHI4)</span></b>
 
 ```go
 import (
@@ -1927,7 +1982,7 @@ func main() {
 func Sort[T constraints.Ordered](slice []T, sortOrder ...string)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/V9AVjzf_4Fk)</span></b>
 
 ```go
 import (
@@ -1964,7 +2019,7 @@ func main() {
 func SortBy[T any](slice []T, less func(a, b T) bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/DAhLQSZEumm)</span></b>
 
 ```go
 import (
@@ -2001,9 +2056,9 @@ func main() {
 }
 ```
 
-### <span id="SortByField">SortByField (已弃用: 请使用 Sort 或 SortBy 代替该方法)</span>
+### <span id="SortByField">SortByField</span>
 
-<p>按字段对结构切片进行排序。slice元素应为struct，字段类型应为int、uint、string或bool。 默认排序类型是升序（asc），如果是降序，设置 sortType 为 desc</p>
+<p>按字段对结构体切片进行排序。slice元素应为struct，排序字段field类型应为int、uint、string或bool。 默认排序类型是升序（asc），如果是降序，设置 sortType 为 desc</p>
 
 <b>函数签名:</b>
 
@@ -2011,7 +2066,7 @@ func main() {
 func SortByField(slice any, field string, sortType ...string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fU1prOBP9p1)</span></b>
 
 ```go
 import (
@@ -2052,7 +2107,7 @@ func main() {
 func Some[T any](slice []T, predicate func(index int, item T) bool) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4pO9Xf9NDGS)</span></b>
 
 ```go
 import (
@@ -2086,7 +2141,7 @@ func main() {
 func StringSlice(slice any) []string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/W0TZDWCPFcI)</span></b>
 
 ```go
 import (
@@ -2115,7 +2170,7 @@ func main() {
 func SymmetricDifference[T comparable](slices ...[]T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/1CbOmtgILUU)</span></b>
 
 ```go
 import (
@@ -2146,7 +2201,7 @@ func main() {
 func ToSlice[T any](items ...T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YzbzVq5kscN)</span></b>
 
 ```go
 import (
@@ -2174,7 +2229,7 @@ func main() {
 func ToSlicePointer[T any](items ...T) []*T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/gx4tr6_VXSF)</span></b>
 
 ```go
 import (
@@ -2209,7 +2264,7 @@ func main() {
 func Unique[T comparable](slice []T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/AXw0R3ZTE6a)</span></b>
 
 ```go
 import (
@@ -2236,7 +2291,7 @@ func main() {
 func UniqueBy[T comparable](slice []T, iteratee func(item T) T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UR323iZLDpv)</span></b>
 
 ```go
 import (
@@ -2267,7 +2322,7 @@ func main() {
 func Union[T comparable](slices ...[]T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/hfXV1iRIZOf)</span></b>
 
 ```go
 import (
@@ -2298,7 +2353,7 @@ func main() {
 func UnionBy[T any, V comparable](predicate func(item T) V, slices ...[]T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HGKHfxKQsFi)</span></b>
 
 ```go
 import (
@@ -2323,7 +2378,7 @@ func main() {
 
 ### <span id="UpdateAt">UpdateAt</span>
 
-<p>更新索引处的切片元素。 如果index < 0或 index >= len(slice)，将返回错误</p>
+<p>更新索引处的切片元素。 如果index &lt 0或 index &lt= len(slice)，将返回错误</p>
 
 <b>函数签名:</b>
 
@@ -2331,7 +2386,7 @@ func main() {
 func UpdateAt[T any](slice []T, index int, value T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/f3mh2KloWVm)</span></b>
 
 ```go
 import (
@@ -2371,7 +2426,7 @@ func main() {
 func Without[T comparable](slice []T, items ...T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/bwhEXEypThg)</span></b>
 
 ```go
 import (
@@ -2399,7 +2454,7 @@ func main() {
 func KeyBy[T any, U comparable](slice []T, iteratee func(item T) U) map[U]T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uXod2LWD1Kg)</span></b>
 
 ```go
 import (
@@ -2429,7 +2484,7 @@ func main() {
 func Join[T any](s []T, separator string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/huKzqwNDD7V)</span></b>
 
 ```go
 import (
@@ -2451,3 +2506,188 @@ func main() {
     // 1-2-3-4-5
 }
 ```
+
+### <span id="Partition">Partition</span>
+
+<p>根据给定的predicate判断函数分组切片元素。</p>
+
+<b>函数签名:</b>
+
+```go
+func Partition[T any](slice []T, predicates ...func(item T) bool) [][]T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/lkQ3Ri2NQhV)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4, 5}
+
+    result1 := slice.Partition(nums)
+    result2 := slice.Partition(nums, func(n int) bool { return n%2 == 0 })
+    result3 := slice.Partition(nums, func(n int) bool { return n == 1 || n == 2 }, func(n int) bool { return n == 2 || n == 3 || n == 4 })
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+
+    // Output:
+    // [[1 2 3 4 5]]
+    // [[2 4] [1 3 5]]
+    // [[1 2] [3 4] [5]]
+}
+```
+
+
+### <span id="Random">Random</span>
+
+<p>随机返回切片中元素以及下标, 当切片长度为0时返回下标-1</p>
+
+<b>函数签名:</b>
+
+```go
+func Random[T any](slice []T) (val T, idx int)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UzpGQptWppw)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4, 5}
+
+    val, idx := slice.Random(nums)
+    if idx >= 0 && idx < len(nums) && slice.Contain(nums, val) {
+        fmt.Println("okk")
+    }
+    // Output:
+    // okk
+}
+```
+
+### <span id="SetToDefaultIf">SetToDefaultIf</span>
+
+<p>根据给定给定的predicate判定函数来修改切片中的元素。对于满足的元素，将其替换为指定的默认值，同时保持元素在切片中的位置不变。函数返回修改后的切片以及被修改的元素个数。</p>
+
+<b>函数签名:</b>
+
+```go
+func SetToDefaultIf[T any](slice []T, predicate func(T) bool) ([]T, int)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9AXGlPRC0-A)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    strs := []string{"a", "b", "a", "c", "d", "a"}
+	modifiedStrs, count := slice.SetToDefaultIf(strs, func(s string) bool { return "a" == s })
+	
+    fmt.Println(modifiedStrs)
+	fmt.Println(count)
+	
+    // Output:
+	// [ b  c d ]
+	// 3
+}
+```
+
+### <span id="Break">Break</span>
+
+<p>根据判断函数将切片分成两部分。它开始附加到与函数匹配的第一个元素之后的第二个切片。第一个匹配之后的所有元素都包含在第二个切片中，无论它们是否与函数匹配。</p>
+
+<b>函数签名:</b>
+
+```go
+func Break[T any](values []T, predicate func(T) bool) ([]T, []T)
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4, 5}
+    even := func(n int) bool { return n%2 == 0 }
+
+    resultEven, resultAfterFirstEven := slice.Break(nums, even)
+    
+    fmt.Println(resultEven)
+    fmt.Println(resultAfterFirstEven)
+    
+    // Output:
+    // [1]
+    // [2 3 4 5]
+}
+```
+
+<span id="RightPadding">RightPadding</span>
+
+<p>在切片的右部添加元素。</p>
+
+<b>函数签名:</b>
+
+```go
+func RightPadding[T any](slice []T, paddingValue T, paddingLength int) []T
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+  	nums := []int{1, 2, 3, 4, 5}
+	padded := slice.RightPadding(nums, 0, 3)
+	fmt.Println(padded)
+	// Output:
+	// [1 2 3 4 5 0 0 0]
+}
+```
+
+<span id="LeftPadding">LeftPadding</span>
+
+<p>在切片的左部添加元素。</p>
+
+<b>函数签名:</b>
+
+```go
+func LeftPadding[T any](slice []T, paddingValue T, paddingLength int) []T
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+  	nums := []int{1, 2, 3, 4, 5}
+	padded := slice.LeftPadding(nums, 0, 3)
+	fmt.Println(padded)
+	// Output:
+	// [0 0 0 1 2 3 4 5]
+}
+```

docs/api/packages/stream.md

@@ -63,7 +63,7 @@ import (
 func Of[T any](elems ...T) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jI6_iZZuVFE)</span></b>
 
 ```go
 import (
@@ -93,7 +93,7 @@ func main() {
 func FromSlice[T any](source []T) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/wywTO0XZtI4)</span></b>
 
 ```go
 import (
@@ -123,7 +123,7 @@ func main() {
 func FromChannel[T any](source <-chan T) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9TZYugGMhXZ)</span></b>
 
 ```go
 import (
@@ -161,7 +161,7 @@ func main() {
 func FromRange[T constraints.Integer | constraints.Float](start, end, step T) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9Ex1-zcg-B-)</span></b>
 
 ```go
 import (
@@ -190,7 +190,7 @@ func main() {
 func Generate[T any](generator func() func() (item T, ok bool)) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/rkOWL1yA3j9)</span></b>
 
 ```go
 import (
@@ -230,7 +230,7 @@ func main() {
 func Concat[T any](a, b stream[T]) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HM4OlYk_OUC)</span></b>
 
 ```go
 import (
@@ -263,7 +263,7 @@ func main() {
 func (s stream[T]) Distinct() stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/eGkOSrm64cB)</span></b>
 
 ```go
 import (
@@ -297,7 +297,7 @@ func main() {
 func (s stream[T]) Filter(predicate func(item T) bool) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/MFlSANo-buc)</span></b>
 
 ```go
 import (
@@ -331,7 +331,7 @@ func main() {
 func (s stream[T]) Map(mapper func(item T) T) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OtNQUImdYko)</span></b>
 
 ```go
 import (
@@ -365,7 +365,7 @@ func main() {
 func (s stream[T]) Peek(consumer func(item T)) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/u1VNzHs6cb2)</span></b>
 
 ```go
 import (
@@ -402,7 +402,7 @@ func main() {
 func (s stream[T]) Skip(n int) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fNdHbqjahum)</span></b>
 
 ```go
 import (
@@ -441,7 +441,7 @@ func main() {
 func (s stream[T]) Limit(maxSize int) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qsO4aniDcGf)</span></b>
 
 ```go
 import (
@@ -480,7 +480,7 @@ func main() {
 func (s stream[T]) Reverse() stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/A8_zkJnLHm4)</span></b>
 
 ```go
 import (
@@ -510,7 +510,7 @@ func main() {
 func (s stream[T]) Range(start, end int) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/indZY5V2f4j)</span></b>
 
 ```go
 import (
@@ -549,7 +549,7 @@ func main() {
 func (s stream[T]) Sorted(less func(a, b T) bool) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/XXtng5uonFj)</span></b>
 
 ```go
 import (
@@ -581,7 +581,7 @@ func main() {
 func (s stream[T]) ForEach(action func(item T))
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Dsm0fPqcidk)</span></b>
 
 ```go
 import (
@@ -614,7 +614,7 @@ func main() {
 func (s stream[T]) Reduce(initial T, accumulator func(a, b T) T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/6uzZjq_DJLU)</span></b>
 
 ```go
 import (
@@ -646,7 +646,7 @@ func main() {
 func (s stream[T]) FindFirst() (T, bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9xEf0-6C1e3)</span></b>
 
 ```go
 import (
@@ -678,7 +678,7 @@ func main() {
 func (s stream[T]) FindLast() (T, bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/WZD2rDAW-2h)</span></b>
 
 ```go
 import (
@@ -710,7 +710,7 @@ func main() {
 func (s stream[T]) Max(less func(a, b T) bool) (T, bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fm-1KOPtGzn)</span></b>
 
 ```go
 import (
@@ -734,7 +734,7 @@ func main() {
 
 ### <span id="Min">Min</span>
 
-<p>根据提供的less函数返回stream的最小元素。less函数: a < b</p>
+<p>根据提供的less函数返回stream的最小元素。less函数: a &lt b</p>
 
 <b>函数签名:</b>
 
@@ -742,7 +742,7 @@ func main() {
 func (s stream[T]) Min(less func(a, b T) bool) (T, bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/vZfIDgGNRe_0)</span></b>
 
 ```go
 import (
@@ -774,7 +774,7 @@ func main() {
 func (s stream[T]) AllMatch(predicate func(item T) bool) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/V5TBpVRs-Cx)</span></b>
 
 ```go
 import (
@@ -812,7 +812,7 @@ func main() {
 func (s stream[T]) AnyMatch(predicate func(item T) bool) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/PTCnWn4OxSn)</span></b>
 
 ```go
 import (
@@ -850,7 +850,7 @@ func main() {
 func (s stream[T]) NoneMatch(predicate func(item T) bool) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/iWS64pL1oo3)</span></b>
 
 ```go
 import (
@@ -888,7 +888,7 @@ func main() {
 func (s stream[T]) Count() int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/r3koY6y_Xo-)</span></b>
 
 ```go
 import (
@@ -919,7 +919,7 @@ func main() {
 func (s stream[T]) ToSlice() []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jI6_iZZuVFE)</span></b>
 
 ```go
 import (

docs/api/packages/struct.md

@@ -1,11 +1,13 @@
-# Field
+# Structs
 
-Field 包封装了一个抽象的`Field`结构体，提供了操作`struct`属性的相关函数
+structs 包封装了一个抽象的`Struct`结构体，提供了操作`struct`的相关函数
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 源码:
 
+-   [https://github.com/duke-git/lancet/blob/main/structs/struct.go](https://github.com/duke-git/lancet/blob/main/structs/struct.go)
+
 -   [https://github.com/duke-git/lancet/blob/main/structs/field.go](https://github.com/duke-git/lancet/blob/main/structs/field.go)
 
 <div STYLE="page-break-after: always;"></div>
@@ -21,6 +23,12 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## 目录:
+
+-   [New](#New)
+-   [ToMap](#ToMap)
+-   [Fields](#Fields)
+-   [Field](#Field)
+-   [IsStruct](#IsStruct)
 -   [Tag](#Tag)
 -   [Name](#Name)
 -   [Value](#Value)
@@ -29,18 +37,192 @@ import (
 -   [IsExported](#IsExported)
 -   [IsZero](#IsZero)
 -   [IsSlice](#IsSlice)
-
-> 注意：由于`Field`继承于`Struct`，所以同样拥有`Struct`所有方法，如下：
-
--   [ToMap](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#ToMap)
--   [Fields](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#Fields)
--   [Field](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#Field)
--   [IsStruct](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#IsStruct)
+-   [IsTargetType](#IsTargetType)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## API 文档:
 
+### <span id="New">New</span>
+
+<p>`Struct`结构体的构造函数</p>
+
+<b>函数签名:</b>
+
+```go
+func New(value any, tagName ...string) *Struct
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type People struct {
+        Name string `json:"name"`
+    }
+    p1 := &People{Name: "11"}
+    s := structs.New(p1)
+    // to do something
+}
+```
+
+### <span id="ToMap">ToMap</span>
+
+<p>将一个合法的struct对象转换为map[string]any</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *Struct) ToMap() (map[string]any, error)
+```
+
+<b>除此之外，提供一个便捷的静态方法 ToMap</b>
+
+```go
+func ToMap(v any) (map[string]any, error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type People struct {
+        Name string `json:"name"`
+    }
+    p1 := &People{Name: "11"}
+    s1 := structs.New(p1)
+    m1, _ := s1.ToMap()
+
+    fmt.Println(m1)
+
+    // 如果不需要Struct更多的方法，可以直接使用ToMap
+    m2, _ := structs.ToMap(p1)
+
+    fmt.Println(m2)
+
+    // Output:
+    // map[name:11]
+    // map[name:11]
+}
+```
+
+### <span id="Fields">Fields</span>
+
+<p>获取一个struct对象的属性列表</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *Struct) Fields() []*Field
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type People struct {
+        Name string `json:"name"`
+    }
+    p1 := &People{Name: "11"}
+    s := structs.New(p1)
+    fields := s.Fields()
+
+    fmt.Println(len(fields))
+
+    // Output:
+    // 1
+}
+```
+
+### <span id="Field">Field</span>
+
+<p>根据属性名获取一个struct对象的属性</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *Struct) Field(name string) *Field
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type People struct {
+        Name string `json:"name"`
+    }
+    p1 := &People{Name: "11"}
+    s := structs.New(p1)
+    f := s.Field("Name")
+
+    fmt.Println(f.Value())
+
+    // Output:
+    // 11
+}
+```
+
+### <span id="IsStruct">IsStruct</span>
+
+<p>判断是否为一个合法的struct对象</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *Struct) IsStruct() bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type People struct {
+        Name string `json:"name"`
+    }
+    p1 := &People{Name: "11"}
+    s := structs.New(p1)
+
+    fmt.Println(s.IsStruct())
+
+    // Output:
+    // true
+}
+```
+
 ### <span id="Tag">Tag</span>
 
 <p>获取`Field`的`Tag`，默认的tag key是json</p>
@@ -350,4 +532,45 @@ func main() {
     // Output: 
     // true
 }
+```
+
+### <span id="IsTargetType">IsTargetType</span>
+
+<p>判断属性是否是目标类型</p>
+
+<b>函数签名:</b>
+
+```go
+func (f *Field) IsTargetType(targetType reflect.Kind) bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "reflect"
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type Parent struct {
+        Name string
+        arr  []int
+    }
+
+    p1 := &Parent{arr: []int{1, 2, 3}}
+    s := structs.New(p1)
+    n, _ := s.Field("Name")
+	a, _ := s.Field("arr")
+    
+    fmt.Println(n.IsTargetType(reflect.String))
+    fmt.Println(a.IsTargetType(reflect.Slice))
+    
+    // Output: 
+    // true
+    // true
+}
 ```

docs/api/packages/strutil.md

@@ -49,6 +49,7 @@ import (
 -   [StringToBytes](#StringToBytes)
 -   [BytesToString](#BytesToString)
 -   [IsBlank](#IsBlank)
+-   [IsNotBlank](#IsNotBlank)
 -   [HasPrefixAny](#HasPrefixAny)
 -   [HasSuffixAny](#HasSuffixAny)
 -   [IndexOffset](#IndexOffset)
@@ -59,10 +60,13 @@ import (
 -   [ContainsAll](#ContainsAll)
 -   [ContainsAny](#ContainsAny)
 -   [RemoveWhiteSpace](#RemoveWhiteSpace)
+-   [SubInBetween](#SubInBetween)
+-   [HammingDistance](#HammingDistance)
+-   [Concat](#Concat)
 
 <div STYLE="page-break-after: always;"></div>
 
-## Documentation 文档
+## 文档
 
 ### <span id="After">After</span>
 
@@ -74,7 +78,7 @@ import (
 func After(s, char string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/RbCOQqCDA7m)</span></b>
 
 ```go
 import (
@@ -114,7 +118,7 @@ func main() {
 func AfterLast(s, char string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/1TegARrb8Yn)</span></b>
 
 ```go
 import (
@@ -154,7 +158,7 @@ func main() {
 func Before(s, char string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/JAWTZDS4F5w)</span></b>
 
 ```go
 import (
@@ -191,7 +195,7 @@ func main() {
 func BeforeLast(s, char string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pJfXXAoG_Te)</span></b>
 
 ```go
 import (
@@ -228,7 +232,7 @@ func main() {
 func CamelCase(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9eXP3tn2tUy)</span></b>
 
 ```go
 import (
@@ -263,7 +267,7 @@ func main() {
 func KebabCase(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dcZM9Oahw-Y)</span></b>
 
 ```go
 import (
@@ -298,7 +302,7 @@ func main() {
 func UpperKebabCase(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/zDyKNneyQXk)</span></b>
 
 ```go
 import (
@@ -333,7 +337,7 @@ func main() {
 func Capitalize(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2OAjgbmAqHZ)</span></b>
 
 ```go
 import (
@@ -368,7 +372,7 @@ func main() {
 func IsString(v any) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/IOgq7oF9ERm)</span></b>
 
 ```go
 import (
@@ -408,7 +412,7 @@ func main() {
 func LowerFirst(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/CbzAyZmtJwL)</span></b>
 
 ```go
 import (
@@ -442,7 +446,7 @@ func main() {
 func UpperFirst(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sBbBxRbs8MM)</span></b>
 
 ```go
 import (
@@ -476,7 +480,7 @@ func main() {
 func Pad(source string, size int, padStr string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/NzImQq-VF8q)</span></b>
 
 ```go
 import (
@@ -521,7 +525,7 @@ func main() {
 func PadEnd(source string, size int, padStr string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9xP8rN0vz--)</span></b>
 
 ```go
 import (
@@ -567,7 +571,7 @@ func main() {
 func PadStart(source string, size int, padStr string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/xpTfzArDfvT)</span></b>
 
 ```go
 import (
@@ -613,7 +617,7 @@ func main() {
 func Reverse(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/adfwalJiecD)</span></b>
 
 ```go
 import (
@@ -644,7 +648,7 @@ func main() {
 func SnakeCase(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tgzQG11qBuN)</span></b>
 
 ```go
 import (
@@ -676,10 +680,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func SnakeCase(s string) string
+func UpperSnakeCase(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4COPHpnLx38)</span></b>
 
 ```go
 import (
@@ -714,7 +718,7 @@ func main() {
 func SplitEx(s, sep string, removeEmptyString bool) []string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Us-ySSbWh-3)</span></b>
 
 ```go
 import (
@@ -755,7 +759,7 @@ func main() {
 func Substring(s string, offset int, length uint) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/q3sM6ehnPDp)</span></b>
 
 ```go
 import (
@@ -798,7 +802,7 @@ func main() {
 func Wrap(str string, wrapWith string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KoZOlZDDt9y)</span></b>
 
 ```go
 import (
@@ -825,7 +829,7 @@ func main() {
 }
 ```
 
-### <span id="Wrap">Wrap</span>
+### <span id="Unwrap">Unwrap</span>
 
 <p>用另一个字符串解开包裹一个字符串。</p>
 
@@ -835,7 +839,7 @@ func main() {
 func Unwrap(str string, wrapToken string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Ec2q4BzCpG-)</span></b>
 
 ```go
 import (
@@ -875,7 +879,7 @@ func main() {
 func SplitWords(s string) []string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KLiX4WiysMM)</span></b>
 
 ```go
 import (
@@ -918,7 +922,7 @@ func main() {
 func WordCount(s string) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/bj7_odx3vRf)</span></b>
 
 ```go
 import (
@@ -961,7 +965,7 @@ func main() {
 func RemoveNonPrintable(str string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/og47F5x_jTZ)</span></b>
 
 ```go
 import (
@@ -992,7 +996,7 @@ func main() {
 func StringToBytes(str string) (b []byte)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/7OyFBrf9AxA)</span></b>
 
 ```go
 import (
@@ -1022,7 +1026,7 @@ func main() {
 func BytesToString(bytes []byte) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/6c68HRvJecH)</span></b>
 
 ```go
 import (
@@ -1051,7 +1055,7 @@ func main() {
 func IsBlank(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/6zXRH_c0Qd3)</span></b>
 
 ```go
 import (
@@ -1075,6 +1079,45 @@ func main() {
 }
 ```
 
+### <span id="IsNotBlank">IsNotBlank</span>
+
+<p>Checks if a string is not whitespace or not empty.</p>
+
+<b>函数签名:</b>
+
+```go
+func IsNotBlank(str string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/e_oJW0RAquA)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.IsNotBlank("")
+    result2 := strutil.IsNotBlank("    ")
+    result3 := strutil.IsNotBlank("\t\v\f\n")
+    result4 := strutil.IsNotBlank(" 中文")
+    result5 := strutil.IsNotBlank("     world    ")
+    
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    // Output:
+    // false
+    // false
+    // false
+    // true
+    // true
+}
+```
+
 ### <span id="HasPrefixAny">HasPrefixAny</span>
 
 <p>检查字符串是否以指定字符串数组中的任何一个开头。</p>
@@ -1085,7 +1128,7 @@ func main() {
 func HasPrefixAny(str string, prefixes []string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8UUTl2C5slo)</span></b>
 
 ```go
 import (
@@ -1116,7 +1159,7 @@ func main() {
 func HasSuffixAny(str string, suffixes []string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sKWpCQdOVkx)</span></b>
 
 ```go
 import (
@@ -1147,7 +1190,7 @@ func main() {
 func IndexOffset(str string, substr string, idxFrom int) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qZo4lV2fomB)</span></b>
 
 ```go
 import (
@@ -1189,7 +1232,7 @@ func main() {
 func ReplaceWithMap(str string, replaces map[string]string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/h3t7CNj2Vvu)</span></b>
 
 ```go
 import (
@@ -1222,7 +1265,7 @@ func main() {
 func Trim(str string, characterMask ...string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Y0ilP0NRV3j)</span></b>
 
 ```go
 import (
@@ -1259,7 +1302,7 @@ func main() {
 func SplitAndTrim(str, delimiter string, characterMask ...string) []string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ZNL6o4SkYQ7)</span></b>
 
 ```go
 import (
@@ -1292,7 +1335,7 @@ func main() {
 func HideString(origin string, start, end int, replaceChar string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pzbaIVCTreZ)</span></b>
 
 ```go
 import (
@@ -1331,7 +1374,7 @@ func main() {
 func ContainsAll(str string, substrs []string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KECtK2Os4zq)</span></b>
 
 ```go
 import (
@@ -1364,7 +1407,7 @@ func main() {
 func ContainsAny(str string, substrs []string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dZGSSMB3LXE)</span></b>
 
 ```go
 import (
@@ -1400,7 +1443,7 @@ func main() {
 func RemoveWhiteSpace(str string, repalceAll bool) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HzLC9vsTwkf)</span></b>
 
 ```go
 import (
@@ -1422,3 +1465,102 @@ func main() {
     // hello world
 }
 ```
+
+### <span id="SubInBetween">SubInBetween</span>
+
+<p>获取字符串中指定的起始字符串start和终止字符串end直接的子字符串。</p>
+
+<b>函数签名:</b>
+
+```go
+func SubInBetween(str string, start string, end string) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/EDbaRvjeNsv)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    str := "abcde"
+
+    result1 := strutil.SubInBetween(str, "", "de")
+    result2 := strutil.SubInBetween(str, "a", "d")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // abc
+    // bc
+}
+```
+
+### <span id="HammingDistance">HammingDistance</span>
+
+<p>计算两个字符串之间的汉明距离。汉明距离是指对应符号不同的位置数。</p>
+
+<b>函数签名:</b>
+
+```go
+func HammingDistance(a, b string) (int, error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/glNdQEA9HUi)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+
+    result1, _ := strutil.HammingDistance("de", "de")
+    result2, _ := strutil.HammingDistance("a", "d")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 0
+    // 1
+}
+
+```
+### <span id="Concat">Concat</span>
+
+<p>拼接字符串。length是拼接后字符串的长度，如果不确定则传0或负数。</p>
+
+<b>函数签名:</b>
+
+```go
+func Concat(length int, str ...string) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行]()</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+
+ 	result1 := strutil.Concat(12, "Hello", " ", "World", "!")
+	result2 := strutil.Concat(11, "Go", " ", "Language")
+	result3 := strutil.Concat(0, "An apple a ", "day，", "keeps the", " doctor away")
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// Hello World!
+	// Go Language
+	// An apple a day，keeps the doctor away
+}
+```

docs/api/packages/system.md

@@ -46,7 +46,7 @@ import (
 func IsWindows() bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/zIflQgZNuxD)</span></b>
 
 ```go
 import (
@@ -64,7 +64,7 @@ func main() {
 
 <p>检查当前操作系统是否是linux</p>
 
-<b>函数签名:</b>
+<b>函数签名:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/zIflQgZNuxD)</span></b>
 
 ```go
 func IsLinux() bool
@@ -94,7 +94,7 @@ func main() {
 func IsMac() bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/Mg4Hjtyq7Zc)</span></b>
 
 ```go
 import (
@@ -118,7 +118,7 @@ func main() {
 func GetOsEnv(key string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/D88OYVCyjO-)</span></b>
 
 ```go
 import (
@@ -148,7 +148,7 @@ func main() {
 func SetOsEnv(key, value string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/D88OYVCyjO-)</span></b>
 
 ```go
 import (
@@ -178,7 +178,7 @@ func main() {
 func RemoveOsEnv(key string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/fqyq4b3xUFQ)</span></b>
 
 ```go
 import (
@@ -216,7 +216,7 @@ func main() {
 func CompareOsEnv(key, comparedEnv string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/BciHrKYOHbp)</span></b>
 
 ```go
 import (
@@ -252,7 +252,7 @@ type (
 func ExecCommand(command string, opts ...Option) (stdout, stderr string, err error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/n-2fLyZef-4)</span></b>
 
 ```go
 import (
@@ -292,7 +292,7 @@ func main() {
 func GetOsBits() int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/ml-_XH3gJbW)</span></b>
 
 ```go
 import (

docs/api/packages/tuple.md

@@ -61,6 +61,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
+
 ## 文档
 
 ### <span id="Tuple2">Tuple2</span>
@@ -78,7 +79,7 @@ type Tuple2[A any, B any] struct {
 func NewTuple2[A any, B any](a A, b B) Tuple2[A, B]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/3sHVqBQpLYN)</span></b>
 
 ```go
 package main
@@ -106,7 +107,7 @@ func main() {
 func (t Tuple2[A, B]) Unbox() (A, B)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/0fD1qfCVwjm)</span></b>
 
 ```go
 package main
@@ -135,7 +136,7 @@ func main() {
 func Zip2[A any, B any](a []A, b []B) []Tuple2[A, B]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/4ncWJJ77Xio)</span></b>
 
 ```go
 package main
@@ -163,7 +164,7 @@ func main() {
 func Unzip2[A any, B any](tuples []Tuple2[A, B]) ([]A, []B)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/KBecr60feXb)</span></b>
 
 ```go
 package main
@@ -198,7 +199,7 @@ type Tuple3[A any, B any, C any] struct {
 func NewTuple3[A any, B any, C any](a A, b B c C) Tuple3[A, B, C]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/FtH2sdCLlCf)</span></b>
 
 ```go
 package main
@@ -226,7 +227,7 @@ func main() {
 func (t Tuple3[A, B, C]) Unbox() (A, B, C)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/YojLy-id1BS)</span></b>
 
 ```go
 package main
@@ -255,7 +256,7 @@ func main() {
 func Zip3[A any, B any, C any](a []A, b []B, c []C) []Tuple3[A, B, C]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/97NgmsTILfu)</span></b>
 
 ```go
 package main
@@ -283,7 +284,7 @@ func main() {
 func Unzip3[A any, B any, C any](tuples []Tuple3[A, B, C]) ([]A, []B, []C)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/bba4cpAa7KO)</span></b>
 
 ```go
 package main
@@ -321,7 +322,7 @@ type Tuple4[A any, B any, C any, D any] struct {
 func NewTuple4[A any, B any, C any, D any](a A, b B, c C, d D) Tuple4[A, B, C, D]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/D2EqDz096tk)</span></b>
 
 ```go
 package main
@@ -349,7 +350,7 @@ func main() {
 func (t Tuple4[A, B, C, D]) Unbox() (A, B, C, D)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/ACj9YuACGgW)</span></b>
 
 ```go
 package main
@@ -378,7 +379,7 @@ func main() {
 func Zip4[A any, B any, C any, D any](a []A, b []B, c []C, d []D) []Tuple4[A, B, C, D]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/PEmTYVK5hL4)</span></b>
 
 ```go
 package main
@@ -406,7 +407,7 @@ func main() {
 func Unzip4[A any, B any, C any, D any](tuples []Tuple4[A, B, C, D]) ([]A, []B, []C, []D)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/rb8z4gyYSRN)</span></b>
 
 ```go
 package main
@@ -445,7 +446,7 @@ type Tuple5[A any, B any, C any, D any, E any] struct {
 func NewTuple5[A any, B any, C any, D any, E any](a A, b B, c C, d D, e E) Tuple5[A, B, C, D, E]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/2WndmVxPg-r)</span></b>
 
 ```go
 package main
@@ -473,7 +474,7 @@ func main() {
 func (t Tuple5[A, B, C, D, E]) Unbox() (A, B, C, D, E)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/GyIyZHjCvoS)</span></b>
 
 ```go
 package main
@@ -502,7 +503,7 @@ func main() {
 func Zip5[A any, B any, C any, D any, E any](a []A, b []B, c []C, d []D, e []E) []Tuple5[A, B, C, D, E]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/fCAAJLMfBIP)</span></b>
 
 ```go
 package main
@@ -530,7 +531,7 @@ func main() {
 func Unzip5[A any, B any, C any, D any, E any](tuples []Tuple5[A, B, C, D, E]) ([]A, []B, []C, []D, []E)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/gyl6vKfhqPb)</span></b>
 
 ```go
 package main
@@ -570,7 +571,7 @@ type Tuple6[A any, B any, C any, D any, E any, F any] struct {
 func NewTuple6[A any, B any, C any, D any, E any, F any](a A, b B, c C, d D, e E, f F) Tuple6[A, B, C, D, E, F]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/VjqcCwEJZbs)</span></b>
 
 ```go
 package main
@@ -598,7 +599,7 @@ func main() {
 func (t Tuple6[A, B, C, D, E, F]) Unbox() (A, B, C, D, E, F)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/FjIHV7lpxmW)</span></b>
 
 ```go
 package main
@@ -627,7 +628,7 @@ func main() {
 func Zip6[A any, B any, C any, D any, E any, F any](a []A, b []B, c []C, d []D, e []E, f []F) []Tuple6[A, B, C, D, E, F]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/oWPrnUYuFHo)</span></b>
 
 ```go
 package main
@@ -655,7 +656,7 @@ func main() {
 func Unzip6[A any, B any, C any, D any, E any, F any](tuples []Tuple6[A, B, C, D, E, F]) ([]A, []B, []C, []D, []E, []F)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/l41XFqCyh5E)</span></b>
 
 ```go
 package main
@@ -696,7 +697,7 @@ type Tuple7[A any, B any, C any, D any, E any, F any, G any] struct {
 func NewTuple7[A any, B any, C any, D any, E any, F any, G any](a A, b B, c C, d D, e E, f F, g G) Tuple7[A, B, C, D, E, F, G]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/dzAgv_Ezub9)</span></b>
 
 ```go
 package main
@@ -724,7 +725,7 @@ func main() {
 func (t Tuple7[A, B, C, D, E, F, G]) Unbox() (A, B, C, D, E, F, G)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/R9I8qeDk0zs)</span></b>
 
 ```go
 package main
@@ -753,7 +754,7 @@ func main() {
 func Zip7[A any, B any, C any, D any, E any, F any, G any](a []A, b []B, c []C, d []D, e []E, f []F, g []G) []Tuple7[A, B, C, D, E, F, G]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/WUJuo897Egf)</span></b>
 
 ```go
 package main
@@ -781,7 +782,7 @@ func main() {
 func Unzip7[A any, B any, C any, D any, E any, F any, G any](tuples []Tuple7[A, B, C, D, E, F, G]) ([]A, []B, []C, []D, []E, []F, []G)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/hws_P1Fr2j3)</span></b>
 
 ```go
 package main
@@ -823,7 +824,7 @@ type Tuple8[A any, B any, C any, D any, E any, F any, G any, H any] struct {
 func NewTuple8[A any, B any, C any, D any, E any, F any, G any, H any](a A, b B, c C, d D, e E, f F, g G, h H) Tuple8[A, B, C, D, E, F, G, H]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/YA9S0rz3dRz)</span></b>
 
 ```go
 package main
@@ -851,7 +852,7 @@ func main() {
 func (t Tuple8[A, B, C, D, E, F, G, H]) Unbox() (A, B, C, D, E, F, G, H)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/PRxLBBb4SMl)</span></b>
 
 ```go
 package main
@@ -880,7 +881,7 @@ func main() {
 func Zip8[A any, B any, C any, D any, E any, F any, G any, H any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H) []Tuple8[A, B, C, D, E, F, G, H]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/8V9jWkuJfaQ)</span></b>
 
 ```go
 package main
@@ -908,7 +909,7 @@ func main() {
 func Unzip8[A any, B any, C any, D any, E any, F any, G any, H any](tuples []Tuple8[A, B, C, D, E, F, G, H]) ([]A, []B, []C, []D, []E, []F, []G, []H)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/1SndOwGsZB4)</span></b>
 
 ```go
 package main
@@ -953,7 +954,7 @@ func NewTuple9[A any, B any, C any, D any, E any, F any, G any, H any, I any](a
 
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/yS2NGGtZpQr)</span></b>
 
 ```go
 package main
@@ -981,7 +982,7 @@ func main() {
 func (t Tuple9[A, B, C, D, E, F, G, H, I]) Unbox() (A, B, C, D, E, F, G, H, I)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/oFJFGTAuOa8)</span></b>
 
 ```go
 package main
@@ -1010,7 +1011,7 @@ func main() {
 func Zip9[A any, B any, C any, D any, E any, F any, G any, H any, I any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I) []Tuple9[A, B, C, D, E, F, G, H, I]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/cgsL15QYnfz)</span></b>
 
 ```go
 package main
@@ -1038,7 +1039,7 @@ func main() {
 func Unzip9[A any, B any, C any, D any, E any, F any, G any, H any, I any](tuples []Tuple9[A, B, C, D, E, F, G, H, I]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/91-BU_KURSA)</span></b>
 
 ```go
 package main
@@ -1084,7 +1085,7 @@ func NewTuple10[A any, B any, C any, D any, E any, F any, G any, H any, I any, J
 
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/799qqZg0hUv)</span></b>
 
 ```go
 package main
@@ -1115,7 +1116,7 @@ func main() {
 func (t Tuple10[A, B, C, D, E, F, G, H, I, J]) Unbox() (A, B, C, D, E, F, G, H, I, J)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/qfyx3x_X0Cu)</span></b>
 
 ```go
 package main
@@ -1147,7 +1148,7 @@ func main() {
 func Zip10[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I, j []J) []Tuple10[A, B, C, D, E, F, G, H, I, J]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/YSR-2cXnrY4)</span></b>
 
 ```go
 package main
@@ -1175,7 +1176,7 @@ func main() {
 func Unzip10[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any](tuples []Tuple10[A, B, C, D, E, F, G, H, I, J]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I, []J)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/-taQB6Wfre_z)</span></b>
 
 ```go
 package main

docs/api/packages/validator.md

@@ -55,6 +55,15 @@ import (
 -   [IsZeroValue](#IsZeroValue)
 -   [IsGBK](#IsGBK)
 -   [IsPrintable](#IsPrintable)
+-   [IsBin](#IsBin)
+-   [IsHex](#IsHex)
+-   [IsBase64URL](#IsBase64URL)
+-   [IsJWT](#IsJWT)
+-   [IsVisa](#IsVisa)
+-   [IsMasterCard](#IsMasterCard)
+-   [IsAmericanExpress](#IsAmericanExpress)
+-   [IsUnionPay](#IsUnionPay)
+-   [IsChinaUnionPay](#IsChinaUnionPay)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -62,7 +71,7 @@ import (
 
 ### <span id="ContainChinese">ContainChinese</span>
 
-<p>验证字符串是否包含中文字符</p>
+<p>验证字符串是否包含中文字符。</p>
 
 <b>函数签名:</b>
 
@@ -70,7 +79,7 @@ import (
 func ContainChinese(s string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/7DpU0uElYeM)</span></b>
 
 ```go
 import (
@@ -96,7 +105,7 @@ func main() {
 
 ### <span id="ContainLetter">ContainLetter</span>
 
-<p>验证字符串是否包含至少一个英文字母</p>
+<p>验证字符串是否包含至少一个英文字母。</p>
 
 <b>函数签名:</b>
 
@@ -104,7 +113,7 @@ func main() {
 func ContainLetter(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/lqFD04Yyewp)</span></b>
 
 ```go
 import (
@@ -130,7 +139,7 @@ func main() {
 
 ### <span id="ContainLower">ContainLower</span>
 
-<p>验证字符串是否包含至少一个英文小写字母</p>
+<p>验证字符串是否包含至少一个英文小写字母。</p>
 
 <b>函数签名:</b>
 
@@ -138,7 +147,7 @@ func main() {
 func ContainLower(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/Srqi1ItvnAA)</span></b>
 
 ```go
 import (
@@ -164,7 +173,7 @@ func main() {
 
 ### <span id="ContainUpper">ContainUpper</span>
 
-<p>验证字符串是否包含至少一个英文大写字母.</p>
+<p>验证字符串是否包含至少一个英文大写字母。</p>
 
 <b>函数签名:</b>
 
@@ -172,7 +181,7 @@ func main() {
 func ContainUpper(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/CmWeBEk27-z)</span></b>
 
 ```go
 import (
@@ -198,7 +207,7 @@ func main() {
 
 ### <span id="IsAlpha">IsAlpha</span>
 
-<p>验证字符串是否只包含英文字母</p>
+<p>验证字符串是否只包含英文字母。</p>
 
 <b>函数签名:</b>
 
@@ -206,7 +215,7 @@ func main() {
 func IsAlpha(s string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/7Q5sGOz2izQ)</span></b>
 
 ```go
 import (
@@ -232,7 +241,7 @@ func main() {
 
 ### <span id="IsAllUpper">IsAllUpper</span>
 
-<p>验证字符串是否全是大写英文字母</p>
+<p>验证字符串是否全是大写英文字母。</p>
 
 <b>函数签名:</b>
 
@@ -240,7 +249,7 @@ func main() {
 func IsAllUpper(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/ZHctgeK1n4Z)</span></b>
 
 ```go
 import (
@@ -266,7 +275,7 @@ func main() {
 
 ### <span id="IsAllLower">IsAllLower</span>
 
-<p>验证字符串是否全是小写英文字母</p>
+<p>验证字符串是否全是小写英文字母。</p>
 
 <b>函数签名:</b>
 
@@ -274,7 +283,7 @@ func main() {
 func IsAllLower(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/GjqCnOfV6cM)</span></b>
 
 ```go
 import (
@@ -308,7 +317,7 @@ func main() {
 func IsASCII(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/hfQNPLX0jNa)</span></b>
 
 ```go
 import (
@@ -340,7 +349,7 @@ func main() {
 
 ### <span id="IsBase64">IsBase64</span>
 
-<p>验证字符串是否是base64编码</p>
+<p>验证字符串是否是base64编码。</p>
 
 <b>函数签名:</b>
 
@@ -348,7 +357,7 @@ func main() {
 func IsBase64(base64 string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/sWHEySAt6hl)</span></b>
 
 ```go
 import (
@@ -371,7 +380,7 @@ func main() {
 
 ### <span id="IsChineseMobile">IsChineseMobile</span>
 
-<p>验证字符串是否是中国手机号码</p>
+<p>验证字符串是否是中国手机号码。</p>
 
 <b>函数签名:</b>
 
@@ -379,7 +388,7 @@ func main() {
 func IsChineseMobile(mobileNum string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/GPYUlGTOqe3)</span></b>
 
 ```go
 import (
@@ -402,7 +411,7 @@ func main() {
 
 ### <span id="IsChineseIdNum">IsChineseIdNum</span>
 
-<p>验证字符串是否是中国身份证号码</p>
+<p>验证字符串是否是中国身份证号码。</p>
 
 <b>函数签名:</b>
 
@@ -410,7 +419,7 @@ func main() {
 func IsChineseIdNum(id string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/d8EWhl2UGDF)</span></b>
 
 ```go
 import (
@@ -433,7 +442,7 @@ func main() {
 
 ### <span id="IsChinesePhone">IsChinesePhone</span>
 
-<p>验证字符串是否是中国电话座机号码</p>
+<p>验证字符串是否是中国电话座机号码。</p>
 
 <b>函数签名:</b>
 
@@ -441,7 +450,7 @@ func main() {
 func IsChinesePhone(phone string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/RUD_-7YZJ3I)</span></b>
 
 ```go
 import (
@@ -464,7 +473,7 @@ func main() {
 
 ### <span id="IsCreditCard">IsCreditCard</span>
 
-<p>验证字符串是否是信用卡号码</p>
+<p>验证字符串是否是信用卡号码。</p>
 
 <b>函数签名:</b>
 
@@ -472,7 +481,7 @@ func main() {
 func IsCreditCard(creditCart string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/sNwwL6B0-v4)</span></b>
 
 ```go
 import (
@@ -495,7 +504,7 @@ func main() {
 
 ### <span id="IsDns">IsDns</span>
 
-<p>验证字符串是否是有效dns</p>
+<p>验证字符串是否是有效dns。</p>
 
 <b>函数签名:</b>
 
@@ -503,7 +512,7 @@ func main() {
 func IsDns(dns string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/jlYApVLLGTZ)</span></b>
 
 ```go
 import (
@@ -529,7 +538,7 @@ func main() {
 
 ### <span id="IsEmail">IsEmail</span>
 
-<p>验证字符串是否是有效电子邮件地址</p>
+<p>验证字符串是否是有效电子邮件地址。</p>
 
 <b>函数签名:</b>
 
@@ -537,7 +546,7 @@ func main() {
 func IsEmail(email string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/Os9VaFlT33G)</span></b>
 
 ```go
 import (
@@ -560,7 +569,7 @@ func main() {
 
 ### <span id="IsEmptyString">IsEmptyString</span>
 
-<p>验证字符串是否是空字符串</p>
+<p>验证字符串是否是空字符串。</p>
 
 <b>函数签名:</b>
 
@@ -568,7 +577,7 @@ func main() {
 func IsEmptyString(s string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/dpzgUjFnBCX)</span></b>
 
 ```go
 import (
@@ -602,7 +611,7 @@ func main() {
 func IsInt(v any) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/eFoIHbgzl-z)</span></b>
 
 ```go
 import (
@@ -631,7 +640,7 @@ func main() {
 
 ### <span id="IsFloat">IsFloat</span>
 
-<p>验证参数是否是浮点数((float32, float34)。</p>
+<p>验证参数是否是浮点数(float32, float34)。</p>
 
 <b>函数签名:</b>
 
@@ -639,7 +648,7 @@ func main() {
 func IsFloat(v any) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/vsyG-sxr99_Z)</span></b>
 
 ```go
 import (
@@ -668,7 +677,7 @@ func main() {
 
 ### <span id="IsNumber">IsNumber</span>
 
-<p>验证参数是否是数字(integer or float)</p>
+<p>验证参数是否是数字(integer or float)。</p>
 
 <b>函数签名:</b>
 
@@ -676,7 +685,7 @@ func main() {
 func IsNumber(v any) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/mdJHOAvtsvF)</span></b>
 
 ```go
 import (
@@ -703,10 +712,9 @@ func main() {
 }
 ```
 
-
 ### <span id="IsIntStr">IsIntStr</span>
 
-<p>验证字符串是否是可以转换为整数</p>
+<p>验证字符串是否是可以转换为整数。</p>
 
 <b>函数签名:</b>
 
@@ -714,7 +722,7 @@ func main() {
 func IsIntStr(s string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/jQRtFv-a0Rk)</span></b>
 
 ```go
 import (
@@ -743,7 +751,7 @@ func main() {
 
 ### <span id="IsFloatStr">IsFloatStr</span>
 
-<p>验证字符串是否是可以转换为浮点数</p>
+<p>验证字符串是否是可以转换为浮点数。</p>
 
 <b>函数签名:</b>
 
@@ -751,7 +759,7 @@ func main() {
 func IsFloatStr(s string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/LOYwS_Oyl7U)</span></b>
 
 ```go
 import (
@@ -780,7 +788,7 @@ func main() {
 
 ### <span id="IsNumberStr">IsNumberStr</span>
 
-<p>验证字符串是否是可以转换为数字</p>
+<p>验证字符串是否是可以转换为数字。</p>
 
 <b>函数签名:</b>
 
@@ -788,7 +796,7 @@ func main() {
 func IsNumberStr(s string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/LzaKocSV79u)</span></b>
 
 ```go
 import (
@@ -817,7 +825,7 @@ func main() {
 
 ### <span id="IsJSON">IsJSON</span>
 
-<p>验证字符串是否是有效json</p>
+<p>验证字符串是否是有效json。</p>
 
 <b>函数签名:</b>
 
@@ -825,7 +833,7 @@ func main() {
 func IsJSON(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/8Kip1Itjiil)</span></b>
 
 ```go
 import (
@@ -854,7 +862,7 @@ func main() {
 
 ### <span id="IsRegexMatch">IsRegexMatch</span>
 
-<p>验证字符串是否可以匹配正则表达式</p>
+<p>验证字符串是否可以匹配正则表达式。</p>
 
 <b>函数签名:</b>
 
@@ -862,7 +870,7 @@ func main() {
 func IsRegexMatch(s, regex string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/z_XeZo_litG)</span></b>
 
 ```go
 import (
@@ -883,11 +891,9 @@ func main() {
 }
 ```
 
-
-
 ### <span id="IsIp">IsIp</span>
 
-<p>验证字符串是否是ip地址</p>
+<p>验证字符串是否是ip地址。</p>
 
 <b>函数签名:</b>
 
@@ -895,7 +901,7 @@ func main() {
 func IsIp(ipstr string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/FgcplDvmxoD)</span></b>
 
 ```go
 import (
@@ -924,7 +930,7 @@ func main() {
 
 ### <span id="IsIpV4">IsIpV4</span>
 
-<p>验证字符串是否是ipv4地址</p>
+<p>验证字符串是否是ipv4地址。</p>
 
 <b>函数签名:</b>
 
@@ -932,7 +938,7 @@ func main() {
 func IsIpV4(ipstr string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/zBGT99EjaIu)</span></b>
 
 ```go
 import (
@@ -955,7 +961,7 @@ func main() {
 
 ### <span id="IsIpV6">IsIpV6</span>
 
-<p>验证字符串是否是ipv6地址</p>
+<p>验证字符串是否是ipv6地址。</p>
 
 <b>函数签名:</b>
 
@@ -963,7 +969,7 @@ func main() {
 func IsIpV6(ipstr string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/AHA0r0AzIdC)</span></b>
 
 ```go
 import (
@@ -986,7 +992,7 @@ func main() {
 
 ### <span id="IsStrongPassword">IsStrongPassword</span>
 
-<p>验证字符串是否是强密码：(alpha(lower+upper) + number + special chars(!@#$%^&*()?><))</p>
+<p>验证字符串是否是强密码：(alpha(lower+upper) + number + special chars(!@#$%^&*()?&gt&lt))。</p>
 
 <b>函数签名:</b>
 
@@ -994,7 +1000,7 @@ func main() {
 func IsStrongPassword(password string, length int) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/QHdVcSQ3uDg)</span></b>
 
 ```go
 import (
@@ -1017,7 +1023,7 @@ func main() {
 
 ### <span id="IsUrl">IsUrl</span>
 
-<p>验证字符串是否是url</p>
+<p>验证字符串是否是url。</p>
 
 <b>函数签名:</b>
 
@@ -1025,7 +1031,7 @@ func main() {
 func IsUrl(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/pbJGa7F98Ka)</span></b>
 
 ```go
 import (
@@ -1052,7 +1058,7 @@ func main() {
 ### <span id="IsWeakPassword">IsWeakPassword</span>
 
 <p>验证字符串是否是弱密码：（only letter or only number or letter + number）
-.</p>
+。</p>
 
 <b>函数签名:</b>
 
@@ -1060,7 +1066,7 @@ func main() {
 func IsWeakPassword(password string, length int) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/wqakscZH5gH)</span></b>
 
 ```go
 import (
@@ -1083,7 +1089,7 @@ func main() {
 
 ### <span id="IsZeroValue">IsZeroValue</span>
 
-<p>判断传入的参数值是否为零值</p>
+<p>判断传入的参数值是否为零值。</p>
 
 <b>函数签名:</b>
 
@@ -1091,7 +1097,7 @@ func main() {
 func IsZeroValue(value any) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/UMrwaDCi_t4)</span></b>
 
 ```go
 import (
@@ -1128,7 +1134,7 @@ func main() {
 func IsGBK(data []byte) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/E2nt3unlmzP)</span></b>
 
 ```go
 import (
@@ -1150,7 +1156,6 @@ func main() {
 }
 ```
 
-
 ### <span id="IsPrintable">IsPrintable</span>
 
 <p>检查字符串是否全部为可打印字符。</p>
@@ -1161,7 +1166,7 @@ func main() {
 func IsPrintable(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/Pe1FE2gdtTP)</span></b>
 
 ```go
 import (
@@ -1189,4 +1194,301 @@ func main() {
     // true
     // false
 }
-```
+```
+
+### <span id="IsBin">IsBin</span>
+
+<p>检查字符串是否是有效的二进制数。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsBin(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/ogPeg2XJH4P)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsBin("0101")
+    result2 := validator.IsBin("0b1101")
+    result3 := validator.IsBin("b1101")
+    result4 := validator.IsBin("1201")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // true
+    // false
+    // false
+}
+```
+
+### <span id="IsHex">IsHex</span>
+
+<p>检查字符串是否是有效的十六进制数。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsHex(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/M2qpHbEwmm7)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsHex("0xabcde")
+    result2 := validator.IsHex("0XABCDE")
+    result3 := validator.IsHex("cdfeg")
+    result4 := validator.IsHex("0xcdfeg")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // true
+    // false
+    // false
+}
+```
+
+### <span id="IsBase64URL">IsBase64URL</span>
+
+<p>检查字符串是否是有效的base64 url。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsBase64URL(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/vhl4mr8GZ6S)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsBase64URL("SAGsbG8sIHdvcmxkIQ")
+    result2 := validator.IsBase64URL("SAGsbG8sIHdvcmxkIQ==")
+    result3 := validator.IsBase64URL("SAGsbG8sIHdvcmxkIQ=")
+    result4 := validator.IsBase64URL("SAGsbG8sIHdvcmxkIQ===")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // true
+    // false
+    // false
+}
+```
+
+### <span id="IsJWT">IsJWT</span>
+
+<p>检查字符串是否是有效的JSON Web Token (JWT)。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsJWT(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/R6Op7heJbKI)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsJWT("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibWVzc2FnZSI6IlB1dGluIGlzIGFic29sdXRlIHNoaXQiLCJpYXQiOjE1MTYyMzkwMjJ9.wkLWA5GtCpWdxNOrRse8yHZgORDgf8TpJp73WUQb910")
+    result2 := validator.IsJWT("abc")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsVisa">IsVisa</span>
+
+<p>检查字符串是否是有效的visa卡号。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsVisa(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/SdS2keOyJsl)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsVisa("4111111111111111")
+    result2 := validator.IsVisa("123")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsMasterCard">IsMasterCard</span>
+
+<p>检查字符串是否是有效的MasterCard卡号。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsMasterCard(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/CwWBFRrG27b)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsMasterCard("5425233430109903")
+    result2 := validator.IsMasterCard("4111111111111111")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsAmericanExpress">IsAmericanExpress</span>
+
+<p>检查字符串是否是有效的American Express卡号。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsAmericanExpress(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/HIDFpcOdpkd)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsAmericanExpress("342883359122187")
+    result2 := validator.IsAmericanExpress("3782822463100007")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsUnionPay">IsUnionPay</span>
+
+<p>检查字符串是否是有效的美国银联卡号。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsUnionPay(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/CUHPEwEITDf)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsUnionPay("6221263430109903")
+    result2 := validator.IsUnionPay("3782822463100007")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsChinaUnionPay">IsChinaUnionPay</span>
+
+<p>检查字符串是否是有效的中国银联卡号。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsChinaUnionPay(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/yafpdxLiymu)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsChinaUnionPay("6250941006528599")
+    result2 := validator.IsChinaUnionPay("3782822463100007")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```

docs/api/packages/xerror.md

@@ -38,6 +38,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
+
 ## 文档
 
 ### <span id="New">New</span>
@@ -58,7 +59,7 @@ type XError struct {
 func New(format string, args ...any) *XError
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/w4oWZts7q7f)</span></b>
 
 ```go
 package main
@@ -87,7 +88,7 @@ func main() {
 func Wrap(cause error, message ...any) *XError
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/5385qT2dCi4)</span></b>
 
 ```go
 package main
@@ -118,7 +119,7 @@ func main() {
 func Unwrap(err error) *XError
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/LKMLep723tu)</span></b>
 
 ```go
 package main
@@ -153,24 +154,25 @@ func main() {
 func (e *XError) Wrap(cause error) *XError
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/RpjJ5u5sc97)</span></b>
 
 ```go
 package main
 
 import (
     "fmt"
+    "errors"
     "github.com/duke-git/lancet/v2/xerror"
 )
 
 func main() {
-    err := xerror.New("wrong password")
-    wrapErr := xerror.Wrap(err, "error")
+    err1 := xerror.New("error").With("level", "high")
+	err2 := err1.Wrap(errors.New("invalid username"))
 
-    fmt.Println(wrapErr.Error())
+	fmt.Println(err2.Error())
 
-    // Output:
-    // error: wrong password
+	// Output:
+	// error: invalid username
 }
 ```
 
@@ -184,7 +186,7 @@ func main() {
 func (e *XError) Unwrap() error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/VUXJ8BST4c6)</span></b>
 
 ```go
 package main
@@ -217,7 +219,7 @@ func main() {
 func (e *XError) With(key string, value any) *XError
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/ow8UISXX_Dp)</span></b>
 
 ```go
 package main
@@ -249,7 +251,7 @@ func main() {
 func (e *XError) Id(id string) *XError
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/X6HBlsy58U9)</span></b>
 
 ```go
 package main
@@ -286,7 +288,7 @@ func main() {
 func (e *XError) Is(target error) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/X6HBlsy58U9)</span></b>
 
 ```go
 package main
@@ -323,7 +325,7 @@ func main() {
 func (e *XError) Values() map[string]any
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/ow8UISXX_Dp)</span></b>
 
 ```go
 package main
@@ -356,7 +358,7 @@ func main() {
 func (e *XError) StackTrace() StackTrace
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/6FAvSQpa7pc)</span></b>
 
 ```go
 package main
@@ -390,7 +392,7 @@ func main() {
 func (e *XError) Info() *errInfo
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/1ZX0ME1F-Jb)</span></b>
 
 ```go
 package main
@@ -430,7 +432,7 @@ func main() {
 func (e *XError) Error() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/w4oWZts7q7f)</span></b>
 
 ```go
 package main
@@ -459,7 +461,7 @@ func main() {
 func TryUnwrap[T any](val T, err error) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/acyZVkNZEeW)</span></b>
 
 ```go
 package main

docs/en/api/overview.md

@@ -0,0 +1,70 @@
+---
+outline: deep
+---
+
+# API Overview
+
+<b>Lancet (Lancet) is a powerful, comprehensive, efficient and reusable go language tool function library. Contains 25 packages, more than 600 utility functions. Functions cover string processing, slice processing, network, concurrency, encryption and decryption, file processing, time/date, stream processing, iterators, and more.</b>
+
+
+<style>
+.package-title {
+    color: black;
+    font-size: 18px;
+    text-align: center;
+    font-weight: bold;
+}
+.package-container {
+    font-size: 16px;
+    border: 1px dashed;
+    padding: 10px;
+    text-align: center;
+}
+
+.package-cell {
+    height: 40px;
+    width: 140px;
+    display: inline-block;
+    vertical-align: middle;
+    line-height: 40px;
+    background: #059669;
+    border: 1px solid;
+    margin-right: 10px;
+    margin-bottom: 10px;
+    border-radius: 6px;
+    font-weight: bold;
+}
+</style>
+
+<div>
+    <p class="package-title">Lancet function module</p>
+    <div class="package-container">
+        <div class="package-cell">algorithm</div>
+        <div class="package-cell">compare</div>
+        <div class="package-cell">concurrency</div>
+        <div class="package-cell">condition</div>
+        <div class="package-cell">convertor</div>
+        <div class="package-cell">cryptor</div>
+        <div class="package-cell">datastructure</div>
+        <div class="package-cell">datetime</div>
+        <div class="package-cell">fileutil</div>
+        <div class="package-cell">formatter</div>
+        <div class="package-cell">function</div>
+        <div class="package-cell">iterator</div>
+        <div class="package-cell">maputil</div>
+        <div class="package-cell">mathutil</div>
+        <div class="package-cell">netutil</div>
+        <div class="package-cell">pointer</div>
+        <div class="package-cell">random</div>
+        <div class="package-cell">retry</div>
+        <div class="package-cell">slice</div>
+        <div class="package-cell">stream</div>
+        <div class="package-cell">structs</div>
+        <div class="package-cell">strutil</div>
+        <div class="package-cell">system</div>
+        <div class="package-cell">tuple</div>
+        <div class="package-cell">validator</div>
+        <div class="package-cell">xerror</div>
+    </div>
+</div>
+

docs/en/api/packages/algorithm.md

@@ -43,15 +43,15 @@ import (
 
 ### <span id="BubbleSort">BubbleSort</span>
 
-<p>Sort slice with bubble sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
+<p>Sort slice with bubble sort algorithm. Param comparator should implements constraints.Comparator.</p>
 
 <b>Signature:</b>
 
 ```go
-func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func BubbleSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/GNdv7Jg2Taj)</span></b>
 
 ```go
 package main
@@ -91,15 +91,15 @@ func main() {
 
 ### <span id="InsertionSort">InsertionSort</span>
 
-<p>Sort slice with insertion sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
+<p>Sort slice with insertion sort algorithm. Param comparator should implements constraints.Comparator.</p>
 
 <b>Signature:</b>
 
 ```go
-func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func InsertionSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/G5LJiWgJJW6)</span></b>
 
 ```go
 package main
@@ -117,7 +117,7 @@ type people struct {
 // PeopleAageComparator sort people slice by age field
 type peopleAgeComparator struct{}
 
-// Compare implements github.com/duke-git/lancet/lancetconstraints/constraints.go/Comparator
+// Compare implements github.com/duke-git/lancet/constraints/constraints.go/Comparator
 func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
     p1, _ := v1.(people)
     p2, _ := v2.(people)
@@ -154,15 +154,15 @@ func main() {
 
 ### <span id="SelectionSort">SelectionSort</span>
 
-<p>Sort slice with selection sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
+<p>Sort slice with selection sort algorithm. Param comparator should implements constraints.Comparator.</p>
 
 <b>Signature:</b>
 
 ```go
-func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func SelectionSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/oXovbkekayS)</span></b>
 
 ```go
 package main
@@ -202,15 +202,15 @@ func main() {
 
 ### <span id="ShellSort">ShellSort</span>
 
-<p>Sort slice with shell sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
+<p>Sort slice with shell sort algorithm. Param comparator should implements constraints.Comparator.</p>
 
 <b>Signature:</b>
 
 ```go
-func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func ShellSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/3ibkszpJEu3)</span></b>
 
 ```go
 package main
@@ -250,15 +250,15 @@ func main() {
 
 ### <span id="QuickSort">QuickSort</span>
 
-<p>Sort slice with quick sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
+<p>Sort slice with quick sort algorithm. Param comparator should implements constraints.Comparator.</p>
 
 <b>Signature:</b>
 
 ```go
-func QuickSort[T any](slice []T comparator lancetconstraints.Comparator)
+func QuickSort[T any](slice []T comparator constraints.Comparator)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/7Y7c1Elk3ax)</span></b>
 
 ```go
 package main
@@ -298,15 +298,15 @@ func main() {
 
 ### <span id="HeapSort">HeapSort</span>
 
-<p>Sort slice with heap sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
+<p>Sort slice with heap sort algorithm. Param comparator should implements constraints.Comparator.</p>
 
 <b>Signature:</b>
 
 ```go
-func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func HeapSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/u6Iwa1VZS_f)</span></b>
 
 ```go
 package main
@@ -346,15 +346,15 @@ func main() {
 
 ### <span id="MergeSort">MergeSort</span>
 
-<p>Sort slice with merge sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
+<p>Sort slice with merge sort algorithm. Param comparator should implements constraints.Comparator.</p>
 
 <b>Signature:</b>
 
 ```go
-func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator)
+func MergeSort[T any](slice []T, comparator constraints.Comparator)
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ydinn9YzUJn)</span></b>
 
 ```go
 package main
@@ -394,15 +394,15 @@ func main() {
 
 ### <span id="CountSort">CountSort</span>
 
-<p>Sort slice with count sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
+<p>Sort slice with count sort algorithm. Param comparator should implements constraints.Comparator.</p>
 
 <b>Signature:</b>
 
 ```go
-func CountSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+func CountSort[T any](slice []T, comparator constraints.Comparator) []T
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tB-Umgm0DrP)</span></b>
 
 ```go
 package main
@@ -448,10 +448,10 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
+func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator constraints.Comparator) int
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/t6MeGiUSN47)</span></b>
 
 ```go
 package main
@@ -499,10 +499,10 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
+func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator constraints.Comparator) int
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Anozfr8ZLH3)</span></b>
 
 ```go
 package main
@@ -553,7 +553,7 @@ func main() {
 func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/IsS7rgn5s3x)</span></b>
 
 ```go
 package main
@@ -596,7 +596,7 @@ func (l *LRUCache[K, V]) Delete(key K) bool
 func (l *LRUCache[K, V]) Len() int
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/IsS7rgn5s3x)</span></b>
 
 ```go
 package main

docs/en/api/packages/compare.md

@@ -30,6 +30,7 @@ import (
 -   [GreaterThan](#GreaterThan)
 -   [LessOrEqual](#LessOrEqual)
 -   [GreaterOrEqual](#GreaterOrEqual)
+-   [InDelta](#InDelta)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -39,7 +40,7 @@ import (
 
 <p>Checks if two values are equal or not. (check both type and value)</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/wmVxR-to4lz)</span></b>
 
 ```go
 func Equal(left, right any) bool
@@ -88,7 +89,7 @@ func main() {
 
 <p>Checks if two values are equal or not. (check value only)</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/fxnna_LLD9u)</span></b>
 
 ```go
 func EqualValue(left, right any) bool
@@ -127,7 +128,7 @@ func main() {
 
 <p>Checks if value `left` less than value `right`.</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/cYh7FQQj0ne)</span></b>
 
 ```go
 func LessThan(left, right any) bool
@@ -182,7 +183,7 @@ func main() {
 func GreaterThan(left, right any) bool
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9-NYDFZmIMp)</span></b>
 
 ```go
 package main
@@ -234,7 +235,7 @@ func main() {
 func LessOrEqual(left, right any) bool
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/e4T_scwoQzp)</span></b>
 
 ```go
 package main
@@ -277,7 +278,7 @@ func main() {
 
 <p>Checks if value `left` less greater or equal than value `right`.</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/vx8mP0U8DFk)</span></b>
 
 ```go
 func GreaterOrEqual(left, right any) bool
@@ -324,3 +325,50 @@ func main() {
     // false
 }
 ```
+
+### <span id="InDelta">InDelta</span>
+
+<p>Checks if two values are equal or not within a delta.</p>
+
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/TuDdcNtMkjo)</span></b>
+
+```go
+func InDelta[T constraints.Integer | constraints.Float](left, right T, delta float64) bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := InDelta(1, 1, 0)
+    result2 := InDelta(1, 2, 0)
+
+    result3 := InDelta(2.0/3.0, 0.66667, 0.001)
+    result4 := InDelta(2.0/3.0, 0.0, 0.001)
+
+    result5 := InDelta(float64(74.96)-float64(20.48), 54.48, 0)
+    result6 := InDelta(float64(74.96)-float64(20.48), 54.48, 1e-14)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+
+    // Output:
+    // true
+    // false
+    // true
+    // false
+    // false
+    // true
+}
+```

docs/en/api/packages/concurrency.md

@@ -35,7 +35,6 @@ import (
 
 ## Documentation
 
-
 ## Channel
 ### <span id="NewChannel">NewChannel</span>
 <p>Create a Channel pointer instance.</p>
@@ -46,7 +45,7 @@ import (
 type Channel[T any] struct
 func NewChannel[T any]() *Channel[T]
 ```
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/7aB4KyMMp9A)</span></b>
 
 ```go
 package main
@@ -70,7 +69,7 @@ func main() {
 ```go
 func (c *Channel[T]) Bridge(ctx context.Context, chanStream <-chan <-chan T) <-chan T
 ```
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/qmWSy1NVF-Y)</span></b>
 
 ```go
 package main
@@ -122,7 +121,7 @@ func main() {
 ```go
 func (c *Channel[T]) FanIn(ctx context.Context, channels ...<-chan T) <-chan T
 ```
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/2VYFMexEvTm)</span></b>
 
 ```go
 package main
@@ -156,7 +155,7 @@ func main() {
 
 <p>Create channel, put values into the channel repeatly until cancel the context.</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/k5N_ALVmYjE)</span></b>
 
 ```go
 func (c *Channel[T]) Repeat(ctx context.Context, values ...T) <-chan T
@@ -200,7 +199,7 @@ func main() {
 ```go
 func (c *Channel[T]) Generate(ctx context.Context, values ...T) <-chan T
 ```
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/7aB4KyMMp9A)</span></b>
 
 ```go
 package main
@@ -233,7 +232,7 @@ func main() {
 
 <p>Create a channel, excutes fn repeatly, and put the result into the channel, until close context.</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4J1zAWttP85)</span></b>
 
 ```go
 func (c *Channel[T]) RepeatFn(ctx context.Context, fn func() T) <-chan T
@@ -275,7 +274,7 @@ func main() {
 
 <p>Read one or more channels into one channel, will close when any readin channel is closed.</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Wqz9rwioPww)</span></b>
 
 ```go
 func (c *Channel[T]) Or(channels ...<-chan T) <-chan T
@@ -318,7 +317,7 @@ func main() {
 
 <p>Read a channel into another channel, will close until cancel context.</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/lm_GoS6aDjo)</span></b>
 
 ```go
 func (c *Channel[T]) OrDone(ctx context.Context, channel <-chan T) <-chan T
@@ -356,7 +355,7 @@ func main() {
 
 <p>Create a channel whose values are taken from another channel with limit number.</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9Utt-1pDr2J)</span></b>
 
 ```go
 func (c *Channel[T]) Take(ctx context.Context, valueStream <-chan T, number int) <-chan T
@@ -402,7 +401,7 @@ func main() {
 
 <p>Split one chanel into two channels, until cancel the context.</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/3TQPKnCirrP)</span></b>
 
 ```go
 func (c *Channel[T]) Tee(ctx context.Context, in <-chan T) (<-chan T, <-chan T)

docs/en/api/packages/condition.md

@@ -46,7 +46,7 @@ All other types are truthy if they are not their zero value.</p>
 ```go
 func Bool[T any](value T) bool
 ```
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ETzeDJRSvhm)</span></b>
 
 ```go
 package main
@@ -111,7 +111,7 @@ func main() {
 ```go
 func And[T, U any](a T, b U) bool
 ```
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/W1SSUmt6pvr)</span></b>
 
 ```go
 package main
@@ -139,7 +139,7 @@ func main() {
 ```go
 func Or[T, U any](a T, b U) bool
 ```
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UlQTxHaeEkq)</span></b>
 
 ```go
 package main
@@ -167,7 +167,7 @@ func main() {
 ```go
 func Xor[T, U any](a T, b U) bool
 ```
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/gObZrW7ZbG8)</span></b>
 
 ```go
 package main
@@ -195,7 +195,7 @@ func main() {
 ```go
 func Nor[T, U any](a T, b U) bool
 ```
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/g2j08F_zZky)</span></b>
 
 ```go
 package main
@@ -222,7 +222,7 @@ func main() {
 ```go
 func Xnor[T, U any](a T, b U) bool
 ```
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OuDB9g51643)</span></b>
 
 ```go
 package main
@@ -249,7 +249,7 @@ func main() {
 ```go
 func Nand[T, U any](a T, b U) bool
 ```
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/vSRMLxLIbq8)</span></b>
 
 ```go
 package main
@@ -277,7 +277,7 @@ func main() {
 ```go
 func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U
 ```
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ElllPZY0guT)</span></b>
 
 ```go
 package main

docs/en/api/packages/convertor.md

@@ -43,6 +43,10 @@ import (
 -   [ToInterface](#ToInterface)
 -   [Utf8ToGbk](#Utf8ToGbk)
 -   [GbkToUtf8](#GbkToUtf8)
+-   [ToStdBase64](#ToStdBase64)
+-   [ToUrlBase64](#ToUrlBase64)
+-   [ToRawStdBase64](#ToRawStdBase64)
+-   [ToRawUrlBase64](#ToRawUrlBase64)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -58,7 +62,7 @@ import (
 func ColorHexToRGB(colorHex string) (red, green, blue int)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/o7_ft-JCJBV)</span></b>
 
 ```go
 package main
@@ -89,7 +93,7 @@ func main() {
 func ColorRGBToHex(red, green, blue int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nzKS2Ro87J1)</span></b>
 
 ```go
 package main
@@ -122,7 +126,7 @@ func main() {
 func ToBool(s string) (bool, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ARht2WnGdIN)</span></b>
 
 ```go
 package main
@@ -163,7 +167,7 @@ func main() {
 func ToBytes(data any) ([]byte, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/fAMXYFDvOvr)</span></b>
 
 ```go
 package main
@@ -196,7 +200,7 @@ func main() {
 func ToChar(s string) []string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/JJ1SvbFkVdM)</span></b>
 
 ```go
 package main
@@ -232,7 +236,7 @@ func main() {
 func ToChannel[T any](array []T) <-chan T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/hOx_oYZbAnL)</span></b>
 
 ```go
 package main
@@ -269,7 +273,7 @@ func main() {
 func ToFloat(value any) (float64, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4YTmPCibqHJ)</span></b>
 
 ```go
 package main
@@ -314,7 +318,7 @@ func main() {
 func ToInt(value any) (int64, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9_h9vIt-QZ_b)</span></b>
 
 ```go
 package main
@@ -356,7 +360,7 @@ func main() {
 func ToJson(value any) (string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/2rLIkMmXWvR)</span></b>
 
 ```go
 package main
@@ -391,7 +395,7 @@ func main() {
 func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tVFy7E-t24l)</span></b>
 
 ```go
 package main
@@ -432,7 +436,7 @@ func main() {
 func ToPointer[T any](value T) *T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ASf_etHNlw1)</span></b>
 
 ```go
 package main
@@ -461,7 +465,7 @@ func main() {
 func ToString(value any) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nF1zOOslpQq)</span></b>
 
 ```go
 package main
@@ -509,7 +513,7 @@ func main() {
 func StructToMap(value any) (map[string]any, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/KYGYJqNUBOI)</span></b>
 
 ```go
 package main
@@ -547,7 +551,7 @@ func main() {
 func MapToSlice[T any, K comparable, V any](aMap map[K]V, iteratee func(K, V) T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/dmX4Ix5V6Wl)</span></b>
 
 ```go
 package main
@@ -567,6 +571,7 @@ func main() {
 }
 ```
 
+
 ### <span id="EncodeByte">EncodeByte</span>
 
 <p>Encode data to byte slice.</p>
@@ -577,7 +582,7 @@ func main() {
 func EncodeByte(data any) ([]byte, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/DVmM1G5JfuP)</span></b>
 
 ```go
 package main
@@ -606,7 +611,7 @@ func main() {
 func DecodeByte(data []byte, target any) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/zI6xsmuQRbn)</span></b>
 
 ```go
 package main
@@ -632,69 +637,6 @@ func main() {
 }
 ```
 
-### <span id="DeepClone">DeepClone</span>
-
-<p>Creates a deep copy of passed item, can't clone unexported field of struct.</p>
-
-<b>Signature:</b>
-
-```go
-func DeepClone[T any](src T) T
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    type Struct struct {
-        Str        string
-        Int        int
-        Float      float64
-        Bool       bool
-        Nil        interface{}
-        unexported string
-    }
-
-    cases := []interface{}{
-        true,
-        1,
-        0.1,
-        map[string]int{
-            "a": 1,
-            "b": 2,
-        },
-        &Struct{
-            Str:   "test",
-            Int:   1,
-            Float: 0.1,
-            Bool:  true,
-            Nil:   nil,
-            // unexported: "can't be cloned",
-        },
-    }
-
-    for _, item := range cases {
-        cloned := convertor.DeepClone(item)
-
-        isPointerEqual := &cloned == &item
-        fmt.Println(cloned, isPointerEqual)
-    }
-
-    // Output:
-    // true false
-    // 1 false
-    // 0.1 false
-    // map[a:1 b:2] false
-    // &{test 1 0.1 true <nil> } false
-}
-```
 
 ### <span id="CopyProperties">CopyProperties</span>
 
@@ -706,7 +648,7 @@ func main() {
 func CopyProperties[T, U any](dst T, src U) (err error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/oZujoB5Sgg5)</span></b>
 
 ```go
 package main
@@ -775,41 +717,6 @@ func main() {
 }
 ```
 
-### <span id="ToInterface">ToInterface</span>
-
-<p>Converts reflect value to its interface type.</p>
-
-<b>Signature:</b>
-
-```go
-func ToInterface(v reflect.Value) (value interface{}, ok bool)
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    val := reflect.ValueOf("abc")
-    iVal, ok := convertor.ToInterface(val)
-
-    fmt.Printf("%T\n", iVal)
-    fmt.Printf("%v\n", iVal)
-    fmt.Println(ok)
-
-    // Output:
-    // string
-    // abc
-    // true    
-}
-```
-
 ### <span id="Utf8ToGbk">Utf8ToGbk</span>
 
 <p>Converts utf8 encoding data to GBK encoding data.</p>
@@ -820,7 +727,7 @@ func main() {
 func Utf8ToGbk(bs []byte) ([]byte, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9FlIaFLArIL)</span></b>
 
 ```go
 package main
@@ -854,7 +761,7 @@ func main() {
 func GbkToUtf8(bs []byte) ([]byte, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/OphmHCN_9u8)</span></b>
 
 ```go
 package main
@@ -875,4 +782,338 @@ func main() {
     // true
     // hello   
 }
+```
+
+### <span id="ToStdBase64">ToStdBase64</span>
+
+<p>Convert a value to a string encoded in standard Base64. Error data of type "error" will also be encoded, and complex structures will be converted to a JSON formatted string.</p>
+
+<b>Signature:</b>
+
+```go
+func ToStdBase64(value any) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_fLJqJD3NMo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    afterEncode := convertor.ToStdBase64(nil)
+    fmt.Println(afterEncode)
+
+    afterEncode = convertor.ToStdBase64("")
+    fmt.Println(afterEncode)
+
+    stringVal := "hello"
+    afterEncode = convertor.ToStdBase64(stringVal)
+    fmt.Println(afterEncode)
+
+    byteSliceVal := []byte("hello")
+    afterEncode = convertor.ToStdBase64(byteSliceVal)
+    fmt.Println(afterEncode)
+
+    intVal := 123
+    afterEncode = convertor.ToStdBase64(intVal)
+    fmt.Println(afterEncode)
+
+    mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+        A string
+        B int
+    }{"hello", 3}}
+    afterEncode = convertor.ToStdBase64(mapVal)
+    fmt.Println(afterEncode)
+
+    floatVal := 123.456
+    afterEncode = convertor.ToStdBase64(floatVal)
+    fmt.Println(afterEncode)
+
+    boolVal := true
+    afterEncode = convertor.ToStdBase64(boolVal)
+    fmt.Println(afterEncode)
+
+    errVal := errors.New("err")
+    afterEncode = convertor.ToStdBase64(errVal)
+    fmt.Println(afterEncode)
+
+    // Output:
+    //
+    //
+    // aGVsbG8=
+    // aGVsbG8=
+    // MTIz
+    // eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ==
+    // MTIzLjQ1Ng==
+    // dHJ1ZQ==
+    // ZXJy
+}
+
+```
+
+
+
+### <span id="ToUrlBase64">ToUrlBase64</span>
+
+<p>Convert a value to a string encoded in url Base64. Error data of type "error" will also be encoded, and complex structures will be converted to a JSON formatted string.</p>
+
+<b>Signature:</b>
+
+```go
+func ToUrlBase64(value any) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/C_d0GlvEeUR)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    afterEncode := convertor.ToUrlBase64(nil)
+    fmt.Println(afterEncode)
+
+
+    stringVal := "hello"
+    afterEncode = convertor.ToUrlBase64(stringVal)
+    fmt.Println(afterEncode)
+
+    byteSliceVal := []byte("hello")
+    afterEncode = convertor.ToUrlBase64(byteSliceVal)
+    fmt.Println(afterEncode)
+
+    intVal := 123
+    afterEncode = convertor.ToUrlBase64(intVal)
+    fmt.Println(afterEncode)
+
+    mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+        A string
+        B int
+    }{"hello", 3}}
+    afterEncode = convertor.ToUrlBase64(mapVal)
+    fmt.Println(afterEncode)
+
+    floatVal := 123.456
+    afterEncode = convertor.ToUrlBase64(floatVal)
+    fmt.Println(afterEncode)
+
+    boolVal := true
+    afterEncode = convertor.ToUrlBase64(boolVal)
+    fmt.Println(afterEncode)
+
+    errVal := errors.New("err")
+    afterEncode = convertor.ToUrlBase64(errVal)
+    fmt.Println(afterEncode)
+
+    // Output:
+    //
+    // aGVsbG8=
+    // aGVsbG8=
+    // MTIz
+    // eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ==
+    // MTIzLjQ1Ng==
+    // dHJ1ZQ==
+    // ZXJy
+}
+
+```
+
+### <span id="ToRawStdBase64">ToRawStdBase64</span>
+
+<p>Convert a value to a string encoded in raw standard Base64. Error data of type "error" will also be encoded, and complex structures will be converted to a JSON formatted string.</p>
+
+<b>Signature:</b>
+
+```go
+func ToRawStdBase64(value any) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/wSAr3sfkDcv)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+
+    stringVal := "hello"
+    afterEncode := convertor.ToRawStdBase64(stringVal)
+    fmt.Println(afterEncode)
+
+    byteSliceVal := []byte("hello")
+    afterEncode = convertor.ToRawStdBase64(byteSliceVal)
+    fmt.Println(afterEncode)
+
+    intVal := 123
+    afterEncode = convertor.ToRawStdBase64(intVal)
+    fmt.Println(afterEncode)
+
+    mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+        A string
+        B int
+    }{"hello", 3}}
+    afterEncode = convertor.ToRawStdBase64(mapVal)
+    fmt.Println(afterEncode)
+
+    floatVal := 123.456
+    afterEncode = convertor.ToRawStdBase64(floatVal)
+    fmt.Println(afterEncode)
+
+    boolVal := true
+    afterEncode = convertor.ToRawStdBase64(boolVal)
+    fmt.Println(afterEncode)
+
+    errVal := errors.New("err")
+    afterEncode = convertor.ToRawStdBase64(errVal)
+    fmt.Println(afterEncode)
+
+    // Output:
+    // aGVsbG8
+    // aGVsbG8
+    // MTIz
+    // eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ
+    // MTIzLjQ1Ng
+    // dHJ1ZQ
+    // ZXJy
+}
+```
+
+### <span id="ToRawUrlBase64">ToRawUrlBase64</span>
+
+<p> Convert a value to a string encoded in raw url Base64. Error data of type "error" will also be encoded, and complex structures will be converted to a JSON formatted string.</p>
+
+<b>Signature:</b>
+
+```go
+func ToRawUrlBase64(value any) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/HwdDPFcza1O)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+
+    stringVal := "hello"
+    afterEncode := convertor.ToRawUrlBase64(stringVal)
+    fmt.Println(afterEncode)
+
+    byteSliceVal := []byte("hello")
+    afterEncode = convertor.ToRawUrlBase64(byteSliceVal)
+    fmt.Println(afterEncode)
+
+    intVal := 123
+    afterEncode = convertor.ToRawUrlBase64(intVal)
+    fmt.Println(afterEncode)
+
+    mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
+        A string
+        B int
+    }{"hello", 3}}
+    afterEncode = convertor.ToRawUrlBase64(mapVal)
+    fmt.Println(afterEncode)
+
+    floatVal := 123.456
+    afterEncode = convertor.ToRawUrlBase64(floatVal)
+    fmt.Println(afterEncode)
+
+    boolVal := true
+    afterEncode = convertor.ToRawUrlBase64(boolVal)
+    fmt.Println(afterEncode)
+
+    errVal := errors.New("err")
+    afterEncode = convertor.ToRawUrlBase64(errVal)
+    fmt.Println(afterEncode)
+
+    // Output:
+    // aGVsbG8
+    // aGVsbG8
+    // MTIz
+    // eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ
+    // MTIzLjQ1Ng
+    // dHJ1ZQ
+    // ZXJy
+}
+```
+
+### <span id="DeepClone">DeepClone</span>
+
+<p>Creates a deep copy of passed item, can't clone unexported field of struct.</p>
+
+<b>Signature:</b>
+
+```go
+func DeepClone[T any](src T) T
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/j4DP5dquxnk)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    type Struct struct {
+        Str        string
+        Int        int
+        Float      float64
+        Bool       bool
+        Nil        interface{}
+        unexported string
+    }
+
+    cases := []interface{}{
+        true,
+        1,
+        0.1,
+        map[string]int{
+            "a": 1,
+            "b": 2,
+        },
+        &Struct{
+            Str:   "test",
+            Int:   1,
+            Float: 0.1,
+            Bool:  true,
+            Nil:   nil,
+        },
+    }
+
+    for _, item := range cases {
+        cloned := convertor.DeepClone(item)
+
+        isPointerEqual := &cloned == &item
+        fmt.Println(cloned, isPointerEqual)
+    }
+
+    // Output:
+    // true false
+    // 1 false
+    // 0.1 false
+    // map[a:1 b:2] false
+    // &{test 1 0.1 true <nil> } false
+}
 ```

docs/en/api/packages/cryptor.md

@@ -1,18 +1,18 @@
 # Cryptor
+
 Package cryptor contains some functions for data encryption and decryption. Support base64, md5, hmac, aes, des, rsa.
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Source:
 
-- [https://github.com/duke-git/lancet/blob/main/cryptor/basic.go](https://github.com/duke-git/lancet/blob/main/cryptor/basic.go)
-- [https://github.com/duke-git/lancet/blob/main/cryptor/crypto.go](https://github.com/duke-git/lancet/blob/main/cryptor/crypto.go)
-
-
+-   [https://github.com/duke-git/lancet/blob/main/cryptor/basic.go](https://github.com/duke-git/lancet/blob/main/cryptor/basic.go)
+-   [https://github.com/duke-git/lancet/blob/main/cryptor/crypto.go](https://github.com/duke-git/lancet/blob/main/cryptor/crypto.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Usage:
+
 ```go
 import (
     "github.com/duke-git/lancet/v2/cryptor"
@@ -23,49 +23,51 @@ import (
 
 ## Index
 
-- [AesEcbEncrypt](#AesEcbEncrypt)
-- [AesEcbDecrypt](#AesEcbDecrypt)
-- [AesCbcEncrypt](#AesCbcEncrypt)
-- [AesCbcDecrypt](#AesCbcDecrypt)
-- [AesCtrCrypt](#AesCtrCrypt)
-- [AesCfbEncrypt](#AesCfbEncrypt)
-- [AesCfbDecrypt](#AesCfbDecrypt)
-- [AesOfbEncrypt](#AesOfbEncrypt)
-- [AesOfbDecrypt](#AesOfbDecrypt)
-- [Base64StdEncode](#Base64StdEncode)
-- [Base64StdDecode](#Base64StdDecode)
-- [DesEcbEncrypt](#DesEcbEncrypt)
-- [DesEcbDecrypt](#DesEcbDecrypt)
-- [DesCbcEncrypt](#DesCbcEncrypt)
-- [DesCbcDecrypt](#DesCbcDecrypt)
-- [DesCtrCrypt](#DesCtrCrypt)
-- [DesCfbEncrypt](#DesCfbEncrypt)
-- [DesCfbDecrypt](#DesCfbDecrypt)
-- [DesOfbEncrypt](#DesOfbEncrypt)
-- [DesOfbDecrypt](#DesOfbDecrypt)
-- [HmacMd5](#HmacMd5)
-- [HmacMd5WithBase64](#HmacMd5WithBase64)
-- [HmacSha1](#HmacSha1)
-- [HmacSha1WithBase64](#HmacSha1WithBase64)
-- [HmacSha256](#HmacSha256)
-- [HmacSha256WithBase64](#HmacSha256WithBase64)
-- [HmacSha512](#HmacSha512)
-- [HmacSha512WithBase64](#HmacSha512WithBase64)
-- [Md5String](#Md5String)
-- [Md5StringWithBase64](#Md5StringWithBase64)
-- [Md5Byte](#Md5Byte)
-- [Md5ByteWithBase64](#Md5ByteWithBase64)
-- [Md5File](#Md5File)
-- [Sha1](#Sha1)
-- [Sha1WithBase64](#Sha1WithBase64)
-- [Sha256](#Sha256)
-- [Sha256WithBase64](#Sha256WithBase64)
-- [Sha512](#Sha512)
-- [Sha512WithBase64](#Sha512WithBase64)
-- [GenerateRsaKey](#GenerateRsaKey)
-- [RsaEncrypt](#RsaEncrypt)
-- [RsaDecrypt](#RsaDecrypt)
-
+-   [AesEcbEncrypt](#AesEcbEncrypt)
+-   [AesEcbDecrypt](#AesEcbDecrypt)
+-   [AesCbcEncrypt](#AesCbcEncrypt)
+-   [AesCbcDecrypt](#AesCbcDecrypt)
+-   [AesCtrCrypt](#AesCtrCrypt)
+-   [AesCfbEncrypt](#AesCfbEncrypt)
+-   [AesCfbDecrypt](#AesCfbDecrypt)
+-   [AesOfbEncrypt](#AesOfbEncrypt)
+-   [AesOfbDecrypt](#AesOfbDecrypt)
+-   [Base64StdEncode](#Base64StdEncode)
+-   [Base64StdDecode](#Base64StdDecode)
+-   [DesEcbEncrypt](#DesEcbEncrypt)
+-   [DesEcbDecrypt](#DesEcbDecrypt)
+-   [DesCbcEncrypt](#DesCbcEncrypt)
+-   [DesCbcDecrypt](#DesCbcDecrypt)
+-   [DesCtrCrypt](#DesCtrCrypt)
+-   [DesCfbEncrypt](#DesCfbEncrypt)
+-   [DesCfbDecrypt](#DesCfbDecrypt)
+-   [DesOfbEncrypt](#DesOfbEncrypt)
+-   [DesOfbDecrypt](#DesOfbDecrypt)
+-   [HmacMd5](#HmacMd5)
+-   [HmacMd5WithBase64](#HmacMd5WithBase64)
+-   [HmacSha1](#HmacSha1)
+-   [HmacSha1WithBase64](#HmacSha1WithBase64)
+-   [HmacSha256](#HmacSha256)
+-   [HmacSha256WithBase64](#HmacSha256WithBase64)
+-   [HmacSha512](#HmacSha512)
+-   [HmacSha512WithBase64](#HmacSha512WithBase64)
+-   [Md5String](#Md5String)
+-   [Md5StringWithBase64](#Md5StringWithBase64)
+-   [Md5Byte](#Md5Byte)
+-   [Md5ByteWithBase64](#Md5ByteWithBase64)
+-   [Md5File](#Md5File)
+-   [Sha1](#Sha1)
+-   [Sha1WithBase64](#Sha1WithBase64)
+-   [Sha256](#Sha256)
+-   [Sha256WithBase64](#Sha256WithBase64)
+-   [Sha512](#Sha512)
+-   [Sha512WithBase64](#Sha512WithBase64)
+-   [GenerateRsaKey](#GenerateRsaKey)
+-   [RsaEncrypt](#RsaEncrypt)
+-   [RsaDecrypt](#RsaDecrypt)
+-   [GenerateRsaKeyPair](#GenerateRsaKeyPair)
+-   [RsaEncryptOAEP](#RsaEncryptOAEP)
+-   [RsaDecryptOAEP](#RsaDecryptOAEP)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -80,7 +82,8 @@ import (
 ```go
 func AesEcbEncrypt(data, key []byte) []byte
 ```
-<b>Example:</b>
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/zI6xsmuQRbn)</span></b>
 
 ```go
 package main
@@ -113,7 +116,8 @@ func main() {
 ```go
 func AesEcbDecrypt(encrypted, key []byte) []byte
 ```
-<b>Example:</b>
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/zI6xsmuQRbn)</span></b>
 
 ```go
 package main
@@ -146,7 +150,8 @@ func main() {
 ```go
 func AesCbcEncrypt(data, key []byte) []byte
 ```
-<b>Example:</b>
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/IOq_g8_lKZD)</span></b>
 
 ```go
 package main
@@ -180,7 +185,7 @@ func main() {
 func AesCbcDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/IOq_g8_lKZD)</span></b>
 
 ```go
 package main
@@ -214,7 +219,7 @@ func main() {
 func AesCtrCrypt(data, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/SpaZO0-5Nsp)</span></b>
 
 ```go
 package main
@@ -248,7 +253,7 @@ func main() {
 func AesCfbEncrypt(data, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tfkF10B13kH)</span></b>
 
 ```go
 package main
@@ -282,7 +287,7 @@ func main() {
 func AesCfbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tfkF10B13kH)</span></b>
 
 ```go
 package main
@@ -316,7 +321,7 @@ func main() {
 func AesOfbEncrypt(data, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/VtHxtkUj-3F)</span></b>
 
 ```go
 package main
@@ -339,6 +344,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="AesCfbDecrypt">AesOfbDecrypt</span>
 
 <p>Decrypt data with key use AES OFB algorithm. Length of `key` param should be 16, 24 or 32.</p>
@@ -349,7 +355,7 @@ func main() {
 func AesOfbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/VtHxtkUj-3F)</span></b>
 
 ```go
 package main
@@ -382,7 +388,8 @@ func main() {
 ```go
 func Base64StdEncode(s string) string
 ```
-<b>Example:</b>
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/VOaUyQUreoK)</span></b>
 
 ```go
 package main
@@ -400,6 +407,7 @@ func main() {
     // aGVsbG8=
 }
 ```
+
 ### <span id="Base64StdDecode">Base64StdDecode</span>
 
 <p>Decode a base64 encoded string.</p>
@@ -410,7 +418,7 @@ func main() {
 func Base64StdDecode(s string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/RWQylnJVgIe)</span></b>
 
 ```go
 package main
@@ -439,7 +447,7 @@ func main() {
 func DesEcbEncrypt(data, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/8qivmPeZy4P)</span></b>
 
 ```go
 package main
@@ -463,6 +471,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesEcbDecrypt">DesEcbDecrypt</span>
 
 <p>Decrypt data with key use DES ECB algorithm. Length of `key` param should be 8.</p>
@@ -473,7 +482,7 @@ func main() {
 func DesEcbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/8qivmPeZy4P)</span></b>
 
 ```go
 package main
@@ -508,7 +517,7 @@ func main() {
 func DesCbcEncrypt(data, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4cC4QvWfe3_1)</span></b>
 
 ```go
 package main
@@ -542,7 +551,7 @@ func main() {
 func DesCbcDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4cC4QvWfe3_1)</span></b>
 
 ```go
 package main
@@ -565,6 +574,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesCtrCrypt">DesCtrCrypt</span>
 
 <p>Encrypt or decrypt data with key use DES CTR algorithm. Length of `key` param should be 8.</p>
@@ -575,7 +585,7 @@ func main() {
 func DesCtrCrypt(data, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9-T6OjKpcdw)</span></b>
 
 ```go
 package main
@@ -609,7 +619,7 @@ func main() {
 func DesCfbEncrypt(data, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/y-eNxcFBlxL)</span></b>
 
 ```go
 package main
@@ -632,6 +642,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesCfbDecrypt">DesCfbDecrypt</span>
 
 <p>Decrypt data with key use DES CBC algorithm. Length of `key` param should be 8.</p>
@@ -642,7 +653,7 @@ func main() {
 func DesCfbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/y-eNxcFBlxL)</span></b>
 
 ```go
 package main
@@ -665,6 +676,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesOfbEncrypt">DesOfbEncrypt</span>
 
 <p>Enecrypt data with key use DES OFB algorithm. Length of `key` param should be 8.</p>
@@ -675,7 +687,7 @@ func main() {
 func DesOfbEncrypt(data, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/74KmNadjN1J)</span></b>
 
 ```go
 package main
@@ -698,6 +710,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesOfbDecrypt">DesOfbDecrypt</span>
 
 <p>Decrypt data with key use DES OFB algorithm. Length of `key` param should be 8.</p>
@@ -708,7 +721,7 @@ func main() {
 func DesOfbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/74KmNadjN1J)</span></b>
 
 ```go
 package main
@@ -742,7 +755,7 @@ func main() {
 func HmacMd5(str, key string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uef0q1fz53I)</span></b>
 
 ```go
 package main
@@ -774,7 +787,7 @@ func main() {
 func HmacMd5WithBase64(str, key string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/UY0ng2AefFC)</span></b>
 
 ```go
 package main
@@ -806,7 +819,7 @@ func main() {
 func HmacSha1(str, key string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/1UI4oQ4WXKM)</span></b>
 
 ```go
 package main
@@ -838,7 +851,7 @@ func main() {
 func HmacSha1WithBase64(str, key string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/47JmmGrnF7B)</span></b>
 
 ```go
 package main
@@ -870,7 +883,7 @@ func main() {
 func HmacSha256(str, key string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/HhpwXxFhhC0)</span></b>
 
 ```go
 package main
@@ -902,7 +915,7 @@ func main() {
 func HmacSha256WithBase64(str, key string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/EKbkUvPTLwO)</span></b>
 
 ```go
 package main
@@ -934,7 +947,7 @@ func main() {
 func HmacSha512(str, key string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/59Od6m4A0Ud)</span></b>
 
 ```go
 package main
@@ -966,7 +979,7 @@ func main() {
 func HmacSha512WithBase64(str, key string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/c6dSe3E2ydU)</span></b>
 
 ```go
 package main
@@ -988,7 +1001,6 @@ func main() {
 }
 ```
 
-
 ### <span id="Md5String">Md5String</span>
 
 <p>Get the md5 value of string.</p>
@@ -999,7 +1011,7 @@ func main() {
 func Md5String(s string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/1bLcVetbTOI)</span></b>
 
 ```go
 package main
@@ -1030,7 +1042,7 @@ func main() {
 func Md5StringWithBase64(s string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Tcb-Z7LN2ax)</span></b>
 
 ```go
 package main
@@ -1059,7 +1071,7 @@ func main() {
 func Md5Byte(data []byte) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/suraalH8lyC)</span></b>
 
 ```go
 package main
@@ -1088,7 +1100,7 @@ func main() {
 func Md5ByteWithBase64(data []byte) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Lx4gH7Vdr5_y)</span></b>
 
 ```go
 package main
@@ -1143,7 +1155,7 @@ func main() {
 func Sha1(str string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_m_uoD1deMT)</span></b>
 
 ```go
 package main
@@ -1174,7 +1186,7 @@ func main() {
 func Sha1WithBase64(str string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/fSyx-Gl2l2-)</span></b>
 
 ```go
 package main
@@ -1203,7 +1215,7 @@ func main() {
 func Sha256(str string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tU9tfBMIAr1)</span></b>
 
 ```go
 package main
@@ -1234,7 +1246,7 @@ func main() {
 func Sha256WithBase64(str string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/85IXJHIal1k)</span></b>
 
 ```go
 package main
@@ -1263,7 +1275,7 @@ func main() {
 func Sha512(str string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/3WsvLYZxsHa)</span></b>
 
 ```go
 package main
@@ -1294,7 +1306,7 @@ func main() {
 func Sha512WithBase64(str string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/q_fY2rA-k5I)</span></b>
 
 ```go
 package main
@@ -1323,7 +1335,7 @@ func main() {
 func GenerateRsaKey(keySize int, priKeyFile, pubKeyFile string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/zutRHrDqs0X)</span></b>
 
 ```go
 package main
@@ -1351,7 +1363,7 @@ func main() {
 func RsaEncrypt(data []byte, pubKeyFileName string) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uef0q1fz53I)</span></b>
 
 ```go
 package main
@@ -1366,11 +1378,11 @@ func main() {
     if err != nil {
         return
     }
-      
+
     data := []byte("hello")
     encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
     decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
-      
+
     fmt.Println(string(decrypted))
 
     // Output:
@@ -1378,7 +1390,6 @@ func main() {
 }
 ```
 
-
 ### <span id="RsaDecrypt">RsaDecrypt</span>
 
 <p>Decrypt data with private key file useing ras algorithm.</p>
@@ -1389,7 +1400,7 @@ func main() {
 func RsaDecrypt(data []byte, privateKeyFileName string) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uef0q1fz53I)</span></b>
 
 ```go
 package main
@@ -1404,11 +1415,11 @@ func main() {
     if err != nil {
         return
     }
-      
+
     data := []byte("hello")
     encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
     decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
-      
+
     fmt.Println(string(decrypted))
 
     // Output:
@@ -1416,5 +1427,113 @@ func main() {
 }
 ```
 
+### <span id="GenerateRsaKeyPair">GenerateRsaKeyPair</span>
 
+<p>Creates rsa private and public key.</p>
 
+<b>Signature:</b>
+
+```go
+func GenerateRsaKeyPair(keySize int) (*rsa.PrivateKey, *rsa.PublicKey)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/sSVmkfENKMz)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    pri, pub := cryptor.GenerateRsaKeyPair(1024)
+}
+```
+
+### <span id="RsaEncryptOAEP">RsaEncryptOAEP</span>
+
+<p>Encrypts the given data with RSA-OAEP.</p>
+
+<b>Signature:</b>
+
+```go
+func RsaEncryptOAEP(data []byte, label []byte, key rsa.PublicKey) ([]byte, error)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/sSVmkfENKMz)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    pri, pub := cryptor.GenerateRsaKeyPair(1024)
+
+    data := []byte("hello world")
+    label := []byte("123456")
+
+    encrypted, err := cryptor.RsaEncryptOAEP(data, label, *pub)
+    if err != nil {
+        return
+    }
+
+    decrypted, err := cryptor.RsaDecryptOAEP([]byte(encrypted), label, *pri)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(string(decrypted))
+
+    // Output:
+    // hello world
+}
+```
+
+### <span id="RsaDecryptOAEP">RsaDecryptOAEP</span>
+
+<p>Decrypts the data with RSA-OAEP.</p>
+
+<b>Signature:</b>
+
+```go
+func RsaDecryptOAEP(ciphertext []byte, label []byte, key rsa.PrivateKey) ([]byte, error)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/sSVmkfENKMz)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    pri, pub := cryptor.GenerateRsaKeyPair(1024)
+
+    data := []byte("hello world")
+    label := []byte("123456")
+
+    encrypted, err := cryptor.RsaEncryptOAEP(data, label, *pub)
+    if err != nil {
+        return
+    }
+
+    decrypted, err := cryptor.RsaDecryptOAEP([]byte(encrypted), label, *pri)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(string(decrypted))
+
+    // Output:
+    // hello world
+}
+```

docs/en/api/packages/datastructure/copyonwritelist.md

@@ -0,0 +1,525 @@
+# CopyOnWriteList
+
+CopyOnWriteList is a thread-safe list implementation that uses go slicing as its base. When writing, a new slice is copied and assigned to the original slice when writing is complete. When reading, the original slice is read directly.
+
+## 源码
+
+-   [https://github.com/duke-git/lancet/blob/main/datastructure/list/copyonwritelist.go](https://github.com/duke-git/lancet/blob/main /datastructure/list/copyonwritelist.go)
+
+## 用法
+
+```go
+import (
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [NewCopyOnWriteList](#NewCopyOnWriteList)
+-   [Size](#Size)
+-   [Get](#Get)
+-   [Set](#Set)
+-   [Remove](#Remove)
+-   [IndexOf](#IndexOf)
+-   [LastIndexOf](#LastIndexOf)
+-   [IndexOfFunc](#IndexOfFunc)
+-   [LastIndexOfFunc](#LastIndexOfFunc)
+-   [IsEmpty](#IsEmpty)
+-   [Contain](#Contain)
+-   [ValueOf](#ValueOf)
+-   [Add](#Add)
+-   [AddAll](#AddAll)
+-   [AddByIndex](#AddByIndex)
+-   [DeleteAt](#DeleteAt)
+-   [DeleteIf](#DeleteIf)
+-   [DeleteBy](#DeleteBy)
+-   [DeleteRange](#DeleteRange)
+-   [Equal](#Equal)
+
+## Documentation
+
+### NewCopyOnWriteList
+
+Returns a CopyOnWriteList with empty slices.
+
+```go
+type CopyOnWriteList[T any] struct {
+    data []T
+    lock sync.
+}
+
+func NewCopyOnWriteList() *CopyOnWriteList
+
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l)
+}
+```
+
+### Size
+
+Returns the length of the CopyOnWriteList.
+
+```go
+func (l *CopyOnWriteList[T]) Size() int
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Size())
+}
+
+```
+
+### Get
+
+Returns the element at the specified position in the list
+
+```go
+func (c *CopyOnWriteList[T]) Get(index int) *T
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Get(2))
+}
+
+```
+
+### Set
+
+Replaces the element at the specified position in this list with the specified element.
+
+```go
+func (c *CopyOnWriteList[T]) Set(index int, e T) (oldValue *T, ok bool)
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Set(2, 4))
+}
+
+```
+
+### Remove
+
+### IndexOf
+
+Returns the index of the value in the list, or -1 if not found.
+
+```go
+func (c *CopyOnWriteList[T]) IndexOf(e T) int
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.IndexOf(1))
+}
+
+```
+
+### LastIndexOf
+
+Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain that element.
+
+```go
+func (c *CopyOnWriteList[T]) LastIndexOf(e T) int
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3,1})
+    fmt.Println(l.LastIndexOf(1))
+}
+
+```
+
+
+### <span id="IndexOfFunc">IndexOfFunc</span>
+<p> IndexOfFunc returns the first index satisfying the functional predicate f(v) bool. if not found return -1.</p>
+
+<b>Signature:</b>
+
+```go
+func (l *CopyOnWriteList[T]) IndexOfFunc(f func(T) bool) int 
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1, 2, 3})
+
+    fmt.Println(l.IndexOfFunc(func(a int) bool { return a == 1 })) //0
+    fmt.Println(l.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 the functional predicate f(T) bool. if not found return -1.</p>
+
+<b>Signature:</b>
+
+```go
+func (l *CopyOnWriteList[T]) LastIndexOfFunc(f func(T) bool) int
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1, 2, 3, 1})
+
+    fmt.Println(l.LastIndexOfFunc(func(a int) bool { return a == 1 })) // 3
+    fmt.Println(l.LastIndexOfFunc(func(a int) bool { return a == 0 })) //-1
+}
+```
+
+### IsEmpty
+
+Returns true if this list does not contain any elements.
+
+```go
+func (c *CopyOnWriteList[T]) IsEmpty() bool
+```
+
+#### Example
+
+```go
+package main
+
+import (
+"fmt"
+"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{})
+    fmt.Println(l.IsEmpty())
+}
+```
+
+### Contain
+
+Determines if a CopyOnWriteList contains an element.
+
+```go
+func (c *CopyOnWriteList[T]) Contain(e T) bool
+```
+
+#### Example
+
+```go
+package main
+
+import (
+"fmt"
+"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+l := list.NewCopyOnWriteList([]int{1,2,3})
+fmt.Println(l.Contain(1))
+}
+```
+
+### ValueOf
+
+Returns a pointer to the value at the index in the list
+
+```go
+func (c *CopyOnWriteList[T]) ValueOf(index int) []T
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.ValueOf(2))
+}
+
+```
+
+### Add
+
+Appends the specified element to the end of the list.
+
+```go
+func (c *CopyOnWriteList[T]) Add(e T) bool
+```
+
+#### Example
+
+```go
+
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+	l.Add(4)
+	fmt.Println(l.getList())
+}
+
+```
+
+### AddAll
+
+Appends all the elements of the specified collection to the end of this list
+
+```go
+func (c *CopyOnWriteList[T]) AddAll(e []T) bool
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    l.AddAll([]int{4,5,6})
+    fmt.Println(l.getList())
+}
+
+```
+
+### AddByIndex
+
+Inserts the specified element into the list at the specified position.
+
+```go
+func (c *CopyOnWriteList[T]) AddByIndex(index int, e T) bool
+```
+
+#### Example
+
+```go
+package main
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.AddByIndex(2, 6)
+    fmt.Println(l.getList())
+}
+
+```
+
+### DeleteAt
+
+Removes the element at the specified position in this list.
+
+```go
+func (c *CopyOnWriteList[T]) DeleteAt(index int) (oldValue *T, ok bool)
+```
+
+#### Example
+
+```go
+package main
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.DeleteAt(2)
+    fmt.Println(l.getList())
+}
+```
+
+### DeleteIf
+
+Removes the first occurrence of the specified element from this list (if it exists).
+
+```go
+func (c *CopyOnWriteList[T]) DeleteIf(func(T) bool) (oldValue *T, ok bool)
+```
+
+#### Example
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.DeleteIf(func(i int) bool {
+        return i == 2
+    })
+    fmt.Println(l.getList())
+}
+```
+
+### DeleteBy
+
+Deletes the first occurrence of the specified element from this list (if it exists).
+
+```go
+func (c *CopyOnWriteList[T]) DeleteBy(e T) (*T bool)
+```
+
+#### Example
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.DeleteBy(2)
+    fmt.Println(l.getList())
+}
+```
+
+### DeleteRange
+
+Deletes all elements from this list with indexes between fromIndex (included) and toIndex (not included).
+(leftCloseRightOpen)
+
+```go
+func (c *CopyOnWriteList[T]) DeleteRange(start int, end int)
+```
+
+#### Example
+
+```go
+package main
+import (
+"fmt"
+"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3,4,5,6,7,8,9})
+    list.DeleteRange(2, 5)
+    fmt.Println(l.getList())
+}
+```
+
+### Equal
+
+Returns true if the specified object is equal to this list
+
+```go
+func (c *CopyOnWriteList[T]) Equal(e []T) bool
+```
+
+#### Example
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3,4,5,6,7,8,9})
+    fmt.Println(l.Equal([]int{1,2,3,4,5,6,7,8,9}))
+}
+```

docs/en/api/packages/datastructure/hashmap.md

@@ -32,6 +32,7 @@ import (
 - [Iterate](#Iterate)
 - [Keys](#Keys)
 - [Values](#Values)
+- [FilterByValue](#FilterByValue)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -39,7 +40,7 @@ import (
 
 ### <span id="NewHashMap">NewHashMap</span>
 
-<p>Make a HashMap instance with default capacity is 1 << 10.</p>
+<p>Make a HashMap instance with default capacity is 1 &lt&lt 10.</p>
 
 <b>Signature:</b>
 
@@ -311,4 +312,77 @@ func main() {
 }
 ```
 
+### <span id="FilterByValue">FilterByValue</span>
 
+<p>Returns a filtered HashMap.</p>
+
+<b>Signature:</b>
+
+```go
+func (hm *HashMap) FilterByValue(perdicate func(value any) bool) *HashMap
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+)
+
+func main() {
+    hm := hashmap.NewHashMap()
+
+    hm.Put("a", 1)
+    hm.Put("b", 2)
+    hm.Put("c", 3)
+    hm.Put("d", 4)
+    hm.Put("e", 5)
+    hm.Put("f", 6)
+
+    filteredHM := hm.FilterByValue(func(value any) bool {
+        return value.(int) == 1 || value.(int) == 3
+    })
+
+    fmt.Println(filteredHM.Size()) //2
+}
+```
+
+
+
+### <span id="ToInterface">ToInterface</span>
+
+<p>Converts reflect value to its interface type.</p>
+
+<b>Signature:</b>
+
+```go
+func ToInterface(v reflect.Value) (value interface{}, ok bool)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/syqw0-WG7Xd)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    val := reflect.ValueOf("abc")
+    iVal, ok := convertor.ToInterface(val)
+
+    fmt.Printf("%T\n", iVal)
+    fmt.Printf("%v\n", iVal)
+    fmt.Println(ok)
+
+    // Output:
+    // string
+    // abc
+    // true    
+}
+```

docs/en/api/packages/datastructure/heap.md

@@ -44,9 +44,9 @@ MaxHeap is a binary heap tree implemented by slice, The key of the root node is
 ```go
 type MaxHeap[T any] struct {
 	data       []T
-	comparator lancetconstraints.Comparator
+	comparator constraints.Comparator
 }
-func NewMaxHeap[T any](comparator lancetconstraints.Comparator) *MaxHeap[T]
+func NewMaxHeap[T any](comparator constraints.Comparator) *MaxHeap[T]
 ```
 <b>Example:</b>
 

docs/en/api/packages/datastructure/optional.md

@@ -0,0 +1,416 @@
+# Optional
+Optional is a type that may or may not contain a non-nil value.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source
+
+- [https://github.com/duke-git/lancet/blob/main/datastructure/optional/optional.go](https://github.com/duke-git/lancet/blob/main/datastructure/optional/optional.go)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage
+```go
+import (
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+
+- [Of](#Of)
+- [FromNillable](#FromNillable)
+- [Default](#Default)
+- [IsNotNil](#IsNotNil)
+- [IsNil](#IsNil)
+- [IsNotNil](#IsNotNil)
+- [IfNotNilOrElse](#IfNotNilOrElse)
+- [Umwarp](#Umwarp)
+- [OrElse](#OrElse)
+- [OrElseGet](#OrElseGet)
+- [OrElseTrigger](#OrElseTrigger)
+
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+### <span id="Of">Of</span>
+<p>Returns an Optional with a non-nil value.</p>
+
+<b>Signature:</b>
+
+```go
+func Of[T any](value T) Optional[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    value := 42
+    opt := optional.Of(value)
+
+    fmt.Println(opt.Get())
+
+    // Output:
+    // 42
+}
+```
+
+### <span id="FromNillable">FromNillable</span>
+<p>Returns an Optional for a given value, which may be nil.</p>
+
+<b>Signature:</b>
+
+```go
+func FromNillable[T any](value *T) Optional[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    var value *int = nil
+    opt := optional.FromNillable(value)
+
+    fmt.Println(opt.IsNotNil())
+
+    value = new(int)
+    *value = 42
+    opt = optional.FromNillable(value)
+
+    fmt.Println(opt.IsNotNil())
+
+
+    // Output:
+    // false
+    // true
+}
+```
+
+
+### <span id="Default">Default</span>
+<p>Returns an default Optional instance.</p>
+
+<b>Signature:</b>
+
+```go
+func Default[T any]() Optional[T]
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    optDefault := optional.Default[int]()
+    fmt.Println(optDefault.IsNil())
+
+    // Output:
+    // true
+}
+```
+
+
+### <span id="IsNil">IsNil</span>
+<p>Checks if the Optional is nil.</p>
+
+<b>Signature:</b>
+
+```go
+func (o Optional[T]) IsNil() bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    optDefault := optional.Default[int]()
+    fmt.Println(optDefault.IsNil())
+
+    // Output:
+    // true
+}
+```
+
+
+### <span id="IsNotNil">IsNotNil</span>
+<p>Checks if there is a value not nil.</p>
+
+<b>Signature:</b>
+
+```go
+func (o Optional[T]) IsNotNil() bool
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    var value *int = nil
+    opt := optional.FromNillable(value)
+
+    fmt.Println(opt.IsNotNil())
+
+    value = new(int)
+    *value = 42
+    opt = optional.FromNillable(value)
+
+    fmt.Println(opt.IsNotNil())
+
+
+    // Output:
+    // false
+    // true
+}
+```
+
+
+### <span id="IfNotNil">IfNotNil</span>
+<p>Performs the given action with the value if a value is present.</p>
+
+<b>Signature:</b>
+
+```go
+func (o Optional[T]) IfNotNil(action func(value T))
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+     "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    called := false
+    action := func(value int) { called = true }
+
+    optDefault := optional.Default[int]()
+    optDefault.IfNotNil(action)
+
+    fmt.Println(called)
+
+    called = false // Reset for next test
+    optWithValue := optional.Of(42)
+    optWithValue.IfNotNil(action)
+
+    fmt.Println(optWithValue.IsNotNil())
+
+    // Output:
+    // false
+    // true
+}
+```
+
+
+### <span id="IfNotNilOrElse">IfNotNilOrElse</span>
+<p>Performs the action with the value if not nil, otherwise performs the fallback action.</p>
+
+<b>Signature:</b>
+
+```go
+func (o Optional[T]) IfNotNilOrElse(action func(value T), fallbackAction func())
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    calledWithValue := false
+    valueAction := func(value int) { calledWithValue = true }
+    emptyAction := func() { t.Errorf("Empty action should not be called when value is present") }
+
+    optWithValue := optional.Of(42)
+    optWithValue.IfNotNilOrElse(valueAction, emptyAction)
+
+    fmt.Println(calledWithValue)
+
+    calledWithEmpty := false
+    valueAction = func(value int) { t.Errorf("Value action should not be called when value is not present") }
+    emptyAction = func() { calledWithEmpty = true }
+
+    optDefault := optional.Default[int]()
+    optDefault.IfNotNilOrElse(valueAction, emptyAction)
+
+    fmt.Println(calledWithEmpty)
+
+    // Output:
+    // true
+    // true
+}
+```
+
+### <span id="Unwrap">Unwrap</span>
+<p>Returns the value if not nil, otherwise panics.</p>
+
+<b>Signature:</b>
+
+```go
+func (o Optional[T]) Unwrap() T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    value := 42
+    opt := optional.Of(value)
+
+    fmt.Println(opt.Unwrap())
+
+    // Output:
+    // 42
+}
+```
+
+
+### <span id="OrElse">OrElse</span>
+<p>Returns the value if not nill, otherwise returns other.</p>
+
+<b>Signature:</b>
+
+```go
+func (o Optional[T]) OrElse(other T) T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    optDefault := optional.Default[int]()
+    val := optDefault.OrElse(100)
+    fmt.Println(val)
+
+    optWithValue := optional.Of(42)
+    val = optWithValue.OrElse(100)
+    fmt.Println(val)
+
+    // Output:
+    // 100
+    // 42
+}
+```
+
+
+### <span id="OrElseGet">OrElseGet</span>
+<p>Returns the value if not nil, otherwise invokes action and returns the result.</p>
+
+<b>Signature:</b>
+
+```go
+func (o Optional[T]) OrElseGet(action func() T) T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    optDefault := optional.Default[int]()
+    action := func() int { return 100 }
+
+    val := optDefault.OrElseGet(action)
+    fmt.Println(val)
+
+    // Output:
+    // 100
+}
+```
+
+
+### <span id="OrElseTrigger">OrElseTrigger</span>
+<p>Returns the value if present, otherwise returns an error.</p>
+
+<b>Signature:</b>
+
+```go
+ OrElseTrigger(errorHandler func() error) (T, error)
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datastructure/optional"
+)
+
+func main() {
+    optDefault := optional.Default[int]()
+    _, err := optDefault.OrElseTrigger(func() error { return errors.New("no value") })
+    
+    fmt.Println(err.Error())
+
+    optWithValue := optional.Of(42)
+    val, err := optWithValue.OrElseTrigger(func() error { return errors.New("no value") })
+
+    fmt.Println(val)
+    fmt.Println(err)
+
+    // Output:
+    // no value
+    // 42
+    // nil
+}
+```

docs/en/api/packages/datastructure/queue.md

@@ -1100,12 +1100,12 @@ Common queue implemented by slice.
 <b>Signature:</b>
 
 ```go
-func NewPriorityQueue[T any](capacity int, comparator lancetconstraints.Comparator) *PriorityQueue[T]
+func NewPriorityQueue[T any](capacity int, comparator constraints.Comparator) *PriorityQueue[T]
 
 type PriorityQueue[T any] struct {
 	items      []T
 	size       int
-	comparator lancetconstraints.Comparator
+	comparator constraints.Comparator
 }
 ```
 <b>Example:</b>

docs/en/api/packages/datastructure/set.md

@@ -22,8 +22,8 @@ import (
 
 ## Index
 
--   [NewSet](#NewSet)
--   [NewSetFromSlice](#NewSetFromSlice)
+-   [New](#New)
+-   [FromSlice](#FromSlice)
 -   [Values](#Values)
 -   [Add](#Add)
 -   [AddIfNotExist](#AddIfNotExist)
@@ -41,20 +41,23 @@ import (
 -   [Intersection](#Intersection)
 -   [SymmetricDifference](#SymmetricDifference)
 -   [Minus](#Minus)
+-   [Pop](#Pop)
+-   [ToSlice](#ToSlice)
+-   [ToSortedSlice](#ToSortedSlice)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Documentation
 
-### <span id="NewSet">NewSet</span>
+### <span id="New">New</span>
 
 <p>Create a set instance</p>
 
 <b>Signature:</b>
 
 ```go
-type Set[T comparable] map[T]bool
-func NewSet[T comparable](items ...T) Set[T]
+type Set[T comparable] map[T]struct{}
+func New[T comparable](items ...T) Set[T]
 ```
 
 <b>Example:</b>
@@ -68,19 +71,19 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int](1,2,2,3)
+    st := set.New[int](1,2,2,3)
     fmt.Println(st.Values()) //1,2,3
 }
 ```
 
-### <span id="NewSetFromSlice">NewSetFromSlice</span>
+### <span id="FromSlice">FromSlice</span>
 
 <p>Create a set from slice</p>
 
 <b>Signature:</b>
 
 ```go
-func NewSetFromSlice[T comparable](items []T) Set[T]
+func FromSlice[T comparable](items []T) Set[T]
 ```
 
 <b>Example:</b>
@@ -94,14 +97,15 @@ import (
 )
 
 func main() {
-    st := set.NewSetFromSlice([]int{1, 2, 2, 3})
+    st := set.FromSlice([]int{1, 2, 2, 3})
     fmt.Println(st.Values()) //1,2,3
 }
 ```
 
-### <span id="Values">Values</span>
+### <span id="Values">Values<sup>deprecated</sup></span>
 
-<p>Return slice of all set data</p>
+<p>Return slice of all set data.<br>
+    The <a href='#ToSlice'>ToSlice()</a> function provides the same functionality as Values and returns a slice containing all values of the set.</p>
 
 <b>Signature:</b>
 
@@ -120,7 +124,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int](1,2,2,3)
+    st := set.New[int](1,2,2,3)
     fmt.Println(st.Values()) //1,2,3
 }
 ```
@@ -146,7 +150,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2, 3)
 
     fmt.Println(st.Values()) //1,2,3
@@ -174,7 +178,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2, 3)
 
     r1 := st.AddIfNotExist(1)
@@ -207,7 +211,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2)
 
     ok := st.AddIfNotExistBy(3, func(val int) bool {
@@ -246,7 +250,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2, 3)
 
     set.Delete(3)
@@ -275,7 +279,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2, 3)
 
     fmt.Println(st.Contain(1)) //true
@@ -304,9 +308,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(1, 2)
-    set3 := set.NewSet(1, 2, 3, 4)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(1, 2)
+    set3 := set.New(1, 2, 3, 4)
 
     fmt.Println(set1.ContainAll(set2)) //true
     fmt.Println(set1.ContainAll(set3)) //false
@@ -334,7 +338,7 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
 
     fmt.Println(set1.Size()) //3
 }
@@ -361,7 +365,7 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
     set2 := set1.Clone()
 
     fmt.Println(set1.Size() == set2.Size()) //true
@@ -390,9 +394,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(1, 2, 3)
-    set3 := set.NewSet(1, 2, 3, 4)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(1, 2, 3)
+    set3 := set.New(1, 2, 3, 4)
 
     fmt.Println(set1.Equal(set2)) //true
     fmt.Println(set1.Equal(set3)) //false
@@ -420,7 +424,7 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
     arr := []int{}
     set.Iterate(func(item int) {
         arr = append(arr, item)
@@ -451,7 +455,7 @@ import (
 )
 
 func main() {
-    s := set.NewSet(1, 2, 3, 4, 5)
+    s := set.New(1, 2, 3, 4, 5)
 
     var sum int
 
@@ -488,8 +492,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet()
+    set1 := set.New(1, 2, 3)
+    set2 := set.New()
 
     fmt.Println(set1.IsEmpty()) //false
     fmt.Println(set2.IsEmpty()) //true
@@ -517,8 +521,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.Union(set2)
 
     fmt.Println(set3.Values()) //1,2,3,4,5
@@ -546,8 +550,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.Intersection(set2)
 
     fmt.Println(set3.Values()) //2,3
@@ -575,8 +579,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.SymmetricDifference(set2)
 
     fmt.Println(set3.Values()) //1,4,5
@@ -604,9 +608,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
-    set3 := set.NewSet(2, 3)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
+    set3 := set.New(2, 3)
 
     res1 := set1.Minus(set2)
     fmt.Println(res1.Values()) //1
@@ -637,7 +641,7 @@ import (
 )
 
 func main() {
-    s := set.NewSet[int]()
+    s := set.New[int]()
     s.Add(1)
     s.Add(2)
     s.Add(3)
@@ -648,3 +652,58 @@ func main() {
     fmt.Println(ok) // true
 }
 ```
+
+### <span id="ToSlice">ToSlice</span>
+
+<p>returns a slice containing all values of the set.</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) ToSlice() (v T, ok bool)
+```
+
+<b>Example:</b>
+
+```go
+func main() {
+    s := set.New(1, 2, 3, 4, 5)
+
+    val := s.ToSlice()
+    fmt.Println(val) // [2 3 4 5 1]
+}
+```
+
+### <span id="ToSortedSlice">ToSortedSlice</span>
+
+<p>returns a sorted slice containing all values of the set</p>
+
+<b>Signature:</b>
+
+```go
+func (s Set[T]) ToSortedSlice() (v T, ok bool)
+```
+
+<b>Example:</b>
+
+```go
+func main() {
+    s1 := set.New(1, 2, 3, 4, 5)
+    type Person struct {
+		Name string
+		Age  int
+	}
+	s2 := FromSlice([]Person{{"Tom", 20}, {"Jerry", 18}, {"Spike", 25}})
+
+    res1 := s1.ToSortedSlice(func(v1, v2 int) bool {
+		return v1 < v2
+	})
+    
+    res2 := s2.ToSortedSlice(func(v1, v2 Person) bool {
+		return v1.Age < v2.Age
+	})
+    
+    fmt.Println(res1) // [1 2 3 4 5]
+    fmt.Println(res2) // [{Jerry 18} {Tom 20} {Spike 25}]
+}
+```

docs/en/api/packages/datastructure/tree.md

@@ -41,7 +41,7 @@ import (
 ## 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.
+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 constraints.Comparator interface.
 
 ### <span id="NewBSTree">NewBSTree</span>
 <p>Make a BSTree pointer instance</p>
@@ -49,11 +49,11 @@ BSTree is a binary search tree data structure in which each node has at two chil
 <b>Signature:</b>
 
 ```go
-func NewBSTree[T any](rootData T, comparator lancetconstraints.Comparator) *BSTree[T]
+func NewBSTree[T any](rootData T, comparator constraints.Comparator) *BSTree[T]
 
 type BSTree[T any] struct {
 	root       *datastructure.TreeNode[T]
-	comparator lancetconstraints.Comparator
+	comparator constraints.Comparator
 }
 
 type TreeNode[T any] struct {

docs/en/api/packages/datetime.md

@@ -107,7 +107,7 @@ import (
 func AddDay(t time.Time, day int64) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/dIGbs_uTdFa)</span></b>
 
 ```go
 package main
@@ -146,7 +146,7 @@ func main() {
 func AddHour(t time.Time, hour int64) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/rcMjd7OCsi5)</span></b>
 
 ```go
 package main
@@ -185,7 +185,7 @@ func main() {
 func AddMinute(t time.Time, minute int64) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nT1heB1KUUK)</span></b>
 
 ```go
 package main
@@ -224,7 +224,7 @@ func main() {
 func AddYear(t time.Time, year int64) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/MqW2ujnBx10)</span></b>
 
 ```go
 package main
@@ -263,7 +263,7 @@ func main() {
 func BeginOfMinute(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ieOLVJ9CiFT)</span></b>
 
 ```go
 package main
@@ -295,7 +295,7 @@ func main() {
 func BeginOfHour(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/GhdGFnDWpYs)</span></b>
 
 ```go
 package main
@@ -327,7 +327,7 @@ func main() {
 func BeginOfDay(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/94m_UT6cWs9)</span></b>
 
 ```go
 package main
@@ -359,7 +359,7 @@ func main() {
 func BeginOfWeek(t time.Time, beginFrom ...time.Weekday) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ynjoJPz7VNV)</span></b>
 
 ```go
 package main
@@ -391,7 +391,7 @@ func main() {
 func BeginOfMonth(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/bWXVFsmmzwL)</span></b>
 
 ```go
 package main
@@ -423,7 +423,7 @@ func main() {
 func BeginOfYear(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/i326DSwLnV8)</span></b>
 
 ```go
 package main
@@ -455,7 +455,7 @@ func main() {
 func EndOfMinute(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/yrL5wGzPj4z)</span></b>
 
 ```go
 package main
@@ -487,7 +487,7 @@ func main() {
 func EndOfHour(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/6ce3j_6cVqN)</span></b>
 
 ```go
 package main
@@ -519,7 +519,7 @@ func main() {
 func EndOfDay(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/eMBOvmq5Ih1)</span></b>
 
 ```go
 package main
@@ -551,7 +551,7 @@ func main() {
 func EndOfWeek(t time.Time, endWith ...time.Weekday) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/i08qKXD9flf)</span></b>
 
 ```go
 package main
@@ -583,7 +583,7 @@ func main() {
 func EndOfMonth(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_GWh10B3Nqi)</span></b>
 
 ```go
 package main
@@ -615,7 +615,7 @@ func main() {
 func EndOfYear(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/G01cKlMCvNm)</span></b>
 
 ```go
 package main
@@ -647,7 +647,7 @@ func main() {
 func GetNowDate() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/PvfkPpcpBBf)</span></b>
 
 ```go
 package main
@@ -676,7 +676,7 @@ func main() {
 func GetNowTime() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/l7BNxCkTmJS)</span></b>
 
 ```go
 package main
@@ -705,7 +705,7 @@ func main() {
 func GetNowDateTime() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/pI4AqngD0al)</span></b>
 
 ```go
 package main
@@ -734,7 +734,7 @@ func main() {
 func GetTodayStartTime() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/84siyYF7t99)</span></b>
 
 ```go
 package main
@@ -763,7 +763,7 @@ func main() {
 func GetTodayEndTime() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jjrLnfoqgn3)</span></b>
 
 ```go
 package main
@@ -792,7 +792,7 @@ func main() {
 func GetZeroHourTimestamp() int64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/QmL2oIaGE3q)</span></b>
 
 ```go
 package main
@@ -821,7 +821,7 @@ func main() {
 func GetNightTimestamp() int64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/UolysR3MYP1)</span></b>
 
 ```go
 package main
@@ -850,7 +850,7 @@ func main() {
 func FormatTimeToStr(t time.Time, format string, timezone ...string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_Ia7M8H_OvE)</span></b>
 
 ```go
 package main
@@ -889,7 +889,7 @@ func main() {
 func FormatStrToTime(str, format string, timezone ...string) (time.Time, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/1h9FwdU8ql4)</span></b>
 
 ```go
 package main
@@ -928,7 +928,7 @@ type theTime struct {
 func NewUnixNow() *theTime
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/U4PPx-9D0oz)</span></b>
 
 ```go
 package main
@@ -960,7 +960,7 @@ type theTime struct {
 func NewUnix(unix int64) *theTime
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/psoSuh_kLRt)</span></b>
 
 ```go
 package main
@@ -992,7 +992,7 @@ type theTime struct {
 func NewFormat(t string) (*theTime, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/VkW08ZOaXPZ)</span></b>
 
 ```go
 package main
@@ -1024,7 +1024,7 @@ type theTime struct {
 func NewISO8601(iso8601 string) (*theTime, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/mkhOHQkdeA2)</span></b>
 
 ```go
 package main
@@ -1053,7 +1053,7 @@ func main() {
 func (t *theTime) ToUnix() int64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_LUiwAdocjy)</span></b>
 
 ```go
 package main
@@ -1082,7 +1082,7 @@ func main() {
 func (t *theTime) ToFormat() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/VkW08ZOaXPZ)</span></b>
 
 ```go
 package main
@@ -1111,7 +1111,7 @@ func main() {
 func (t *theTime) ToFormatForTpl(tpl string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nyXxXcQJ8L5)</span></b>
 
 ```go
 package main
@@ -1141,7 +1141,7 @@ func main() {
 func (t *theTime) ToIso8601() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/mkhOHQkdeA2)</span></b>
 
 ```go
 package main
@@ -1171,7 +1171,7 @@ func main() {
 func IsLeapYear(year int) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/xS1eS2ejGew)</span></b>
 
 ```go
 package main
@@ -1204,7 +1204,7 @@ func main() {
 func BetweenSeconds(t1 time.Time, t2 time.Time) int64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/n3YDRyfyXJu)</span></b>
 
 ```go
 package main
@@ -1241,7 +1241,7 @@ func main() {
 func DayOfYear(t time.Time) int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/0hjqhTwFNlH)</span></b>
 
 ```go
 package main
@@ -1282,7 +1282,7 @@ func main() {
 func IsWeekend(t time.Time) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/cupRM5aZOIY)</span></b>
 
 ```go
 package main
@@ -1322,7 +1322,7 @@ func main() {
 func NowDateOrTime(format string, timezone ...string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/EZ-begEjtT0)</span></b>
 
 ```go
 package main
@@ -1356,7 +1356,7 @@ func main() {
 func Timestamp(timezone ...string) int64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/iU5b7Vvjx6x)</span></b>
 
 ```go
 package main
@@ -1376,7 +1376,6 @@ func main() {
 }
 ```
 
-
 ### <span id="TimestampMilli">TimestampMilli</span>
 
 <p>Return current mill second timestamp.</p>
@@ -1387,7 +1386,7 @@ func main() {
 func TimestampMilli(timezone ...string) int64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4gvEusOTu1T)</span></b>
 
 ```go
 package main
@@ -1417,7 +1416,7 @@ func main() {
 func TimestampMicro(timezone ...string) int64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/2maANglKHQE)</span></b>
 
 ```go
 package main
@@ -1447,7 +1446,7 @@ func main() {
 func TimestampNano(timezone ...string) int64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/A9Oq_COrcCF)</span></b>
 
 ```go
 package main

docs/en/api/packages/fileutil.md

@@ -26,6 +26,7 @@ import (
 -   [CreateFile](#CreateFile)
 -   [CreateDir](#CreateDir)
 -   [CopyFile](#CopyFile)
+-   [CopyDir](#CopyDir)
 -   [CurrentPath](#CurrentPath)
 -   [FileMode](#FileMode)
 -   [MiMeType](#MiMeType)
@@ -45,8 +46,12 @@ import (
 -   [Sha](#Sha)
 -   [ReadCsvFile](#ReadCsvFile)
 -   [WriteCsvFile](#WriteCsvFile)
+-   [WriteMapsToCsv](#WriteMapsToCsv)
 -   [WriteStringToFile](#WriteStringToFile)
 -   [WriteBytesToFile](#WriteBytesToFile)
+-   [ReadFile](#ReadFile)
+-   [ChunkRead](#ChunkRead)
+-   [ParallelChunkRead](#ParallelChunkRead)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -62,7 +67,7 @@ import (
 func ClearFile(path string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/NRZ0ZT-G94H)</span></b>
 
 ```go
 package main
@@ -90,7 +95,7 @@ func main() {
 func CreateFile(path string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/lDt8PEsTNKI)</span></b>
 
 ```go
 package main
@@ -116,7 +121,7 @@ func main() {
 func CreateDir(absPath string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/qUuCe1OGQnM)</span></b>
 
 ```go
 package main
@@ -142,7 +147,7 @@ func main() {
 func CopyFile(srcPath string, dstPath string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Jg9AMJMLrJi)</span></b>
 
 ```go
 package main
@@ -160,6 +165,34 @@ func main() {
 }
 ```
 
+### <span id="CopyDir">CopyDir</span>
+
+<p>Copy	src directory to dst directory, it will copy all files and directories recursively. the access permission will be the same as the source directory. if dstPath exists, it will return an error.</p>
+
+<b>Signature:</b>
+
+```go
+func CopyDir(srcPath string, dstPath string) error
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/YAyFTA_UuPb)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    err := fileutil.CopyFile("./test_src", "./test_dest")
+    if err != nil {
+        fmt.Println(err)
+    }
+}
+```
+
 ### <span id="CurrentPath">CurrentPath</span>
 
 <p>return current absolute path.</p>
@@ -170,7 +203,7 @@ func main() {
 func CurrentPath() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/s74a9iBGcSw)</span></b>
 
 ```go
 package main
@@ -196,7 +229,7 @@ func main() {
 func FileMode(path string) (fs.FileMode, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/2l2hI42fA3p)</span></b>
 
 ```go
 package main
@@ -225,7 +258,7 @@ func main() {
 func MiMeType(file any) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/bd5sevSUZNu)</span></b>
 
 ```go
 package main
@@ -256,7 +289,7 @@ func main() {
 func IsExist(path string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nKKXt8ZQbmh)</span></b>
 
 ```go
 package main
@@ -283,7 +316,7 @@ func main() {
 func IsLink(path string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/TL-b-Kzvf44)</span></b>
 
 ```go
 package main
@@ -309,7 +342,7 @@ func main() {
 func IsDir(path string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/WkVwEKqtOWk)</span></b>
 
 ```go
 package main
@@ -338,7 +371,7 @@ func main() {
 func ListFileNames(path string) ([]string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Tjd7Y07rejl)</span></b>
 
 ```go
 package main
@@ -364,7 +397,7 @@ func main() {
 func RemoveFile(path string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/P2y0XW8a1SH)</span></b>
 
 ```go
 package main
@@ -392,7 +425,7 @@ func main() {
 func ReadFileToString(path string) (string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/cmfwp_5SQTp)</span></b>
 
 ```go
 package main
@@ -425,7 +458,7 @@ func main() {
 func ReadFileByLine(path string)([]string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/svJP_7ZrBrD)</span></b>
 
 ```go
 package main
@@ -459,7 +492,7 @@ func main() {
 func Zip(fpath string, destPath string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/j-3sWBp8ik_P)</span></b>
 
 ```go
 package main
@@ -487,7 +520,7 @@ func main() {
 func ZipAppendEntry(fpath string, destPath string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/cxvaT8TRNQp)</span></b>
 
 ```go
 package main
@@ -515,7 +548,7 @@ func main() {
 func UnZip(zipFile string, destPath string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/g0w34kS7B8m)</span></b>
 
 ```go
 package main
@@ -543,7 +576,7 @@ func main() {
 func IsZipFile(filepath string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9M0g2j_uF_e)</span></b>
 
 ```go
 package main
@@ -569,7 +602,7 @@ func main() {
 func FileSize(path string) (int64, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/H9Z05uD-Jjc)</span></b>
 
 ```go
 package main
@@ -601,7 +634,7 @@ func main() {
 func MTime(filepath string) (int64, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/s_Tl7lZoAaY)</span></b>
 
 ```go
 package main
@@ -633,7 +666,7 @@ func main() {
 func Sha(filepath string, shaType ...int) (string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/VfEEcO2MJYf)</span></b>
 
 ```go
 package main
@@ -668,10 +701,10 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func ReadCsvFile(filepath string) ([][]string, error)
+func ReadCsvFile(filepath string, delimiter ...rune) ([][]string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/OExTkhGEd3_u)</span></b>
 
 ```go
 package main
@@ -700,10 +733,10 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func WriteCsvFile(filepath string, records [][]string, append bool) error
+func WriteCsvFile(filepath string, records [][]string, append bool, delimiter ...rune) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/dAXm58Q5U1o)</span></b>
 
 ```go
 package main
@@ -742,6 +775,59 @@ func main() {
 }
 ```
 
+### <span id="WriteMapsToCsv">WriteMapsToCsv</span>
+
+<p>Write slice of map to csv file.</p>
+
+<b>Signature:</b>
+
+```go
+// filepath: path of the CSV file.
+// records: slice of maps to be written. the value of map should be basic type. The maps will be sorted by key in alphabeta order, then be written into csv file.
+// appendToExistingFile: If true, data will be appended to the file if it exists.
+// delimiter: Delimiter to use in the CSV file.
+// headers: order of the csv column headers, needs to be consistent with the key of the map.
+func WriteMapsToCsv(filepath string, records []map[string]any, appendToExistingFile bool, delimiter rune, headers ...[]string) error
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/umAIomZFV1c)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    fpath := "./test.csv"
+    fileutil.CreateFile(fpath)
+
+    f, _ := os.OpenFile(fpath, os.O_WRONLY|os.O_TRUNC, 0777)
+    defer f.Close()
+
+    records := []map[string]any{
+        {"Name": "Lili", "Age": "22", "Gender": "female"},
+        {"Name": "Jim", "Age": "21", "Gender": "male"},
+    }
+
+    headers := []string{"Name", "Age", "Gender"}
+    err := fileutil.WriteMapsToCsv(csvFilePath, records, false, ';', headers)
+
+    if err != nil {
+        log.Fatal(err)
+    }
+
+    content, err := fileutil.ReadCsvFile(csvFilePath, ';')
+
+    fmt.Println(content)
+
+    // Output:
+    // [[Name Age Gender] [Lili 22 female] [Jim 21 male]]
+}
+```
+
 ### <span id="WriteBytesToFile">WriteBytesToFile</span>
 
 <p>Writes bytes to target file.</p>
@@ -752,7 +838,7 @@ func main() {
 func WriteBytesToFile(filepath string, content []byte) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/s7QlDxMj3P8)</span></b>
 
 ```go
 package main
@@ -801,7 +887,7 @@ func main() {
 func WriteStringToFile(filepath string, content string, append bool) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/GhLS6d8lH_g)</span></b>
 
 ```go
 package main
@@ -839,3 +925,153 @@ func main() {
     // hello
 }
 ```
+
+### <span id="ReadFile">ReadFile</span>
+
+<p>Read File or URL.</p>
+
+<b>Signature:</b>
+
+```go
+func ReadFile(path string) (reader io.ReadCloser, closeFn func(), err error) 
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uNep3Tr8fqF)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    reader, fn, err := fileutil.ReadFile("https://httpbin.org/robots.txt")
+    if err != nil {
+        return
+    }
+    defer fn()
+
+    dat, err := io.ReadAll(reader)
+    if err != nil {
+        return
+    }
+    fmt.Println(string(dat))
+    // Output:
+    // User-agent: *
+    // Disallow: /deny
+}
+```
+
+### <span id="ChunkRead">ChunkRead</span>
+
+<p>reads a block from the file at the specified offset and returns all lines within the block.</p>
+
+<b>Signature :</b>
+
+```go
+func ChunkRead(file *os.File, offset int64, size int, bufPool *sync.Pool) ([]string, error)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/r0hPmKWhsgf)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    const mb = 1024 * 1024
+    const defaultChunkSizeMB = 100 
+
+    // test1.csv file content:
+    // Lili,22,female
+    // Jim,21,male
+    filePath := "./testdata/test1.csv"
+    f, err := os.Open(filePath)
+    if err != nil {
+        return
+    }
+
+    defer f.Close()
+
+    var bufPool = sync.Pool{
+        New: func() interface{} {
+            return make([]byte, 0, defaultChunkSizeMB*mb)
+        },
+    }
+
+    lines, err := fileutil.ChunkRead(f, 0, 100, &bufPool)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(lines[0])
+    fmt.Println(lines[1])
+
+    // Output:
+    // Lili,22,female
+    // Jim,21,male
+}
+```
+
+### <span id="ParallelChunkRead">ParallelChunkRead</span>
+
+<p>Reads the file in parallel and send each chunk of lines to the specified channel.</p>
+
+<b>Signature :</b>
+
+```go
+// filePath: file path.
+// chunkSizeMB: The size of the block (in MB, the default is 100MB when set to 0). Setting it too large will be detrimental. Adjust it as appropriate.
+// maxGoroutine: The number of concurrent read chunks, the number of CPU cores used when set to 0.
+// linesCh: The channel used to receive the returned results.
+func ParallelChunkRead(filePath string, linesCh chan<- []string, chunkSizeMB, maxGoroutine int) error
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/teMXnCsdSEw)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    const mb = 1024 * 1024
+    const defaultChunkSizeMB = 100 // 默认值
+
+    numParsers := runtime.NumCPU()
+
+    linesCh := make(chan []string, numParsers)
+    
+    // test1.csv file content:
+    // Lili,22,female
+    // Jim,21,male
+    filePath := "./testdata/test1.csv"
+
+    go fileutil.ParallelChunkRead(filePath, linesCh, defaultChunkSizeMB, numParsers)
+
+    var totalLines int
+    for lines := range linesCh {
+        totalLines += len(lines)
+
+        for _, line := range lines {
+            fmt.Println(line)
+        }
+    }
+
+    fmt.Println(totalLines)
+
+    // Output:
+    // Lili,22,female
+    // Jim,21,male
+    // 2
+}
+```

docs/en/api/packages/formatter.md

@@ -45,7 +45,7 @@ import (
 func Comma[T constraints.Float | constraints.Integer | string](value T, symbol string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/eRD5k2vzUVX)</span></b>
 
 ```go
 package main
@@ -81,7 +81,7 @@ func main() {
 func Pretty(v any) (string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/YsciGj3FH2x)</span></b>
 
 ```go
 package main
@@ -120,7 +120,7 @@ func main() {
 func PrettyToWriter(v any, out io.Writer) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/LPLZ3lDi5ma)</span></b>
 
 ```go
 package main
@@ -163,7 +163,7 @@ func main() {
 func DecimalBytes(size float64, precision ...int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/FPXs1suwRcs)</span></b>
 
 ```go
 package main
@@ -202,7 +202,7 @@ func main() {
 func BinaryBytes(size float64, precision ...int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/G9oHHMCAZxP)</span></b>
 
 ```go
 package main
@@ -241,7 +241,7 @@ func main() {
 func ParseDecimalBytes(size string) (uint64, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Am98ybWjvjj)</span></b>
 
 ```go
 package main
@@ -280,7 +280,7 @@ func main() {
 func ParseBinaryBytes(size string) (uint64, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/69v1tTT62x8)</span></b>
 
 ```go
 package main

docs/en/api/packages/function.md

@@ -0,0 +1,693 @@
+# Function
+
+Package function can control the flow of function execution and support part of functional programming.
+
+<div STYLE="page-break-after: always;"></div>
+
+## 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/predicate.go](https://github.com/duke-git/lancet/blob/main/function/predicate.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/v2/function"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+
+-   [After](#After)
+-   [Before](#Before)
+-   [CurryFn](#CurryFn)
+-   [Compose](#Compose)
+-   [Debounced](#Debounced)
+-   [Delay](#Delay)
+-   [Schedule](#Schedule)
+-   [Pipeline](#Pipeline)
+-   [Watcher](#Watcher)
+-   [And](#And)
+-   [Or](#Or)
+-   [Negate](#Negate)
+-   [Nor](#Nor)
+-   [Xnor](#Xnor)
+-   [Nand](#Nand)
+-   [AcceptIf](#AcceptIf)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+### <span id="After">After</span>
+
+<p>Creates a function that invokes given func once it's called n or more times.</p>
+
+<b>Signature:</b>
+
+```go
+func After(n int, fn any) func(args ...any) []reflect.Value
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/eRD5k2vzUVX)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    fn := function.After(2, func() {
+        fmt.Println("hello")
+    })
+
+    fn()
+    fn()
+
+    // Output:
+    // hello
+}
+```
+
+### <span id="Before">Before</span>
+
+<p>creates a function that invokes func once it's called less than n times.</p>
+
+<b>Signature:</b>
+
+```go
+func Before(n int, fn any) func(args ...any) []reflect.Value
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/0HqUDIFZ3IL)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    fn := function.Before(2, func() {
+        fmt.Println("hello")
+    })
+
+    fn()
+    fn()
+    fn()
+    fn()
+
+    // Output:
+    // hello
+    // hello
+}
+```
+
+### <span id="CurryFn">CurryFn</span>
+
+<p>Make curry function.</p>
+
+<b>Signature:</b>
+
+```go
+type CurryFn[T any] func(...T) T
+func (cf CurryFn[T]) New(val T) func(...T) T
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/5HopfDwANKX)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    add := func(a, b int) int {
+        return a + b
+    }
+
+    var addCurry function.CurryFn[int] = func(values ...int) int {
+        return add(values[0], values[1])
+    }
+    add1 := addCurry.New(1)
+
+    result := add1(2)
+
+    fmt.Println(result)
+
+    // Output:
+    // 3
+}
+```
+
+### <span id="Compose">Compose</span>
+
+<p>Compose the function list from right to left, then return the composed function.</p>
+
+<b>Signature:</b>
+
+```go
+func Compose[T any](fnList ...func(...T) T) func(...T) T
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/KKfugD4PKYF)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    toUpper := func(strs ...string) string {
+        return strings.ToUpper(strs[0])
+    }
+    toLower := func(strs ...string) string {
+        return strings.ToLower(strs[0])
+    }
+    transform := function.Compose(toUpper, toLower)
+
+    result := transform("aBCde")
+
+    fmt.Println(result)
+
+    // Output:
+    // ABCDE
+}
+```
+
+### <span id="Debounced">Debounced</span>
+
+<p>Creates a debounced function that delays invoking fn until after wait duration have elapsed since the last time the debounced function was invoked.</p>
+
+<b>Signature:</b>
+
+```go
+func Debounced(fn func(), duration time.Duration) func()
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/absuEGB_GN7)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    count := 0
+
+    add := func() {
+        count++
+    }
+
+    debouncedAdd := function.Debounced(add, 50*time.Microsecond)
+
+    debouncedAdd()
+    debouncedAdd()
+    debouncedAdd()
+    debouncedAdd()
+
+    time.Sleep(100 * time.Millisecond)
+
+    fmt.Println(count)
+
+    debouncedAdd()
+
+    time.Sleep(100 * time.Millisecond)
+
+    fmt.Println(count)
+
+    // Output:
+    // 1
+    // 2
+}
+```
+
+### <span id="Delay">Delay</span>
+
+<p>Invoke function after delayed time.</p>
+
+<b>Signature:</b>
+
+```go
+func Delay(delay time.Duration, fn any, args ...any)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Ivtc2ZE-Tye)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    var print = func(s string) {
+        fmt.Println(s)
+    }
+
+    function.Delay(2*time.Second, print, "hello")
+
+    // Output:
+    // hello
+}
+```
+
+### <span id="Schedule">Schedule</span>
+
+<p>Invoke function every duration time, until close the returned bool chan.</p>
+
+<b>Signature:</b>
+
+```go
+func Schedule(d time.Duration, fn any, args ...any) chan bool
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/hbON-Xeyn5N)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    count := 0
+
+    increase := func() {
+        count++
+    }
+
+    stop := function.Schedule(2*time.Second, increase)
+
+    time.Sleep(2 * time.Second)
+    close(stop)
+
+    fmt.Println(count)
+
+    // Output:
+    // 2
+}
+```
+
+### <span id="Pipeline">Pipeline</span>
+
+<p>Pipeline takes a list of functions and returns a function whose param will be passed into
+the functions one by one.</p>
+
+<b>Signature:</b>
+
+```go
+func Pipeline[T any](funcs ...func(T) T) func(T) T
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/mPdUVvj6HD6)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    addOne := func(x int) int {
+        return x + 1
+    }
+    double := func(x int) int {
+        return 2 * x
+    }
+    square := func(x int) int {
+        return x * x
+    }
+
+    fn := function.Pipeline(addOne, double, square)
+
+    result := fn(2)
+
+    fmt.Println(result)
+
+    // Output:
+    // 36
+}
+```
+
+### <span id="Watcher">Watcher</span>
+
+<p>Watcher is used for record code excution time. can start/stop/reset the watch timer. get the elapsed time of function execution.</p>
+
+<b>Signature:</b>
+
+```go
+type Watcher struct {
+    startTime int64
+    stopTime  int64
+    excuting  bool
+}
+func NewWatcher() *Watcher
+func (w *Watcher) Start() //start the watcher
+func (w *Watcher) Stop() //stop the watcher
+func (w *Watcher) Reset() //reset the watcher
+func (w *Watcher) GetElapsedTime() time.Duration //get the elapsed time of function execution
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/l2yrOpCLd1I)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    w := function.NewWatcher()
+
+    w.Start()
+
+    longRunningTask()
+
+    fmt.Println(w.excuting) //true
+
+    w.Stop()
+
+    eapsedTime := w.GetElapsedTime().Milliseconds()
+
+    fmt.Println(eapsedTime)
+
+    w.Reset()
+}
+
+func longRunningTask() {
+    var slice []int64
+    for i := 0; i < 10000000; i++ {
+        slice = append(slice, int64(i))
+    }
+}
+
+```
+
+
+### <span id="And">And</span>
+
+<p>Returns a composed predicate that represents the logical AND of a list of predicates. It evaluates to true only if all predicates evaluate to true for the given value.</p>
+
+<b>Signature:</b>
+
+```go
+func And[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/dTBHJMQ0zD2)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    isNumericAndLength5 := function.And(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return len(s) == 5 },
+    )
+
+    fmt.Println(isNumericAndLength5("12345"))
+    fmt.Println(isNumericAndLength5("1234"))
+    fmt.Println(isNumericAndLength5("abcde"))
+
+    // Output:
+    // true
+    // false
+    // false
+}
+```
+
+### <span id="Or">Or</span>
+
+<p>Returns a composed predicate that represents the logical OR of a list of predicates. It evaluates to true if at least one of the predicates evaluates to true for the given value.</p>
+
+<b>Signature:</b>
+
+```go
+func Or[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/LitCIsDFNDA)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    containsDigitOrSpecialChar := function.Or(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return strings.ContainsAny(s, "!@#$%") },
+    )
+
+    fmt.Println(containsDigitOrSpecialChar("hello!"))
+    fmt.Println(containsDigitOrSpecialChar("hello"))
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="Negate">Negate</span>
+
+<p>Returns a predicate that represents the logical negation of this predicate.</p>
+
+<b>Signature:</b>
+
+```go
+func Negate[T any](predicate func(T) bool) func(T) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jbI8BtgFnVE)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    // Define some simple predicates for demonstration
+    isUpperCase := func(s string) bool {
+        return strings.ToUpper(s) == s
+    }
+    isLowerCase := func(s string) bool {
+        return strings.ToLower(s) == s
+    }
+    isMixedCase := function.Negate(function.Or(isUpperCase, isLowerCase))
+
+    fmt.Println(isMixedCase("ABC"))
+    fmt.Println(isMixedCase("AbC"))
+
+    // Output:
+    // false
+    // true
+}
+```
+
+
+### <span id="Nor">Nor</span>
+
+<p>Returns a composed predicate that represents the logical NOR of a list of predicates. It evaluates to true only if all predicates evaluate to false for the given value.</p>
+
+<b>Signature:</b>
+
+```go
+func Nor[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/2KdCoBEOq84)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    match := function.Nor(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return len(s) == 5 },
+    )
+
+    fmt.Println(match("dbcdckkeee"))
+
+
+    match = function.Nor(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return len(s) == 5 },
+    )
+
+    fmt.Println(match("0123456789"))
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="Nand">Nand</span>
+
+<p>Returns a composed predicate that represents the logical NAND of a list of predicates. It evaluates to true only if all predicates evaluate to false for the given value.</p>
+
+<b>Signature:</b>
+
+```go
+func Nand[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Rb-FdNGpgSO)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    isNumericAndLength5 := function.Nand(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return len(s) == 5 },
+    )
+
+    fmt.Println(isNumericAndLength5("12345"))
+    fmt.Println(isNumericAndLength5("1234"))
+    fmt.Println(isNumericAndLength5("abcdef"))
+
+    // Output:
+    // false
+    // false
+    // true
+}
+```
+
+### <span id="Xnor">Xnor</span>
+
+<p>Returns a composed predicate that represents the logical XNOR of a list of predicates. It evaluates to true only if all predicates evaluate to true or false for the given value.</p>
+
+<b>Signature:</b>
+
+```go
+func Xnor[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/FJxko8SFbqc)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    isEven := func(i int) bool { return i%2 == 0 }
+    isPositive := func(i int) bool { return i > 0 }
+
+    match := function.Xnor(isEven, isPositive)
+
+    fmt.Println(match(2))
+    fmt.Println(match(-3))
+    fmt.Println(match(3))
+
+    // Output:
+    // true
+    // true
+    // false
+}
+```
+
+### <span id="AcceptIf">AcceptIf</span>
+
+<p>AcceptIf returns another function of the same signature as the apply function but also includes a bool value to indicate success or failure. A predicate function that takes an argument of type T and returns a bool. An apply function that also takes an argument of type T and returns a modified value of the same type.</p>
+
+<b>Signature:</b>
+
+```go
+func AcceptIf[T any](predicate func(T) bool, apply func(T) T) func(T) (T, bool)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/XlXHHtzCf7d)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+
+    adder := function.AcceptIf(
+        function.And(
+            func(x int) bool {
+                return x > 10
+            }, func(x int) bool {
+                return x%2 == 0
+            }),
+        func(x int) int {
+            return x + 1
+        },
+    )
+
+    result, ok := adder(20)
+    fmt.Println(result)
+    fmt.Println(ok)
+
+    result, ok = adder(21)
+    fmt.Println(result)
+    fmt.Println(ok)
+
+    // Output:
+    // 21
+    // true
+    // 0
+    // false
+}
+
+```

docs/en/api/packages/maputil.md

@@ -44,6 +44,8 @@ import (
 -   [Minus](#Minus)
 -   [IsDisjoint](#IsDisjoint)
 -   [HasKey](#HasKey)
+-   [ToSortedSlicesDefault](#ToSortedSlicesDefault)
+-   [ToSortedSlicesWithComparator](#ToSortedSlicesWithComparator)
 -   [NewConcurrentMap](#NewConcurrentMap)
 -   [ConcurrentMap_Get](#ConcurrentMap_Get)
 -   [ConcurrentMap_Set](#ConcurrentMap_Set)
@@ -67,7 +69,7 @@ import (
 func MapTo(src any, dst any) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4K7KBEPgS5M)</span></b>
 
 ```go
 package main
@@ -124,7 +126,7 @@ func main() {
 func ForEach[K comparable, V any](m map[K]V, iteratee func(key K, value V))
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/OaThj6iNVXK)</span></b>
 
 ```go
 package main
@@ -165,7 +167,7 @@ func main() {
 func Filter[K comparable, V any](m map[K]V, predicate func(key K, value V) bool) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/fSvF3wxuNG7)</span></b>
 
 ```go
 package main
@@ -210,7 +212,7 @@ func main() {
 func FilterByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/7ov6BJHbVqh)</span></b>
 
 ```go
 package main
@@ -248,7 +250,7 @@ func main() {
 func FilterByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/P3-9MdcXegR)</span></b>
 
 ```go
 package main
@@ -286,7 +288,7 @@ func main() {
 func OmitBy[K comparable, V any](m map[K]V, predicate func(key K, value V) bool) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/YJM4Hj5hNwm)</span></b>
 
 ```go
 package main
@@ -327,7 +329,7 @@ func main() {
 func OmitByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jXGrWDBfSRp)</span></b>
 
 ```go
 package main
@@ -365,7 +367,7 @@ func main() {
 func OmitByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/XB7Y10uw20_U)</span></b>
 
 ```go
 package main
@@ -403,7 +405,7 @@ func main() {
 func Intersect[K comparable, V any](maps ...map[K]V) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Zld0oj3sjcC)</span></b>
 
 ```go
 package main
@@ -458,7 +460,7 @@ func main() {
 func Keys[K comparable, V any](m map[K]V) []K
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/xNB5bTb97Wd)</span></b>
 
 ```go
 package main
@@ -498,7 +500,7 @@ func main() {
 func Merge[K comparable, V any](maps ...map[K]V) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/H95LENF1uB-)</span></b>
 
 ```go
 package main
@@ -537,7 +539,7 @@ func main() {
 func Minus[K comparable, V any](mapA, mapB map[K]V) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/3u5U9K7YZ9m)</span></b>
 
 ```go
 package main
@@ -579,7 +581,7 @@ func main() {
 func Values[K comparable, V any](m map[K]V) []V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/CBKdUc5FTW6)</span></b>
 
 ```go
 package main
@@ -619,7 +621,7 @@ func main() {
 func KeysBy[K comparable, V any, T any](m map[K]V, mapper func(item K) T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/hI371iB8Up8)</span></b>
 
 ```go
 package main
@@ -660,7 +662,7 @@ func main() {
 func ValuesBy[K comparable, V any, T any](m map[K]V, mapper func(item V) T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/sg9-oRidh8f)</span></b>
 
 ```go
 package main
@@ -709,7 +711,7 @@ func main() {
 func MapKeys[K comparable, V any, T comparable](m map[K]V, iteratee func(key K, value V) T) map[T]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/8scDxWeBDKd)</span></b>
 
 ```go
 package main
@@ -748,7 +750,7 @@ func main() {
 func MapValues[K comparable, V any, T any](m map[K]V, iteratee func(key K, value V) T) map[K]T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/g92aY3fc7Iw)</span></b>
 
 ```go
 package main
@@ -791,7 +793,7 @@ type Entry[K comparable, V any] struct {
 func Entries[K comparable, V any](m map[K]V) []Entry[K, V]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Ltb11LNcElY)</span></b>
 
 ```go
 package main
@@ -836,7 +838,7 @@ type Entry[K comparable, V any] struct {
 func FromEntries[K comparable, V any](entries []Entry[K, V]) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/fTdu4sCNjQO)</span></b>
 
 ```go
 package main
@@ -870,7 +872,7 @@ func main() {
 func Transform[K1 comparable, V1 any, K2 comparable, V2 any](m map[K1]V1, iteratee func(key K1, value V1) (K2, V2)) map[K2]V2
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/P6ovfToM3zj)</span></b>
 
 ```go
 package main
@@ -909,7 +911,7 @@ func main() {
 func IsDisjoint[K comparable, V any](mapA, mapB map[K]V) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/N9qgYg_Ho6f)</span></b>
 
 ```go
 package main
@@ -964,7 +966,7 @@ if haskey {
 func HasKey[K comparable, V any](m map[K]V, key K) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/isZZHOsDhFc)</span></b>
 
 ```go
 package main
@@ -980,8 +982,8 @@ func main() {
         "b": 2,
     }
 
-    result1 := HasKey(m, "a")
-    result2 := HasKey(m, "c")
+    result1 := maputil.HasKey(m, "a")
+    result2 := maputil.HasKey(m, "c")
 
     fmt.Println(result1)
     fmt.Println(result2)
@@ -992,6 +994,101 @@ func main() {
 }
 ```
 
+### <span id="ToSortedSlicesDefault">ToSortedSlicesDefault</span>
+
+<p>
+Translate the key and value of the map into two slices that are sorted in ascending order according to the key’s value, with the position of the elements in the value slice corresponding to the key.</p>
+
+<b>Signature:</b>
+
+```go
+func ToSortedSlicesDefault[K constraints.Ordered, V any](m map[K]V) ([]K, []V)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](Todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[int]string{
+		1: "a",
+		3: "c",
+		2: "b",
+	}
+
+	keys, values := ToSortedSlicesDefault(m)
+
+	fmt.Println(keys)
+	fmt.Println(values)
+
+	// Output:
+	// [1 2 3]
+	// [a b c]
+}
+```
+
+### <span id="ToSortedSlicesWithComparator">ToSortedSlicesWithComparator</span>
+
+<p>
+Translate the key and value of the map into two slices that are sorted according to a custom sorting rule defined by a comparator function based on the key's value, with the position of the elements in the value slice corresponding to the key.
+</p>
+
+<b>Signature:</b>
+
+```go
+func ToSortedSlicesWithComparator[K comparable, V any](m map[K]V, comparator func(a, b K) bool) ([]K, []V) 
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](Todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m1 := map[time.Time]string{
+		time.Date(2024, 3, 31, 0, 0, 0, 0, time.UTC): "today",
+		time.Date(2024, 3, 30, 0, 0, 0, 0, time.UTC): "yesterday",
+		time.Date(2024, 4, 1, 0, 0, 0, 0, time.UTC):  "tomorrow",
+	}
+
+	keys1, values1 := ToSortedSlicesWithComparator(m1, func(a, b time.Time) bool {
+		return a.Before(b)
+	})
+
+	m2 := map[int]string{
+		1: "a",
+		3: "c",
+		2: "b",
+	}
+	keys2, values2 := ToSortedSlicesWithComparator(m2, func(a, b int) bool {
+		return a > b
+	})
+
+	fmt.Println(keys2)
+	fmt.Println(values2)
+
+	fmt.Println(keys1)
+	fmt.Println(values1)
+
+	// Output:
+	// [2024-03-30 00:00:00 +0000 UTC 2024-03-31 00:00:00 +0000 UTC 2024-04-01 00:00:00 +0000 UTC]
+	// [yesterday today tomorrow]
+	// [3 2 1]
+	// [c b a]
+}
+```
+
 ### <span id="NewConcurrentMap">NewConcurrentMap</span>
 
 <p>ConcurrentMap is like map, but is safe for concurrent use by multiple goroutines.</p>
@@ -1003,7 +1100,7 @@ func main() {
 func NewConcurrentMap[K comparable, V any](shardCount int) *ConcurrentMap[K, V]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/3PenTPETJT0)</span></b>
 
 ```go
 package main
@@ -1029,7 +1126,7 @@ func main() {
 func (cm *ConcurrentMap[K, V]) Set(key K, value V)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/3PenTPETJT0)</span></b>
 
 ```go
 package main
@@ -1054,12 +1151,16 @@ func main() {
     wg1.Wait()
 
 
-    for j := 0; j < 5; j++ {
-        go func(n int) {
-            val, ok := cm.Get(fmt.Sprintf("%d", n))
-            fmt.Println(val, ok)
-        }(j)
-    }
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
+	for j := 0; j < 5; j++ {
+		go func(n int) {
+			val, ok := cm.Get(fmt.Sprintf("%d", n))
+			fmt.Println(val, ok)
+			wg2.Done()
+		}(j)
+	}
+	wg2.Wait()
 
     // output: (order may change)
     // 1 true
@@ -1080,7 +1181,7 @@ func main() {
 func (cm *ConcurrentMap[K, V]) Get(key K) (V, bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/3PenTPETJT0)</span></b>
 
 ```go
 package main
@@ -1105,12 +1206,16 @@ func main() {
     wg1.Wait()
 
 
-    for j := 0; j < 5; j++ {
-        go func(n int) {
-            val, ok := cm.Get(fmt.Sprintf("%d", n))
-            fmt.Println(val, ok)
-        }(j)
-    }
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
+	for j := 0; j < 5; j++ {
+		go func(n int) {
+			val, ok := cm.Get(fmt.Sprintf("%d", n))
+			fmt.Println(val, ok)
+			wg2.Done()
+		}(j)
+	}
+	wg2.Wait()
 
     // output: (order may change)
     // 1 true
@@ -1131,7 +1236,7 @@ func main() {
 func (cm *ConcurrentMap[K, V]) GetOrSet(key K, value V) (actual V, ok bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/aDcDApOK01a)</span></b>
 
 ```go
 package main
@@ -1175,7 +1280,7 @@ func main() {
 func (cm *ConcurrentMap[K, V]) Delete(key K)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uTIJZYhpVMS)</span></b>
 
 ```go
 package main
@@ -1199,17 +1304,19 @@ func main() {
     }
     wg1.Wait()
 
-
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
     for j := 0; j < 5; j++ {
         go func(n int) {
             cm.Delete(fmt.Sprintf("%d", n))
             wg2.Done()
-        }(i)
+        }(j)
     }
+
+    wg2.Wait()
 }
 ```
 
-
 ### <span id="ConcurrentMap_GetAndDelete">ConcurrentMap_GetAndDelete</span>
 
 <p>Returns the existing value for the key if present and then delete the value for the key. Otherwise, do nothing, just return false.</p>
@@ -1220,7 +1327,7 @@ func main() {
 func (cm *ConcurrentMap[K, V]) GetAndDelete(key K) (actual V, ok bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ZyxeIXSZUiM)</span></b>
 
 ```go
 package main
@@ -1244,7 +1351,8 @@ func main() {
     }
     wg1.Wait()
 
-
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
     for j := 0; j < 5; j++ {
         go func(n int) {
             val, ok := cm.GetAndDelete(fmt.Sprintf("%d", n))
@@ -1252,12 +1360,15 @@ func main() {
 
             _, ok = cm.Get(fmt.Sprintf("%d", n))
             fmt.Println(val, ok) //false
+
+            wg2.Done()
         }(j)
     }
+
+    wg2.Wait()
 }
 ```
 
-
 ### <span id="ConcurrentMap_Has">ConcurrentMap_Has</span>
 
 <p>Checks if map has the value for a key.</p>
@@ -1268,7 +1379,7 @@ func main() {
 func (cm *ConcurrentMap[K, V]) Has(key K) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/C8L4ul9TVwf)</span></b>
 
 ```go
 package main
@@ -1292,17 +1403,19 @@ func main() {
     }
     wg1.Wait()
 
-
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
     for j := 0; j < 5; j++ {
         go func(n int) {
             ok := cm.Has(fmt.Sprintf("%d", n))
             fmt.Println(ok) // true
+            wg2.Done()
         }(j)
     }
+    wg2.Wait()
 }
 ```
 
-
 ### <span id="ConcurrentMap_Range">ConcurrentMap_Range</span>
 
 <p>Calls iterator sequentially for each key and value present in each of the shards in the map. If iterator returns false, range stops the iteration.</p>
@@ -1313,7 +1426,7 @@ func main() {
 func (cm *ConcurrentMap[K, V]) Range(iterator func(key K, value V) bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/iqcy7P8P0Pr)</span></b>
 
 ```go
 package main