Add functional predicate XNOR (#181)

Add new function, Xnor, designed to create a composed predicate representing
the logical Exclusive NOR (XNOR) operation applied to a list of predicates.
The XNOR operation is a logical operation that returns true only
if all operands have the same boolean value

.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,9 @@ on:
   push:
     branches:
       - main
-      # - v2
   pull_request:
     branches:
       - main
-      # - v2
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -17,8 +15,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

@@ -9,4 +9,7 @@ fileutil/unzip/*
 fileutil/tempdir/*
 slice/testdata/*
 cryptor/*.pem
-test
+test
+docs/node_modules
+docs/.vitepress/cache
+docs/.vitepress/dist

CONTRIBUTING.en-US.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 `v2` branch instead of `master` 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 是提交到 `v2` 分支，而不是 `main` 分支。
+
+- 如果是修复 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

@@ -66,6 +66,7 @@ func GreaterOrEqual(left, right any) bool {
 }
 
 // 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_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,6 +194,17 @@ 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) {

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 constraints contain some custom interface.
-package lancetconstraints
+package constraints
 
 // Comparator is for comparing two values
 type Comparator interface {

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

@@ -337,6 +337,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 {

cryptor/basic.go

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

cryptor/crypto.go

@@ -13,6 +13,7 @@ import (
 	"crypto/des"
 	"crypto/rand"
 	"crypto/rsa"
+	"crypto/sha256"
 	"crypto/x509"
 	"encoding/pem"
 	"io"
@@ -505,3 +506,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/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

@@ -90,6 +90,35 @@ func lastIndexOf[T any](o T, e []T, start int, end int) int {
 	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]

datastructure/list/copyonwritelist_test.go

@@ -1,8 +1,9 @@
 package datastructure
 
 import (
-	"github.com/duke-git/lancet/v2/internal"
 	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
 )
 
 func TestCopyOnWriteList_ValueOf(t *testing.T) {
@@ -233,3 +234,35 @@ func TestCopyOnWriteList_SubList(t *testing.T) {
 	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/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 {
+	if q.tail < q.capacity {
-		return false
+		q.data = append(q.data, item)
-	} else if q.head != 0 && q.tail == q.capacity {
+		// q.tail++
-		for i := q.head; i < q.tail; i++ {
+		q.data[q.tail] = item
-			q.items[i-q.head] = q.items[i]
+	} 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

@@ -7,15 +7,15 @@ package datastructure
 // Set is a data container, like slice, but element of set is not duplicate.
 type Set[T comparable] map[T]struct{}
 
-// NewSet return a instance of set
+// New create a instance of set from given values.
-func NewSet[T comparable](items ...T) Set[T] {
+func New[T comparable](items ...T) Set[T] {
 	set := make(Set[T])
 	set.Add(items...)
 	return set
 }
 
-// NewSetFromSlice create a set from slice
+// FromSlice create a set from given slice.
-func NewSetFromSlice[T comparable](items []T) Set[T] {
+func FromSlice[T comparable](items []T) Set[T] {
 	set := make(Set[T])
 	for _, item := range items {
 		set.Add(item)
@@ -77,7 +77,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 := New[T]()
 	set.Add(s.Values()...)
 	return set
 }
@@ -135,7 +135,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 +147,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)
@@ -165,7 +165,7 @@ func (s Set[T]) SymmetricDifference(other Set[T]) Set[T] {
 
 // Minus creates an set of whose element in origin set but not in compared set
 func (s Set[T]) Minus(comparedSet Set[T]) Set[T] {
-	set := NewSet[T]()
+	set := New[T]()
 
 	s.Iterate(func(value T) {
 		if !comparedSet.Contain(value) {

datastructure/set/set_test.go

@@ -6,18 +6,18 @@ import (
 	"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 +26,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 +39,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 +52,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 +75,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 +87,9 @@ func TestSet_ContainAll(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_ContainAll")
 
-	set1 := NewSet(1, 2, 3)
+	set1 := New(1, 2, 3)
-	set2 := NewSet(1, 2)
+	set2 := New(1, 2)
-	set3 := NewSet(1, 2, 3, 4)
+	set3 := New(1, 2, 3, 4)
 
 	assert.Equal(true, set1.ContainAll(set2))
 	assert.Equal(false, set1.ContainAll(set3))
@@ -100,7 +100,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 +112,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 +124,9 @@ func TestSet_Equal(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Equal")
 
-	set1 := NewSet(1, 2, 3)
+	set1 := New(1, 2, 3)
-	set2 := NewSet(1, 2, 3)
+	set2 := New(1, 2, 3)
-	set3 := NewSet(1, 2, 3, 4)
+	set3 := New(1, 2, 3, 4)
 
 	assert.Equal(true, set1.Equal(set2))
 	assert.Equal(false, set1.Equal(set3))
@@ -137,7 +137,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 +151,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 +160,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 +169,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 +180,12 @@ func TestSet_Union(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Union")
 
-	set1 := NewSet(1, 2, 3)
+	set1 := New(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
+	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 +193,11 @@ func TestSet_Intersection(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Intersection")
 
-	set1 := NewSet(1, 2, 3)
+	set1 := New(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
+	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 +205,10 @@ func TestSet_SymmetricDifference(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_SymmetricDifference")
 
-	set1 := NewSet(1, 2, 3)
+	set1 := New(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
+	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 +216,16 @@ func TestSet_Minus(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Minus")
 
-	set1 := NewSet(1, 2, 3)
+	set1 := New(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
+	set2 := New(2, 3, 4, 5)
-	set3 := NewSet(2, 3)
+	set3 := New(2, 3)
 
-	assert.Equal(NewSet(1), set1.Minus(set2))
+	assert.Equal(New(1), set1.Minus(set2))
-	assert.Equal(NewSet(4, 5), set2.Minus(set3))
+	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
 
@@ -244,7 +244,7 @@ func TestEachWithBreak(t *testing.T) {
 // func TestPop(t *testing.T) {
 // 	assert := internal.NewAssert(t, "TestPop")
 
-// 	s := NewSet[int]()
+// 	s := New[int]()
 
 // 	val, ok := s.Pop()
 // 	assert.Equal(0, val)
@@ -254,7 +254,7 @@ func TestEachWithBreak(t *testing.T) {
 // 	s.Add(2)
 // 	s.Add(3)
 
-// 	// s = NewSet(1, 2, 3, 4, 5)
+// 	// s = New(1, 2, 3, 4, 5)
 
 // 	val, ok = s.Pop()
 // 	assert.Equal(3, val)

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

@@ -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

@@ -35,7 +35,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
-## Documentation
+## 文档
 
 ### <span id="Equal">Equal</span>
 
@@ -47,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
@@ -96,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
@@ -135,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
@@ -184,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
@@ -236,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
@@ -285,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
@@ -337,7 +337,7 @@ func main() {
 func InDelta[T constraints.Integer | constraints.Float](left, right T, delta float64) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/TuDdcNtMkjo)</span></b>
 
 ```go
 package main

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)
+-   [NewChannel](#NewChannel)
-- [FanIn](#FanIn)
+-   [Bridge](#Bridge)
-- [Generate](#Generate)
+-   [FanIn](#FanIn)
-- [Or](#Or)
+-   [Generate](#Generate)
-- [OrDone](#OrDone)
+-   [Or](#Or)
-- [Repeat](#Repeat)
+-   [OrDone](#OrDone)
-- [RepeatFn](#RepeatFn)
+-   [Repeat](#Repeat)
-- [Take](#Take)
+-   [RepeatFn](#RepeatFn)
-- [Tee](#Tee)
+-   [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

@@ -58,7 +58,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 +89,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 +122,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 +163,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 +196,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 +232,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 +269,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 +314,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 +356,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 +391,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 +432,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 +461,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 +509,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 +547,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 +577,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 +606,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 +642,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 +706,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 +785,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 +820,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 +854,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

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/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/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)
+    hms := cryptor.HmacSha512WithBase64(str, key)
-	fmt.Println(hms)
+    fmt.Println(hms)
 
-	// Output:
+    // Output:
-	// 3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A==
+    // 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:
+    // Output:
-	// XUFAKrxLKna5cZ2REBfFkg==
+    // 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:
+    // Output:
-	// 0cc175b9c0f1b6a831c399e269772661
+    // 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:
+    // Output:
-	// XUFAKrxLKna5cZ2REBfFkg==
+    // 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:
+    // Output:
-	// qvTGHdzF6KLavt4PO0gs2a6pQ00=
+    // 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:
+    // Output:
-	// LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=
+    // 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:
+    // Output:
-	// m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
+    // 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

@@ -26,6 +26,8 @@ import (
 -   [Remove](#Remove)
 -   [IndexOf](#IndexOf)
 -   [LastIndexOf](#LastIndexOf)
+-   [IndexOfFunc](#IndexOfFunc)
+-   [LastIndexOfFunc](#LastIndexOfFunc)
 -   [IsEmpty](#IsEmpty)
 -   [Contain](#Contain)
 -   [ValueOf](#ValueOf)
@@ -198,6 +200,58 @@ func main()  {
 
 ```
 
+### <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。

docs/api/packages/datastructure/hashmap.md

@@ -38,7 +38,7 @@ import (
 
 ### <span id="NewHashMap">NewHashMap</span>
 
-<p>新建默认容量（1 << 10）的HashMap指针实例</p>
+<p>新建默认容量（1 &lt&lt 10）的HashMap指针实例</p>
 
 <b>函数签名:</b>
 

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)
+-   [New](#New)
--   [NewSetFromSlice](#NewSetFromSlice)
+-   [FromSlice](#FromSlice)
 -   [Values](#Values)
 -   [Add](#Add)
 -   [AddIfNotExist](#AddIfNotExist)
@@ -45,7 +45,7 @@ import (
 
 ## 文档
 
-### <span id="NewSet">NewSet</span>
+### <span id="New">New</span>
 
 <p>返回Set结构体对象</p>
 
@@ -53,7 +53,7 @@ import (
 
 ```go
 type Set[T comparable] map[T]bool
-func NewSet[T comparable](items ...T) Set[T]
+func New[T comparable](items ...T) Set[T]
 ```
 
 <b>示例:</b>
@@ -67,19 +67,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,7 +93,7 @@ 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
 }
 ```
@@ -119,7 +119,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 +145,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 +173,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2, 3)
 
     r1 := st.AddIfNotExist(1)
@@ -206,7 +206,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 +245,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2, 3)
 
     set.Delete(3)
@@ -274,7 +274,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 +303,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
-    set2 := set.NewSet(1, 2)
+    set2 := set.New(1, 2)
-    set3 := set.NewSet(1, 2, 3, 4)
+    set3 := set.New(1, 2, 3, 4)
 
     fmt.Println(set1.ContainAll(set2)) //true
     fmt.Println(set1.ContainAll(set3)) //false
@@ -333,7 +333,7 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
 
     fmt.Println(set1.Size()) //3
 }
@@ -360,7 +360,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 +389,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
-    set2 := set.NewSet(1, 2, 3)
+    set2 := set.New(1, 2, 3)
-    set3 := set.NewSet(1, 2, 3, 4)
+    set3 := set.New(1, 2, 3, 4)
 
     fmt.Println(set1.Equal(set2)) //true
     fmt.Println(set1.Equal(set3)) //false
@@ -419,7 +419,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 +450,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 +487,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
-    set2 := set.NewSet()
+    set2 := set.New()
 
     fmt.Println(set1.IsEmpty()) //false
     fmt.Println(set2.IsEmpty()) //true
@@ -516,8 +516,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.Union(set2)
 
     fmt.Println(set3.Values()) //1,2,3,4,5
@@ -545,8 +545,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.Intersection(set2)
 
     fmt.Println(set3.Values()) //2,3
@@ -574,8 +574,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.SymmetricDifference(set2)
 
     fmt.Println(set3.Values()) //1,4,5
@@ -603,9 +603,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set2 := set.New(2, 3, 4, 5)
-    set3 := set.NewSet(2, 3)
+    set3 := set.New(2, 3)
 
     res1 := set1.Minus(set2)
     fmt.Println(res1.Values()) //1
@@ -636,7 +636,7 @@ import (
 )
 
 func main() {
-    s := set.NewSet[int]()
+    s := set.New[int]()
     s.Add(1)
     s.Add(2)
     s.Add(3)

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

@@ -45,8 +45,10 @@ import (
 -   [Sha](#Sha)
 -   [ReadCsvFile](#ReadCsvFile)
 -   [WriteCsvFile](#WriteCsvFile)
+-   [WriteMapsToCsv](#WriteMapsToCsv)
 -   [WriteStringToFile](#WriteStringToFile)
 -   [WriteBytesToFile](#WriteBytesToFile)
+-   [ReadFile](#ReadFile)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -62,7 +64,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 +92,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 +118,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 +144,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
@@ -170,7 +172,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 +198,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 +227,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 +258,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 +285,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 +311,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 +340,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 +366,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 +394,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 +427,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 +461,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 +489,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 +517,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 +545,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 +571,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 +603,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 +635,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 +670,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 +702,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 +744,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 +807,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 +856,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 +894,41 @@ 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
+}
+```

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

@@ -7,6 +7,7 @@ function 函数包控制函数执行流程，包含部分函数式编程。
 ## 源码:
 
 -   [https://github.com/duke-git/lancet/blob/main/function/function.go](https://github.com/duke-git/lancet/blob/main/function/function.go)
+-   [https://github.com/duke-git/lancet/blob/main/function/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>
@@ -32,6 +33,10 @@ import (
 -   [Schedule](#Schedule)
 -   [Pipeline](#Pipeline)
 -   [Watcher](#Watcher)
+-   [And](#And)
+-   [Or](#Or)
+-   [Negate](#Negate)
+-   [Nor](#Nor)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -47,7 +52,7 @@ import (
 func After(n int, fn any) func(args ...any) []reflect.Value
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/eRD5k2vzUVX)</span></b>
 
 ```go
 package main
@@ -80,7 +85,7 @@ func main() {
 func Before(n int, fn any) func(args ...any) []reflect.Value
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/0HqUDIFZ3IL)</span></b>
 
 ```go
 package main
@@ -88,7 +93,6 @@ package main
 import (
     "fmt"
     "github.com/duke-git/lancet/v2/function"
-    "github.com/duke-git/lancet/v2/internal"
 )
 
 func main() {
@@ -118,7 +122,7 @@ type CurryFn[T any] func(...T) T
 func (cf CurryFn[T]) New(val T) func(...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/5HopfDwANKX)</span></b>
 
 ```go
 package main
@@ -157,7 +161,7 @@ func main() {
 func Compose[T any](fnList ...func(...T) T) func(...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KKfugD4PKYF)</span></b>
 
 ```go
 package main
@@ -195,7 +199,7 @@ func main() {
 func Debounced(fn func(), duration time.Duration) func()
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/absuEGB_GN7)</span></b>
 
 ```go
 package main
@@ -245,7 +249,7 @@ func main() {
 func Delay(delay time.Duration, fn any, args ...any)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Ivtc2ZE-Tye)</span></b>
 
 ```go
 package main
@@ -277,7 +281,7 @@ func main() {
 func Schedule(d time.Duration, fn any, args ...any) chan bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/hbON-Xeyn5N)</span></b>
 
 ```go
 package main
@@ -316,7 +320,7 @@ func main() {
 func Pipeline[T any](funcs ...func(T) T) func(T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/mPdUVvj6HD6)</span></b>
 
 ```go
 package main
@@ -361,13 +365,14 @@ type Watcher struct {
     excuting  bool
 }
 func NewWatcher() *Watcher
-func (w *Watcher) Start() //start the watcher
+func (w *Watcher) Start()
-func (w *Watcher) Stop() //stop the watcher
+func (w *Watcher) Stop()
-func (w *Watcher) Reset() //reset the watcher
+func (w *Watcher) Reset()
-func (w *Watcher) GetElapsedTime() time.Duration //get the elapsed time of function execution
+func (w *Watcher) GetElapsedTime() time.Duration
+
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/l2yrOpCLd1I)</span></b>
 
 ```go
 package main
@@ -404,3 +409,157 @@ func longRunningTask() {
 }
 
 ```
+
+### <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>示例:</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>示例:</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>示例:</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>示例:</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
+}
+```

docs/api/packages/maputil.md

@@ -53,7 +53,6 @@ import (
 -   [ConcurrentMap_Has](#ConcurrentMap_Has)
 -   [ConcurrentMap_Range](#ConcurrentMap_Range)
 
-
 <div STYLE="page-break-after: always;"></div>
 
 ## API 文档:
@@ -68,7 +67,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 +124,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 +165,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 +210,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 +248,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 +286,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 +327,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 +365,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 +403,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 +458,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 +497,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 +536,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 +578,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 +615,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 +656,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 +705,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 +744,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 +787,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 +832,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 +866,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 +905,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 +960,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
@@ -1000,7 +999,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 +1025,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
@@ -1080,7 +1079,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
@@ -1134,7 +1133,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
@@ -1178,7 +1177,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
@@ -1214,7 +1213,6 @@ func main() {
 }
 ```
 
-
 ### <span id="ConcurrentMap_GetAndDelete">ConcurrentMap_GetAndDelete</span>
 
 <p>获取key，然后删除。</p>
@@ -1225,7 +1223,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
@@ -1266,7 +1264,6 @@ func main() {
 }
 ```
 
-
 ### <span id="ConcurrentMap_Has">ConcurrentMap_Has</span>
 
 <p>验证是否包含key。</p>
@@ -1277,7 +1274,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
@@ -1315,7 +1312,6 @@ func main() {
 }
 ```
 
-
 ### <span id="ConcurrentMap_Range">ConcurrentMap_Range</span>
 
 <p>为map中每个键和值顺序调用迭代器。 如果iterator返回false，则停止迭代。</p>
@@ -1326,7 +1322,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
@@ -1357,4 +1353,3 @@ func main() {
     })
 }
 ```
-

docs/api/packages/mathutil.md

@@ -50,7 +50,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
-## Documentation
+## 文档
 
 ### <span id="Average">Average</span>
 
@@ -62,7 +62,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 +97,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 +133,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 +169,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 +205,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 +238,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 +282,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 +315,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 +359,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
@@ -395,7 +395,7 @@ func main() {
 func RoundToFloat(x float64, n int) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ghyb528JRJL)</span></b>
 
 ```go
 package main
@@ -431,7 +431,7 @@ func main() {
 func RoundToString(x float64, n int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/kZwpBRAcllO)</span></b>
 
 ```go
 package main
@@ -467,7 +467,7 @@ func main() {
 func TruncRound(x float64, n int) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/aumarSHIGzP)</span></b>
 
 ```go
 package main
@@ -503,7 +503,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 +542,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 +581,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 +617,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 +653,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 +683,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 +722,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 +764,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 +800,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 +842,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 +884,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 +920,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 +953,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

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

@@ -30,7 +30,8 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
-## Document 文档
+
+## 文档
 
 ### <span id="Context">Context</span>
 
@@ -42,7 +43,7 @@ import (
 func Context(ctx context.Context)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/xnAOOXv9GkS)</span></b>
 
 ```go
 import (
@@ -89,7 +90,7 @@ func main() {
 type RetryFunc func() error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nk2XRmagfVF)</span></b>
 
 ```go
 package main
@@ -135,7 +136,7 @@ func main() {
 func RetryTimes(n uint)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ssfVeU2SwLO)</span></b>
 
 ```go
 package main
@@ -178,7 +179,7 @@ func main() {
 func RetryDuration(d time.Duration)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nk2XRmagfVF)</span></b>
 
 ```go
 package main
@@ -224,7 +225,7 @@ func main() {
 func Retry(retryFunc RetryFunc, opts ...Option) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nk2XRmagfVF)</span></b>
 
 ```go
 package main

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,11 @@ import (
 -   [Without](#Without)
 -   [KeyBy](#KeyBy)
 -   [Join](#Join)
+-   [Partition](#Partition)
 
 <div STYLE="page-break-after: always;"></div>
 
+
 ## 文档
 
 ### <span id="AppendIfAbsent">AppendIfAbsent</span>
@@ -106,7 +109,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 +140,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 +171,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 +216,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 +247,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 +289,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 +326,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 +357,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 +390,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 +424,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 +455,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 +490,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 +517,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 +534,66 @@ import (
 )
 
 func main() {
-    result1 := slice.DeleteAt([]string{"a", "b", "c"}, -1)
+    chars := []string{"a", "b", "c", "d", "e"}
-    result2 := slice.DeleteAt([]string{"a", "b", "c"}, 0)
+
-    result3 := slice.DeleteAt([]string{"a", "b", "c"}, 0, 2)
+    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 d e]
-    // [b c]
+    // [a b c d]
-    // [c]
+    // [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 +608,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 +645,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 +682,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 +722,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 +764,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 +798,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 +833,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 +868,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 +902,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 +938,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 +974,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 +1010,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 +1046,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 +1076,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 +1106,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 +1141,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 +1179,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 +1215,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 +1249,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 +1278,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 +1307,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 +1338,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 +1378,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 +1411,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 +1444,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 +1478,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 +1515,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 +1548,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 +1579,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 +1609,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 +1643,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 +1679,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 +1709,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 +1751,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 +1779,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 +1807,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 +1836,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 +1870,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 +1904,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 +1938,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 +1978,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 +2015,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 +2052,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 +2062,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 +2103,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 +2137,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 +2166,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 +2197,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 +2225,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 +2260,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 +2287,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 +2318,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 +2349,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 +2374,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 +2382,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 +2422,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 +2450,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 +2480,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 +2502,70 @@ 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
+}
+```

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)
-
+-   [IsTargetType](#IsTargetType)
-> 注意：由于`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)
 
 <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,11 @@ import (
 -   [ContainsAll](#ContainsAll)
 -   [ContainsAny](#ContainsAny)
 -   [RemoveWhiteSpace](#RemoveWhiteSpace)
+-   [SubInBetween](#SubInBetween)
 
 <div STYLE="page-break-after: always;"></div>
 
-## Documentation 文档
+## 文档
 
 ### <span id="After">After</span>
 
@@ -74,7 +76,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 +116,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 +156,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 +193,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 +230,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 +265,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 +300,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 +335,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 +370,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 +410,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 +444,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 +478,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 +523,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 +569,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 +615,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 +646,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 +678,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 +716,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 +757,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 +800,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 +827,7 @@ func main() {
 }
 ```
 
-### <span id="Wrap">Wrap</span>
+### <span id="Unwrap">Unwrap</span>
 
 <p>用另一个字符串解开包裹一个字符串。</p>
 
@@ -835,7 +837,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 +877,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 +920,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 +963,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 +994,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 +1024,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 +1053,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 +1077,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 +1126,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 +1157,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 +1188,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 +1230,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 +1263,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 +1300,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 +1333,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 +1372,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 +1405,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 +1441,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 +1463,36 @@ 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>示例:</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
+}
+```

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")
+    err1 := xerror.New("error").With("level", "high")
-    wrapErr := xerror.Wrap(err, "error")
+	err2 := err1.Wrap(errors.New("invalid username"))
 
-    fmt.Println(wrapErr.Error())
+	fmt.Println(err2.Error())
 
-    // Output:
+	// Output:
-    // error: wrong password
+	// 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

@@ -40,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
@@ -89,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
@@ -128,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
@@ -183,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
@@ -235,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
@@ -278,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
@@ -330,7 +330,7 @@ func main() {
 
 <p>Checks if two values are equal or not within a delta.</p>
 
-<b>Signature:</b>
+<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

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

@@ -58,7 +58,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 +89,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 +122,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 +163,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 +196,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 +232,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 +269,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 +314,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 +356,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 +391,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 +432,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 +461,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 +509,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 +547,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
@@ -577,7 +577,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 +606,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
@@ -642,7 +642,7 @@ func main() {
 func DeepClone[T any](src T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/j4DP5dquxnk)</span></b>
 
 ```go
 package main
@@ -706,7 +706,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
@@ -785,7 +785,7 @@ func main() {
 func ToInterface(v reflect.Value) (value interface{}, ok bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/syqw0-WG7Xd)</span></b>
 
 ```go
 package main
@@ -820,7 +820,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 +854,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

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/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/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)
+-   [AesEcbEncrypt](#AesEcbEncrypt)
-- [AesEcbDecrypt](#AesEcbDecrypt)
+-   [AesEcbDecrypt](#AesEcbDecrypt)
-- [AesCbcEncrypt](#AesCbcEncrypt)
+-   [AesCbcEncrypt](#AesCbcEncrypt)
-- [AesCbcDecrypt](#AesCbcDecrypt)
+-   [AesCbcDecrypt](#AesCbcDecrypt)
-- [AesCtrCrypt](#AesCtrCrypt)
+-   [AesCtrCrypt](#AesCtrCrypt)
-- [AesCfbEncrypt](#AesCfbEncrypt)
+-   [AesCfbEncrypt](#AesCfbEncrypt)
-- [AesCfbDecrypt](#AesCfbDecrypt)
+-   [AesCfbDecrypt](#AesCfbDecrypt)
-- [AesOfbEncrypt](#AesOfbEncrypt)
+-   [AesOfbEncrypt](#AesOfbEncrypt)
-- [AesOfbDecrypt](#AesOfbDecrypt)
+-   [AesOfbDecrypt](#AesOfbDecrypt)
-- [Base64StdEncode](#Base64StdEncode)
+-   [Base64StdEncode](#Base64StdEncode)
-- [Base64StdDecode](#Base64StdDecode)
+-   [Base64StdDecode](#Base64StdDecode)
-- [DesEcbEncrypt](#DesEcbEncrypt)
+-   [DesEcbEncrypt](#DesEcbEncrypt)
-- [DesEcbDecrypt](#DesEcbDecrypt)
+-   [DesEcbDecrypt](#DesEcbDecrypt)
-- [DesCbcEncrypt](#DesCbcEncrypt)
+-   [DesCbcEncrypt](#DesCbcEncrypt)
-- [DesCbcDecrypt](#DesCbcDecrypt)
+-   [DesCbcDecrypt](#DesCbcDecrypt)
-- [DesCtrCrypt](#DesCtrCrypt)
+-   [DesCtrCrypt](#DesCtrCrypt)
-- [DesCfbEncrypt](#DesCfbEncrypt)
+-   [DesCfbEncrypt](#DesCfbEncrypt)
-- [DesCfbDecrypt](#DesCfbDecrypt)
+-   [DesCfbDecrypt](#DesCfbDecrypt)
-- [DesOfbEncrypt](#DesOfbEncrypt)
+-   [DesOfbEncrypt](#DesOfbEncrypt)
-- [DesOfbDecrypt](#DesOfbDecrypt)
+-   [DesOfbDecrypt](#DesOfbDecrypt)
-- [HmacMd5](#HmacMd5)
+-   [HmacMd5](#HmacMd5)
-- [HmacMd5WithBase64](#HmacMd5WithBase64)
+-   [HmacMd5WithBase64](#HmacMd5WithBase64)
-- [HmacSha1](#HmacSha1)
+-   [HmacSha1](#HmacSha1)
-- [HmacSha1WithBase64](#HmacSha1WithBase64)
+-   [HmacSha1WithBase64](#HmacSha1WithBase64)
-- [HmacSha256](#HmacSha256)
+-   [HmacSha256](#HmacSha256)
-- [HmacSha256WithBase64](#HmacSha256WithBase64)
+-   [HmacSha256WithBase64](#HmacSha256WithBase64)
-- [HmacSha512](#HmacSha512)
+-   [HmacSha512](#HmacSha512)
-- [HmacSha512WithBase64](#HmacSha512WithBase64)
+-   [HmacSha512WithBase64](#HmacSha512WithBase64)
-- [Md5String](#Md5String)
+-   [Md5String](#Md5String)
-- [Md5StringWithBase64](#Md5StringWithBase64)
+-   [Md5StringWithBase64](#Md5StringWithBase64)
-- [Md5Byte](#Md5Byte)
+-   [Md5Byte](#Md5Byte)
-- [Md5ByteWithBase64](#Md5ByteWithBase64)
+-   [Md5ByteWithBase64](#Md5ByteWithBase64)
-- [Md5File](#Md5File)
+-   [Md5File](#Md5File)
-- [Sha1](#Sha1)
+-   [Sha1](#Sha1)
-- [Sha1WithBase64](#Sha1WithBase64)
+-   [Sha1WithBase64](#Sha1WithBase64)
-- [Sha256](#Sha256)
+-   [Sha256](#Sha256)
-- [Sha256WithBase64](#Sha256WithBase64)
+-   [Sha256WithBase64](#Sha256WithBase64)
-- [Sha512](#Sha512)
+-   [Sha512](#Sha512)
-- [Sha512WithBase64](#Sha512WithBase64)
+-   [Sha512WithBase64](#Sha512WithBase64)
-- [GenerateRsaKey](#GenerateRsaKey)
+-   [GenerateRsaKey](#GenerateRsaKey)
-- [RsaEncrypt](#RsaEncrypt)
+-   [RsaEncrypt](#RsaEncrypt)
-- [RsaDecrypt](#RsaDecrypt)
+-   [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

@@ -26,6 +26,8 @@ import (
 -   [Remove](#Remove)
 -   [IndexOf](#IndexOf)
 -   [LastIndexOf](#LastIndexOf)
+-   [IndexOfFunc](#IndexOfFunc)
+-   [LastIndexOfFunc](#LastIndexOfFunc)
 -   [IsEmpty](#IsEmpty)
 -   [Contain](#Contain)
 -   [ValueOf](#ValueOf)
@@ -197,6 +199,59 @@ func main() {
 
 ```
 
+
+### <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.

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

@@ -39,7 +39,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>
 

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)
+-   [New](#New)
--   [NewSetFromSlice](#NewSetFromSlice)
+-   [FromSlice](#FromSlice)
 -   [Values](#Values)
 -   [Add](#Add)
 -   [AddIfNotExist](#AddIfNotExist)
@@ -46,7 +46,7 @@ import (
 
 ## Documentation
 
-### <span id="NewSet">NewSet</span>
+### <span id="New">New</span>
 
 <p>Create a set instance</p>
 
@@ -54,7 +54,7 @@ import (
 
 ```go
 type Set[T comparable] map[T]bool
-func NewSet[T comparable](items ...T) Set[T]
+func New[T comparable](items ...T) Set[T]
 ```
 
 <b>Example:</b>
@@ -68,19 +68,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,7 +94,7 @@ 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
 }
 ```
@@ -120,7 +120,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 +146,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 +174,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2, 3)
 
     r1 := st.AddIfNotExist(1)
@@ -207,7 +207,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 +246,7 @@ import (
 )
 
 func main() {
-    st := set.NewSet[int]()
+    st := set.New[int]()
     st.Add(1, 2, 3)
 
     set.Delete(3)
@@ -275,7 +275,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 +304,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
-    set2 := set.NewSet(1, 2)
+    set2 := set.New(1, 2)
-    set3 := set.NewSet(1, 2, 3, 4)
+    set3 := set.New(1, 2, 3, 4)
 
     fmt.Println(set1.ContainAll(set2)) //true
     fmt.Println(set1.ContainAll(set3)) //false
@@ -334,7 +334,7 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
 
     fmt.Println(set1.Size()) //3
 }
@@ -361,7 +361,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 +390,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
-    set2 := set.NewSet(1, 2, 3)
+    set2 := set.New(1, 2, 3)
-    set3 := set.NewSet(1, 2, 3, 4)
+    set3 := set.New(1, 2, 3, 4)
 
     fmt.Println(set1.Equal(set2)) //true
     fmt.Println(set1.Equal(set3)) //false
@@ -420,7 +420,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 +451,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 +488,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
-    set2 := set.NewSet()
+    set2 := set.New()
 
     fmt.Println(set1.IsEmpty()) //false
     fmt.Println(set2.IsEmpty()) //true
@@ -517,8 +517,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.Union(set2)
 
     fmt.Println(set3.Values()) //1,2,3,4,5
@@ -546,8 +546,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.Intersection(set2)
 
     fmt.Println(set3.Values()) //2,3
@@ -575,8 +575,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.SymmetricDifference(set2)
 
     fmt.Println(set3.Values()) //1,4,5
@@ -604,9 +604,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
+    set1 := set.New(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set2 := set.New(2, 3, 4, 5)
-    set3 := set.NewSet(2, 3)
+    set3 := set.New(2, 3)
 
     res1 := set1.Minus(set2)
     fmt.Println(res1.Values()) //1
@@ -637,7 +637,7 @@ import (
 )
 
 func main() {
-    s := set.NewSet[int]()
+    s := set.New[int]()
     s.Add(1)
     s.Add(2)
     s.Add(3)

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

@@ -45,8 +45,10 @@ import (
 -   [Sha](#Sha)
 -   [ReadCsvFile](#ReadCsvFile)
 -   [WriteCsvFile](#WriteCsvFile)
+-   [WriteMapsToCsv](#WriteMapsToCsv)
 -   [WriteStringToFile](#WriteStringToFile)
 -   [WriteBytesToFile](#WriteBytesToFile)
+-   [ReadFile](#ReadFile)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -62,7 +64,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 +92,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 +118,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 +144,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
@@ -170,7 +172,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 +198,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 +227,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 +258,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 +285,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 +311,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 +340,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 +366,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 +394,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 +427,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 +461,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 +489,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 +517,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 +545,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 +571,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 +603,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 +635,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 +670,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 +702,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 +744,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 +807,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 +856,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 +894,41 @@ 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
+}
+```

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

@@ -7,6 +7,7 @@ Package function can control the flow of function execution and support part of
 ## Source:
 
 -   [https://github.com/duke-git/lancet/blob/main/function/function.go](https://github.com/duke-git/lancet/blob/main/function/function.go)
+-   [https://github.com/duke-git/lancet/blob/main/function/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>
@@ -32,6 +33,10 @@ import (
 -   [Schedule](#Schedule)
 -   [Pipeline](#Pipeline)
 -   [Watcher](#Watcher)
+-   [And](#And)
+-   [Or](#Or)
+-   [Negate](#Negate)
+-   [Nor](#Nor)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -47,7 +52,7 @@ import (
 func After(n int, fn any) func(args ...any) []reflect.Value
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/eRD5k2vzUVX)</span></b>
 
 ```go
 package main
@@ -80,7 +85,7 @@ func main() {
 func Before(n int, fn any) func(args ...any) []reflect.Value
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/0HqUDIFZ3IL)</span></b>
 
 ```go
 package main
@@ -88,7 +93,6 @@ package main
 import (
     "fmt"
     "github.com/duke-git/lancet/v2/function"
-    "github.com/duke-git/lancet/v2/internal"
 )
 
 func main() {
@@ -118,7 +122,7 @@ type CurryFn[T any] func(...T) T
 func (cf CurryFn[T]) New(val T) func(...T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/5HopfDwANKX)</span></b>
 
 ```go
 package main
@@ -157,7 +161,7 @@ func main() {
 func Compose[T any](fnList ...func(...T) T) func(...T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/KKfugD4PKYF)</span></b>
 
 ```go
 package main
@@ -195,7 +199,7 @@ func main() {
 func Debounced(fn func(), duration time.Duration) func()
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/absuEGB_GN7)</span></b>
 
 ```go
 package main
@@ -245,7 +249,7 @@ func main() {
 func Delay(delay time.Duration, fn any, args ...any)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Ivtc2ZE-Tye)</span></b>
 
 ```go
 package main
@@ -277,7 +281,7 @@ func main() {
 func Schedule(d time.Duration, fn any, args ...any) chan bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/hbON-Xeyn5N)</span></b>
 
 ```go
 package main
@@ -317,7 +321,7 @@ the functions one by one.</p>
 func Pipeline[T any](funcs ...func(T) T) func(T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/mPdUVvj6HD6)</span></b>
 
 ```go
 package main
@@ -368,7 +372,7 @@ func (w *Watcher) Reset() //reset the watcher
 func (w *Watcher) GetElapsedTime() time.Duration //get the elapsed time of function execution
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/l2yrOpCLd1I)</span></b>
 
 ```go
 package main
@@ -379,7 +383,7 @@ import (
 )
 
 func main() {
-       w := function.NewWatcher()
+    w := function.NewWatcher()
 
     w.Start()
 
@@ -404,3 +408,158 @@ func longRunningTask() {
 }
 
 ```
+
+
+### <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:</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:</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:</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:</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
+}
+```

docs/en/api/packages/maputil.md

@@ -67,7 +67,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 +124,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 +165,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 +210,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 +248,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 +286,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 +327,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 +365,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 +403,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 +458,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 +498,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 +537,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 +579,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 +619,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 +660,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 +709,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 +748,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 +791,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 +836,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 +870,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 +909,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 +964,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
@@ -1003,7 +1003,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 +1029,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
@@ -1084,7 +1084,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
@@ -1139,7 +1139,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
@@ -1183,7 +1183,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
@@ -1220,7 +1220,6 @@ func main() {
 }
 ```
 
-
 ### <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>
@@ -1231,7 +1230,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
@@ -1264,7 +1263,7 @@ func main() {
 
             _, ok = cm.Get(fmt.Sprintf("%d", n))
             fmt.Println(val, ok) //false
-            
+
             wg2.Done()
         }(j)
     }
@@ -1273,7 +1272,6 @@ func main() {
 }
 ```
 
-
 ### <span id="ConcurrentMap_Has">ConcurrentMap_Has</span>
 
 <p>Checks if map has the value for a key.</p>
@@ -1284,7 +1282,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
@@ -1321,7 +1319,6 @@ func main() {
 }
 ```
 
-
 ### <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>
@@ -1332,7 +1329,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
@@ -1356,7 +1353,7 @@ func main() {
     }
     wg1.Wait()
 
-    
+
     cm.Range(func(key string, value int) bool {
         fmt.Println(value)
         return true

docs/en/api/packages/mathutil.md

@@ -48,7 +48,6 @@ import (
 -   [Sum](#Sum)
 -   [Abs](#Abs)
 
-
 <div STYLE="page-break-after: always;"></div>
 
 ## Documentation
@@ -63,7 +62,7 @@ import (
 func Average[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Vv7LBwER-pz)</span></b>
 
 ```go
 package main
@@ -98,7 +97,7 @@ func main() {
 func Exponent(x, n int64) int64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uF3HGNPk8wr)</span></b>
 
 ```go
 package main
@@ -134,7 +133,7 @@ func main() {
 func Fibonacci(first, second, n int) int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/IscseUNMuUc)</span></b>
 
 ```go
 package main
@@ -170,7 +169,7 @@ func main() {
 func Factorial(x uint) uint
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tt6LdOK67Nx)</span></b>
 
 ```go
 package main
@@ -206,7 +205,7 @@ func main() {
 func Max[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/cN8DHI0rTkH)</span></b>
 
 ```go
 package main
@@ -239,7 +238,7 @@ func main() {
 func MaxBy[T any](slice []T, comparator func(T, T) bool) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/pbe2MT-7DV2)</span></b>
 
 ```go
 package main
@@ -283,7 +282,7 @@ func main() {
 func Min[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/21BER_mlGUj)</span></b>
 
 ```go
 package main
@@ -316,7 +315,7 @@ func main() {
 func MinBy[T any](slice []T, comparator func(T, T) bool) T
 ```
 
-<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
@@ -360,7 +359,7 @@ func main() {
 func Percent(val, total float64, n int) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/s0NdFCtwuyd)</span></b>
 
 ```go
 package main
@@ -396,7 +395,7 @@ func main() {
 func RoundToFloat(x float64, n int) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ghyb528JRJL)</span></b>
 
 ```go
 package main
@@ -432,7 +431,7 @@ func main() {
 func RoundToString(x float64, n int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/kZwpBRAcllO)</span></b>
 
 ```go
 package main
@@ -468,7 +467,7 @@ func main() {
 func TruncRound(x float64, n int) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/aumarSHIGzP)</span></b>
 
 ```go
 package main
@@ -504,7 +503,7 @@ func main() {
 func Range[T constraints.Integer | constraints.Float](start T, count int) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9ke2opxa8ZP)</span></b>
 
 ```go
 package main
@@ -543,7 +542,7 @@ func main() {
 func RangeWithStep[T constraints.Integer | constraints.Float](start, end, step T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/akLWz0EqOSM)</span></b>
 
 ```go
 package main
@@ -582,7 +581,7 @@ func main() {
 func AngleToRadian(angle float64) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/CIvlICqrHql)</span></b>
 
 ```go
 package main
@@ -618,7 +617,7 @@ func main() {
 func RadianToAngle(radian float64) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/dQtmOTUOMgi)</span></b>
 
 ```go
 package main
@@ -654,7 +653,7 @@ func main() {
 func PointDistance(x1, y1, x2, y2 float64) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/RrG4JIaziM8)</span></b>
 
 ```go
 package main
@@ -684,7 +683,7 @@ func main() {
 func IsPrime(n int) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Rdd8UTHZJ7u)</span></b>
 
 ```go
 package main
@@ -723,7 +722,7 @@ func main() {
 func GCD[T constraints.Integer](integers ...T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/CiEceLSoAKB)</span></b>
 
 ```go
 package main
@@ -765,7 +764,7 @@ func main() {
 func LCM[T constraints.Integer](integers ...T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/EjcZxfY7G_g)</span></b>
 
 ```go
 package main
@@ -791,7 +790,6 @@ func main() {
 }
 ```
 
-
 ### <span id="Cos">Cos</span>
 
 <p>Returns the cosine of the radian argument.</p>
@@ -802,7 +800,7 @@ func main() {
 func Cos(radian float64, precision ...int) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Sm89LoIfvFq)</span></b>
 
 ```go
 package main
@@ -834,7 +832,6 @@ func main() {
 }
 ```
 
-
 ### <span id="Sin">Sin</span>
 
 <p>Returns the sine of the radian argument.</p>
@@ -845,7 +842,7 @@ func main() {
 func Sin(radian float64, precision ...int) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/TWMQlMywDsP)</span></b>
 
 ```go
 package main
@@ -887,7 +884,7 @@ func main() {
 func Log(n, base float64) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_d4bi8oyhat)</span></b>
 
 ```go
 package main
@@ -923,7 +920,7 @@ func main() {
 func Sum[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/1To2ImAMJA7)</span></b>
 
 ```go
 package main
@@ -956,7 +953,7 @@ func main() {
 func Abs[T constraints.Integer | constraints.Float](x T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/fsyBh1Os-1d)</span></b>
 
 ```go
 package main
@@ -980,4 +977,4 @@ func main() {
 	// 0.1
 	// 0.2
 }
-```
+```

docs/en/api/packages/netutil.md

@@ -51,6 +51,8 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
+<link rel="stylesheet" type="text/css" href="/styles/api_doc.css">
+
 ## Documentation
 
 ### <span id="ConvertMapToQueryString">ConvertMapToQueryString</span>
@@ -63,7 +65,7 @@ import (
 func ConvertMapToQueryString(param map[string]any) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jnNt_qoSnRi)</span></b>
 
 ```go
 package main
@@ -96,7 +98,7 @@ func main() {
 func EncodeUrl(urlStr string) (string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/bsZ6BRC4uKI)</span></b>
 
 ```go
 package main
@@ -131,7 +133,7 @@ func main() {
 func GetInternalIp() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/5mbu-gFp7ei)</span></b>
 
 ```go
 package main
@@ -163,7 +165,7 @@ func main() {
 func GetIps() []string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/NUFfcEmukx1)</span></b>
 
 ```go
 package main
@@ -193,7 +195,7 @@ func main() {
 func GetMacAddrs() []string {
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Rq9UUBS_Xp1)</span></b>
 
 ```go
 package main
@@ -237,7 +239,7 @@ type PublicIpInfo struct {
 }
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/YDxIfozsRHR)</span></b>
 
 ```go
 package main
@@ -267,7 +269,7 @@ func main() {
 func GetRequestPublicIp(req *http.Request) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/kxU-YDc_eBo)</span></b>
 
 ```go
 package main
@@ -305,7 +307,7 @@ func main() {
 func IsPublicIP(IP net.IP) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nmktSQpJZnn)</span></b>
 
 ```go
 package main
@@ -342,7 +344,7 @@ func main() {
 func IsInternalIP(IP net.IP) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/sYGhXbgO4Cb)</span></b>
 
 ```go
 package main
@@ -386,7 +388,7 @@ type HttpRequest struct {
 }
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -443,7 +445,7 @@ func NewHttpClientWithConfig(config *HttpClientConfig) *HttpClient
 
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -474,7 +476,7 @@ func main() {
 func (client *HttpClient) SendRequest(request *HttpRequest) (*http.Response, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -528,7 +530,7 @@ func main() {
 func (client *HttpClient) DecodeResponse(resp *http.Response, target any) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -582,7 +584,7 @@ func main() {
 func StructToUrlValues(targetStruct any) url.Values
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/pFqMkM40w9z)</span></b>
 
 ```go
 package main
@@ -964,7 +966,7 @@ func main() {
 func IsPingConnected(host string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/q8OzTijsA87)</span></b>
 
 ```go
 package main
@@ -997,7 +999,7 @@ func main() {
 func IsTelnetConnected(host string, port string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/yiLCGtQv_ZG)</span></b>
 
 ```go
 package main

docs/en/api/packages/pointer.md

@@ -42,7 +42,7 @@ import (
 func Of[T any](v T) *T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/HFd70x4DrMj)</span></b>
 
 ```go
 package main
@@ -76,7 +76,7 @@ func main() {
 func Unwrap[T any](p *T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/cgeu3g7cjWb)</span></b>
 
 ```go
 package main
@@ -112,7 +112,7 @@ func main() {
 UnwarpOr[T any](p *T, fallback T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/mmNaLC38W8C)</span></b>
 
 ```go
 package main
@@ -157,7 +157,7 @@ func main() {
 UnwarpOrDefault[T any](p *T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ZnGIHf8_o4E)</span></b>
 
 ```go
 package main
@@ -203,7 +203,7 @@ func main() {
 func ExtractPointer(value any) any
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/D7HFjeWU2ZP)</span></b>
 
 ```go
 package main

docs/en/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>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/EkiLESeXf8d)</span></b>
 
 ```go
 package main
@@ -72,7 +75,7 @@ func main() {
 func RandInt(min, max int) int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/pXyyAAI5YxD)</span></b>
 
 ```go
 package main
@@ -98,7 +101,7 @@ func main() {
 func RandString(length int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/W2xvRUXA7Mi)</span></b>
 
 ```go
 package main
@@ -124,7 +127,7 @@ func main() {
 func RandUpper(length int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/29QfOh0DVuh)</span></b>
 
 ```go
 package main
@@ -150,7 +153,7 @@ func main() {
 func RandLower(length int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/XJtZ471cmtI)</span></b>
 
 ```go
 package main
@@ -176,7 +179,7 @@ func main() {
 func RandNumeral(length int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/g4JWVpHsJcf)</span></b>
 
 ```go
 package main
@@ -202,7 +205,7 @@ func main() {
 func RandNumeralOrLetter(length int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/19CEQvpx2jD)</span></b>
 
 ```go
 package main
@@ -218,6 +221,32 @@ func main() {
 }
 ```
 
+### <span id="RandSymbolChar">RandSymbolChar</span>
+
+<p>Generate a random symbol char of specified length.</p>
+
+<b>Signature:</b>
+
+```go
+func RandSymbolChar(length int) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](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) // random string like: @#(_")
+}
+```
+
 ### <span id="UUIdV4">UUIdV4</span>
 
 <p>Generate a random UUID of version 4 according to RFC 4122.</p>
@@ -228,7 +257,7 @@ func main() {
 func UUIdV4() (string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_Z9SFmr28ft)</span></b>
 
 ```go
 package main
@@ -258,7 +287,7 @@ func main() {
 func RandUniqueIntSlice(n, min, max int) []int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uBkRSOz73Ec)</span></b>
 
 ```go
 package main
@@ -273,3 +302,55 @@ func main() {
     fmt.Println(result) //[0 4 7 1 5] (random)
 }
 ```
+
+### <span id="RandFloat">RandFloat</span>
+
+<p>Generate a random float64 number between [min, max) with specific precision.</p>
+
+<b>Signature:</b>
+
+```go
+func RandFloat(min, max float64, precision int) float64
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](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>Generate a slice of random float64 numbers of length n that do not repeat.</p>
+
+<b>Signature:</b>
+
+```go
+func RandFloats(n int, min, max float64, precision int) []float64
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](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(floatNumbers) //[3.42 3.99 1.3 2.38 4.23] (random)
+}
+```

docs/en/api/packages/retry.md

@@ -42,7 +42,7 @@ import (
 func Context(ctx context.Context)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/xnAOOXv9GkS)</span></b>
 
 ```go
 import (
@@ -89,7 +89,7 @@ func main() {
 type RetryFunc func() error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nk2XRmagfVF)</span></b>
 
 ```go
 package main
@@ -135,7 +135,7 @@ func main() {
 func RetryTimes(n uint)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ssfVeU2SwLO)</span></b>
 
 ```go
 package main
@@ -178,7 +178,7 @@ func main() {
 func RetryDuration(d time.Duration)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nk2XRmagfVF)</span></b>
 
 ```go
 package main
@@ -224,7 +224,7 @@ func main() {
 func Retry(retryFunc RetryFunc, opts ...Option) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nk2XRmagfVF)</span></b>
 
 ```go
 package main

docs/en/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,6 +92,7 @@ import (
 -   [Without](#Without)
 -   [KeyBy](#KeyBy)
 -   [Join](#Join)
+-   [Partition](#Partition)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -106,7 +108,7 @@ import (
 func AppendIfAbsent[T comparable](slice []T, item T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/GNdv7Jg2Taj)</span></b>
 
 ```go
 import (
@@ -137,7 +139,7 @@ func main() {
 func Contain[T comparable](slice []T, target T) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_454yEHcNjf)</span></b>
 
 ```go
 import (
@@ -168,7 +170,7 @@ func main() {
 func ContainBy[T any](slice []T, predicate func(item T) bool) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/49tkHfX4GNc)</span></b>
 
 ```go
 import (
@@ -213,7 +215,7 @@ func main() {
 func ContainSubSlice[T comparable](slice, subSlice []T) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/bcuQ3UT6Sev)</span></b>
 
 ```go
 import (
@@ -244,7 +246,7 @@ func main() {
 func Chunk[T any](slice []T, size int) [][]T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/b4Pou5j2L_C)</span></b>
 
 ```go
 import (
@@ -286,7 +288,7 @@ func main() {
 func Compact[T comparable](slice []T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/pO5AnxEr3TK)</span></b>
 
 ```go
 import (
@@ -323,7 +325,7 @@ func main() {
 func Concat[T any](slice []T, slices ...[]T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/gPt-q7zr5mk)</span></b>
 
 ```go
 import (
@@ -354,7 +356,7 @@ func main() {
 func Count[T comparable](slice []T, item T) int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Mj4oiEnQvRJ)</span></b>
 
 ```go
 import (
@@ -387,7 +389,7 @@ func main() {
 func CountBy[T any](slice []T, predicate func(index int, item T) bool) int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tHOccTMDZCC)</span></b>
 
 ```go
 import (
@@ -421,7 +423,7 @@ func main() {
 func Difference[T comparable](slice, comparedSlice []T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/VXvadzLzhDa)</span></b>
 
 ```go
 import (
@@ -452,7 +454,7 @@ func main() {
 func DifferenceBy[T comparable](slice []T, comparedSlice []T, iteratee func(index int, item T) T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/DiivgwM5OnC)</span></b>
 
 ```go
 import (
@@ -487,7 +489,7 @@ func main() {
 func DifferenceWith[T any](slice []T, comparedSlice []T, comparator func(value, otherValue T) bool) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/v2U2deugKuV)</span></b>
 
 ```go
 import (
@@ -514,15 +516,15 @@ func main() {
 
 ### <span id="DeleteAt">DeleteAt</span>
 
-<p>Delete the element of slice from start index to end index - 1.</p>
+<p>Delete delete the element of slice at index.</p>
 
 <b>Signature:</b>
 
 ```go
-func DeleteAt[T any](slice []T, start int, end ...int)
+func DeleteAt[T any](slice []T, index int)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/800B1dPBYyd)</span></b>
 
 ```go
 import (
@@ -531,18 +533,66 @@ import (
 )
 
 func main() {
-    result1 := slice.DeleteAt([]string{"a", "b", "c"}, -1)
+    chars := []string{"a", "b", "c", "d", "e"}
-    result2 := slice.DeleteAt([]string{"a", "b", "c"}, 0)
+
-    result3 := slice.DeleteAt([]string{"a", "b", "c"}, 0, 2)
+    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 d e]
-    // [b c]
+    // [a b c d]
-    // [c]
+    // [a b c d]
+    // [a b c d]
+}
+```
+
+### <span id="DeleteRange">DeleteRange</span>
+
+<p>Delete the element of slice from start index to end index（exclude)</p>
+
+<b>Signature:</b>
+
+```go
+func DeleteRange[T any](slice []T, start, end int) []T 
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](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 := slice.DeleteRange(chars, 0, 0)
+    result2 := slice.DeleteRange(chars, 0, 1)
+    result3 := slice.DeleteRange(chars, 0, 3)
+    result4 := slice.DeleteRange(chars, 0, 4)
+    result5 := slice.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]
+    // []
+
 }
 ```
 
@@ -556,7 +606,7 @@ func main() {
 func Drop[T any](slice []T, n int) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jnPO2yQsT8H)</span></b>
 
 ```go
 import (
@@ -593,7 +643,7 @@ func main() {
 func DropRight[T any](slice []T, n int) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/8bcXvywZezG)</span></b>
 
 ```go
 import (
@@ -630,7 +680,7 @@ func main() {
 func DropWhile[T any](slice []T, predicate func(item T) bool) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4rt252UV_qs)</span></b>
 
 ```go
 import (
@@ -670,7 +720,7 @@ func main() {
 func DropRightWhile[T any](slice []T, predicate func(item T) bool) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/6wyK3zMY56e)</span></b>
 
 ```go
 import (
@@ -712,7 +762,7 @@ func main() {
 func Equal[T comparable](slice1, slice2 []T) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/WcRQJ37ifPa)</span></b>
 
 ```go
 import (
@@ -747,7 +797,7 @@ func main() {
 func EqualWith[T, U any](slice1 []T, slice2 []U, comparator func(T, U) bool) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/b9iygtgsHI1)</span></b>
 
 ```go
 import (
@@ -782,7 +832,7 @@ func main() {
 func Every[T any](slice []T, predicate func(index int, item T) bool) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/R8U6Sl-j8cD)</span></b>
 
 ```go
 import (
@@ -816,7 +866,7 @@ func main() {
 func Filter[T any](slice []T, predicate func(index int, item T) bool) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/SdPna-7qK4T)</span></b>
 
 ```go
 import (
@@ -850,7 +900,7 @@ func main() {
 func Find[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/CBKeBoHVLgq)</span></b>
 
 ```go
 import (
@@ -878,7 +928,7 @@ func main() {
 
 ### <span id="FindBy">FindBy</span>
 
-<p>Iterates over elements of slice, returning the first one that passes a truth test on predicate function.If return T is nil or zero value then no items matched the predicate func. In contrast to Find or FindLast, its return value no longer requires dereferencing</p>
+<p>Iterates over elements of slice, returning the first one that passes a truth test on predicate function.If return T is nil or zero value then no items matched the predicate func. In contrast to Find or FindLast, its return value no longer requires dereferencing.</p>
 
 <b>Signature:</b>
 
@@ -886,7 +936,7 @@ func main() {
 func FindBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/n1lysBYl-GB)</span></b>
 
 ```go
 import (
@@ -922,7 +972,7 @@ func main() {
 func FindLast[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/FFDPV_j7URd)</span></b>
 
 ```go
 import (
@@ -950,7 +1000,7 @@ func main() {
 
 ### <span id="FindLastBy">FindLastBy</span>
 
-<p>FindLastBy iterates over elements of slice, returning the last one that passes a truth test on predicate function. If return T is nil or zero value then no items matched the predicate func. In contrast to Find or FindLast, its return value no longer requires dereferencing</p>
+<p>FindLastBy iterates over elements of slice, returning the last one that passes a truth test on predicate function. If return T is nil or zero value then no items matched the predicate func. In contrast to Find or FindLast, its return value no longer requires dereferencing.</p>
 
 <b>Signature:</b>
 
@@ -958,7 +1008,7 @@ func main() {
 func FindLastBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/8iqomzyCl_s)</span></b>
 
 ```go
 import (
@@ -994,7 +1044,7 @@ func main() {
 func Flatten(slice any) any
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/hYa3cBEevtm)</span></b>
 
 ```go
 import (
@@ -1024,7 +1074,7 @@ func main() {
 func FlattenDeep(slice any) any
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/yjYNHPyCFaF)</span></b>
 
 ```go
 import (
@@ -1054,7 +1104,7 @@ func main() {
 func ForEach[T any](slice []T, iteratee func(index int, item T))
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/DrPaa4YsHRF)</span></b>
 
 ```go
 import (
@@ -1089,7 +1139,7 @@ func main() {
 func ForEachWithBreak[T any](slice []T, iteratee func(index int, item T) bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/qScs39f3D9W)</span></b>
 
 ```go
 import (
@@ -1127,7 +1177,7 @@ func main() {
 func GroupBy[T any](slice []T, groupFn func(index int, item T) bool) ([]T, []T)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/QVkPxzPR0iA)</span></b>
 
 ```go
 import (
@@ -1163,7 +1213,7 @@ func main() {
 func GroupWith[T any, U comparable](slice []T, iteratee func(T) U) map[U][]T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ApCvMNTLO8a)</span></b>
 
 ```go
 import (
@@ -1197,7 +1247,7 @@ func main() {
 func IntSlice(slice any) []int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/UQDj-on9TGN)</span></b>
 
 ```go
 import (
@@ -1226,7 +1276,7 @@ func main() {
 func InterfaceSlice(slice any) []any
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/FdQXF0Vvqs-)</span></b>
 
 ```go
 import (
@@ -1255,7 +1305,7 @@ func main() {
 func Intersection[T comparable](slices ...[]T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/anJXfB5wq_t)</span></b>
 
 ```go
 import (
@@ -1286,7 +1336,7 @@ func main() {
 func InsertAt[T any](slice []T, index int, value any) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/hMLNxPEGJVE)</span></b>
 
 ```go
 import (
@@ -1326,7 +1376,7 @@ func main() {
 func IndexOf[T comparable](slice []T, item T) int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/MRN1f0FpABb)</span></b>
 
 ```go
 import (
@@ -1359,7 +1409,7 @@ func main() {
 func LastIndexOf[T comparable](slice []T, item T) int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/DokM4cf1IKH)</span></b>
 
 ```go
 import (
@@ -1392,7 +1442,7 @@ func main() {
 func Map[T any, U any](slice []T, iteratee func(index int, item T) U) []U
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/biaTefqPquw)</span></b>
 
 ```go
 import (
@@ -1426,7 +1476,7 @@ func main() {
 func FilterMap[T any, U any](slice []T, iteratee func(index int, item T) (U, bool)) []U
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/J94SZ_9MiIe)</span></b>
 
 ```go
 import (
@@ -1463,7 +1513,7 @@ func main() {
 func FlatMap[T any, U any](slice []T, iteratee func(index int, item T) []U) []U
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_QARWlWs1N_F)</span></b>
 
 ```go
 import (
@@ -1496,7 +1546,7 @@ func main() {
 func Merge[T any](slices ...[]T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/lbjFp784r9N)</span></b>
 
 ```go
 import (
@@ -1527,7 +1577,7 @@ func main() {
 func Reverse[T any](slice []T)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/8uI8f1lwNrQ)</span></b>
 
 ```go
 import (
@@ -1557,7 +1607,7 @@ func main() {
 func Reduce[T any](slice []T, iteratee func(index int, item1, item2 T) T, initial T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_RfXJJWIsIm)</span></b>
 
 ```go
 import (
@@ -1591,7 +1641,7 @@ func main() {
 func ReduceBy[T any, U any](slice []T, initial U, reducer func(index int, item T, agg U) U) U
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/YKDpLi7gtee)</span></b>
 
 ```go
 import (
@@ -1627,7 +1677,7 @@ func main() {
 func ReduceRight[T any, U any](slice []T, initial U, reducer func(index int, item T, agg U) U) U
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/qT9dZC03A1K)</span></b>
 
 ```go
 import (
@@ -1657,7 +1707,7 @@ func main() {
 func Replace[T comparable](slice []T, old T, new T, n int) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/P5mZp7IhOFo)</span></b>
 
 ```go
 import (
@@ -1699,7 +1749,7 @@ func main() {
 func ReplaceAll[T comparable](slice []T, old T, new T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/CzqXMsuYUrx)</span></b>
 
 ```go
 import (
@@ -1727,7 +1777,7 @@ func main() {
 func Repeat[T any](item T, n int) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/1CbOmtgILUU)</span></b>
 
 ```go
 import (
@@ -1755,7 +1805,7 @@ func main() {
 func Shuffle[T any](slice []T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/YHvhnWGU3Ge)</span></b>
 
 ```go
 import (
@@ -1784,7 +1834,7 @@ func main() {
 func IsAscending[T constraints.Ordered](slice []T) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9CtsFjet4SH)</span></b>
 
 ```go
 import (
@@ -1818,7 +1868,7 @@ func main() {
 func IsDescending[T constraints.Ordered](slice []T) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/U_LljFXma14)</span></b>
 
 ```go
 import (
@@ -1852,7 +1902,7 @@ func main() {
 func IsSorted[T constraints.Ordered](slice []T) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nCE8wPLwSA-)</span></b>
 
 ```go
 import (
@@ -1886,7 +1936,7 @@ func main() {
 func IsSortedByKey[T any, K constraints.Ordered](slice []T, iteratee func(item T) K) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tUoGB7DOHI4)</span></b>
 
 ```go
 import (
@@ -1918,8 +1968,7 @@ func main() {
 
 ### <span id="Sort">Sort</span>
 
-<p>Sorts a slice of any ordered type(number or string), use quick sort algrithm. Default sort order is ascending (asc), if want descending order, set param `sortOrder` to `desc`. Ordered type: number(all ints uints floats) or string.
+<p>Sorts a slice of any ordered type(number or string), use quick sort algrithm. Default sort order is ascending (asc), if want descending order, set param `sortOrder` to `desc`. Ordered type: number(all ints uints floats) or string.</p>
-</p>
 
 <b>Signature:</b>
 
@@ -1927,7 +1976,7 @@ func main() {
 func Sort[T constraints.Ordered](slice []T, sortOrder ...string)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/V9AVjzf_4Fk)</span></b>
 
 ```go
 import (
@@ -1956,7 +2005,7 @@ func main() {
 
 ### <span id="SortBy">SortBy</span>
 
-<p>Sorts the slice in ascending order as determined by the less function. This sort is not guaranteed to be stable.<p>
+<p>Sorts the slice in ascending order as determined by the less function. This sort is not guaranteed to be stable.</p>
 
 <b>Signature:</b>
 
@@ -1964,7 +2013,7 @@ func main() {
 func SortBy[T any](slice []T, less func(a, b T) bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/DAhLQSZEumm)</span></b>
 
 ```go
 import (
@@ -2001,9 +2050,9 @@ func main() {
 }
 ```
 
-### <span id="SortByField">SortByField (Deprecated: use Sort and SortBy for replacement)</span>
+### <span id="SortByField">SortByField</span>
 
-<p>Sort struct slice by field. Slice element should be struct, field type should be int, uint, string, or bool. Default sort type is ascending (asc), if descending order, set sortType to desc</p>
+<p>Sort struct slice by field. Slice element should be struct, `field` param type should be int, uint, string, or bool. Default sort type is ascending (asc), if descending order, set `sortType` param to desc.</p>
 
 <b>Signature:</b>
 
@@ -2011,7 +2060,7 @@ func main() {
 func SortByField(slice any, field string, sortType ...string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/fU1prOBP9p1)</span></b>
 
 ```go
 import (
@@ -2052,7 +2101,7 @@ func main() {
 func Some[T any](slice []T, predicate func(index int, item T) bool) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4pO9Xf9NDGS)</span></b>
 
 ```go
 import (
@@ -2086,7 +2135,7 @@ func main() {
 func StringSlice(slice any) []string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/W0TZDWCPFcI)</span></b>
 
 ```go
 import (
@@ -2115,7 +2164,7 @@ func main() {
 func SymmetricDifference[T comparable](slices ...[]T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/1CbOmtgILUU)</span></b>
 
 ```go
 import (
@@ -2146,7 +2195,7 @@ func main() {
 func ToSlice[T any](items ...T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/YzbzVq5kscN)</span></b>
 
 ```go
 import (
@@ -2174,7 +2223,7 @@ func main() {
 func ToSlicePointer[T any](items ...T) []*T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/gx4tr6_VXSF)</span></b>
 
 ```go
 import (
@@ -2209,7 +2258,7 @@ func main() {
 func Unique[T comparable](slice []T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/AXw0R3ZTE6a)</span></b>
 
 ```go
 import (
@@ -2236,7 +2285,7 @@ func main() {
 func UniqueBy[T comparable](slice []T, iteratee func(item T) T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/UR323iZLDpv)</span></b>
 
 ```go
 import (
@@ -2267,7 +2316,7 @@ func main() {
 func Union[T comparable](slices ...[]T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/hfXV1iRIZOf)</span></b>
 
 ```go
 import (
@@ -2298,7 +2347,7 @@ func main() {
 func UnionBy[T any, V comparable](predicate func(item T) V, slices ...[]T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/HGKHfxKQsFi)</span></b>
 
 ```go
 import (
@@ -2323,7 +2372,7 @@ func main() {
 
 ### <span id="UpdateAt">UpdateAt</span>
 
-<p>Update the slice element at index. if param index < 0 or index >= len(slice), will return error. </p>
+<p>Update the slice element at index. if param index &lt 0 or index &lt= len(slice), will return error. </p>
 
 <b>Signature:</b>
 
@@ -2331,7 +2380,7 @@ func main() {
 func UpdateAt[T any](slice []T, index int, value T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/f3mh2KloWVm)</span></b>
 
 ```go
 import (
@@ -2363,7 +2412,7 @@ func main() {
 
 ### <span id="Without">Without</span>
 
-<p>Creates a slice excluding all given items. </p>
+<p>Creates a slice excluding all given items.</p>
 
 <b>Signature:</b>
 
@@ -2371,7 +2420,7 @@ func main() {
 func Without[T comparable](slice []T, items ...T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/bwhEXEypThg)</span></b>
 
 ```go
 import (
@@ -2399,7 +2448,7 @@ func main() {
 func KeyBy[T any, U comparable](slice []T, iteratee func(item T) U) map[U]T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uXod2LWD1Kg)</span></b>
 
 ```go
 import (
@@ -2429,7 +2478,7 @@ func main() {
 func Join[T any](s []T, separator string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/huKzqwNDD7V)</span></b>
 
 ```go
 import (
@@ -2451,3 +2500,69 @@ func main() {
     // 1-2-3-4-5
 }
 ```
+
+### <span id="Partition">Partition</span>
+
+<p>Partition all slice elements with the evaluation of the given predicate functions. </p>
+
+<b>Signature:</b>
+
+```go
+func Partition[T any](slice []T, predicates ...func(item T) bool) [][]T
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](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>Random get a random item of slice, return idx=-1 when slice is empty. </p>
+
+<b>Signature:</b>
+
+```go
+func Random[T any](slice []T) (val T, idx int)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](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
+}
+```