doc: add doc for Xnor and Nand in function package

Add new function, NAND, designed to create a composed predicate representing the logical NAND operation
applied to a list of predicates. The NAND operation is a logical operation
that returns true only if all perdicate result in false otherwise false

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

README.md

@@ -4,7 +4,7 @@
 <br/>
 
 ![Go version](https://img.shields.io/badge/go-%3E%3Dv1.18-9cf)
-[![Release](https://img.shields.io/badge/release-2.2.7-green.svg)](https://github.com/duke-git/lancet/releases)
+[![Release](https://img.shields.io/badge/release-2.2.9-green.svg)](https://github.com/duke-git/lancet/releases)
 [![GoDoc](https://godoc.org/github.com/duke-git/lancet/v2?status.svg)](https://pkg.go.dev/github.com/duke-git/lancet/v2)
 [![Go Report Card](https://goreportcard.com/badge/github.com/duke-git/lancet/v2)](https://goreportcard.com/report/github.com/duke-git/lancet/v2)
 [![test](https://github.com/duke-git/lancet/actions/workflows/codecov.yml/badge.svg?branch=main&event=push)](https://github.com/duke-git/lancet/actions/workflows/codecov.yml)
@@ -21,7 +21,7 @@
 
 ## <a href="https://www.golancet.cn/en/" target="_blank"> Website</a> | [简体中文](./README_zh-CN.md)
 
-## Feature
+## Features
 
 -   👏 Comprehensive, efficient and reusable.
 -   💪 600+ go util functions, support string, slice, datetime, net, crypt...
@@ -32,7 +32,7 @@
 
 ### Note:
 
-1. <b>For users who use go1.18 and above, it is recommended to install lancet v2.x.x. Cause in v2.x.x all functions was rewriten with generics of go1.18.</b>
+1. <b>For users who use go1.18 and above, it is recommended to install lancet v2.x.x. Cause in v2.x.x all functions were rewritten with generics of go1.18.</b>
 
 ```go
 go get github.com/duke-git/lancet/v2 // will install latest version of v2.x.x
@@ -201,10 +201,10 @@ import "github.com/duke-git/lancet/v2/concurrency"
 -   **<big>OrDone</big>** : read a channel into another channel, will close until cancel context.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/concurrency.md#OrDone)]
     [[play](https://go.dev/play/p/lm_GoS6aDjo)]
--   **<big>Repeat</big>** : create channel, put values into the channel repeatly until cancel the context.
+-   **<big>Repeat</big>** : create channel, put values into the channel repeatedly until cancel the context.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/concurrency.md#Repeat)]
     [[play](https://go.dev/play/p/k5N_ALVmYjE)]
--   **<big>RepeatFn</big>** : create a channel, excutes fn repeatly, and put the result into the channel, until close context.
+-   **<big>RepeatFn</big>** : create a channel, executes fn repeatedly, and put the result into the channel, until close context.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/concurrency.md#RepeatFn)]
     [[play](https://go.dev/play/p/4J1zAWttP85)]
 -   **<big>Take</big>** : create a channel whose values are taken from another channel with limit number.
@@ -247,7 +247,7 @@ import "github.com/duke-git/lancet/v2/condition"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/condition.md#TernaryOperator)]
     [[play](https://go.dev/play/p/ElllPZY0guT)]
 
-<h3 id="convertor"> 5. Convertor package contains some functions for data convertion. &nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">index</a> </h3>
+<h3 id="convertor"> 5. Convertor package contains some functions for data conversion. &nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">index</a> </h3>
 
 ```go
 import "github.com/duke-git/lancet/v2/convertor"
@@ -453,10 +453,14 @@ import "github.com/duke-git/lancet/v2/cryptor"
     [[play](https://go.dev/play/p/uef0q1fz53I)]
 -   **<big>GenerateRsaKeyPair</big>** : creates rsa private and public key.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/cryptor.md#GenerateRsaKeyPair)]
+    [[play](https://go.dev/play/p/sSVmkfENKMz)]
 -   **<big>RsaEncryptOAEP</big>** : encrypts the given data with RSA-OAEP.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/cryptor.md#RsaEncryptOAEP)]
+    [[play](https://go.dev/play/p/sSVmkfENKMz)]
 -   **<big>RsaDecryptOAEP</big>** : decrypts the data with RSA-OAEP
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/cryptor.md#RsaDecryptOAEP)]
+    [[play](https://go.dev/play/p/sSVmkfENKMz)]
+
 
 <h3 id="datetime"> 7. Datetime package supports date and time format and compare. &nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">index</a></h3>
 
@@ -592,7 +596,7 @@ import "github.com/duke-git/lancet/v2/datetime"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/datetime.md#TimestampNano)]
     [[play](https://go.dev/play/p/A9Oq_COrcCF)]
 
-<h3 id="datastructure"> 8. Datastructure package constains some common data structure. eg. list, linklist, stack, queue, set, tree, graph. &nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">index</a></h3>
+<h3 id="datastructure"> 8. Datastructure package contains some common data structure. eg. list, linklist, stack, queue, set, tree, graph. &nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">index</a></h3>
 
 ```go
 import list "github.com/duke-git/lancet/v2/datastructure/list"
@@ -604,6 +608,7 @@ import set "github.com/duke-git/lancet/v2/datastructure/set"
 import tree "github.com/duke-git/lancet/v2/datastructure/tree"
 import heap "github.com/duke-git/lancet/v2/datastructure/heap"
 import hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
+import optional "github.com/duke-git/lancet/v2/datastructure/optional"
 ```
 
 #### Structure list:
@@ -626,6 +631,9 @@ import hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/datastructure/heap.md)]
 -   **<big>Hashmap</big>** : hash map structure.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/datastructure/hashmap.md)]
+-   **<big>Optional</big>** : Optional container.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/datastructure/optional.md)]
+      
 
 <h3 id="fileutil"> 9. Fileutil package implements some basic functions for file operations. &nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">index</a></h3>
 
@@ -702,7 +710,9 @@ import "github.com/duke-git/lancet/v2/fileutil"
     [[play](https://go.dev/play/p/OExTkhGEd3_u)]
 -   **<big>WriteCsvFile</big>** : write content to target csv file.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/fileutil.md#WriteCsvFile)]
-    [[play](https://go.dev/play/p/dAXm58Q5U1o)]
+-   **<big>WriteMapsToCsv</big>** : write slice of map to csv file.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/fileutil.md#WriteMapsToCsv)]
+    [[play](https://go.dev/play/p/umAIomZFV1c)]
 -   **<big>WriteBytesToFile</big>** : write bytes to target file.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/fileutil.md#WriteBytesToFile)]
     [[play](https://go.dev/play/p/s7QlDxMj3P8)]
@@ -750,10 +760,10 @@ import "github.com/duke-git/lancet/v2/function"
 
 #### Function list:
 
--   **<big>After</big>** : return a function that invokes passed funcation once the returned function is called more than n times.
+-   **<big>After</big>** : return a function that invokes passed function once the returned function is called more than n times.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/function.md#After)]
     [[play](https://go.dev/play/p/eRD5k2vzUVX)]
--   **<big>Before</big>** : return a function that invokes passed funcation once the returned function is called less than n times
+-   **<big>Before</big>** : return a function that invokes passed function once the returned function is called less than n times
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/function.md#Before)]
     [[play](https://go.dev/play/p/0HqUDIFZ3IL)]
 -   **<big>CurryFn</big>** : make a curry function.
@@ -774,7 +784,7 @@ import "github.com/duke-git/lancet/v2/function"
 -   **<big>Pipeline</big>** : takes a list of functions and returns a function whose param will be passed into the functions one by one.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/function.md#Pipeline)]
     [[play](https://go.dev/play/p/mPdUVvj6HD6)]
--   **<big>Watcher</big>** : Watcher is used for record code excution time. can start/stop/reset the watch timer. get the elapsed time of function execution.
+-   **<big>Watcher</big>** : Watcher is used for record code execution time. can start/stop/reset the watch timer. get the elapsed time of function execution.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/function.md#Watcher)]
     [[play](https://go.dev/play/p/l2yrOpCLd1I)]
 
@@ -789,7 +799,7 @@ import "github.com/duke-git/lancet/v2/maputil"
 -   **<big>MapTo</big>** : quick map any value to struct or any base type.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/maputil.md#MapTo)]
     [[play](https://go.dev/play/p/4K7KBEPgS5M)]
--   **<big>ForEach</big>** : executes iteratee funcation for every key and value pair in map.
+-   **<big>ForEach</big>** : executes iteratee function for every key and value pair in map.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/maputil.md#ForEach)]
     [[play](https://go.dev/play/p/OaThj6iNVXK)]
 -   **<big>Filter</big>** : iterates over map, return a new map contains all key and value pairs pass the predicate function.
@@ -807,7 +817,7 @@ import "github.com/duke-git/lancet/v2/maputil"
 -   **<big>OmitByKeys</big>** : the opposite of FilterByKeys, extracts all the map elements which keys are not omitted.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/maputil.md#OmitByKeys)]
     [[play](https://go.dev/play/p/jXGrWDBfSRp)]
--   **<big>OmitByValues</big>** : the opposite of FilterByValues. remov all elements whose value are in the give slice.
+-   **<big>OmitByValues</big>** : the opposite of FilterByValues. remove all elements whose value are in the give slice.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/maputil.md#OmitByValues)]
     [[play](https://go.dev/play/p/XB7Y10uw20_U)]
 -   **<big>Intersect</big>** : iterates over maps, return a new map of key and value pairs in all given maps.
@@ -957,7 +967,7 @@ import "github.com/duke-git/lancet/v2/mathutil"
 -   **<big>Sum</big>** : return sum of passed numbers.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/mathutil.md#Sum)]
     [[play](https://go.dev/play/p/1To2ImAMJA7)]
--   **<big>Abs</big>** : returns the absolute value of param nubmer.
+-   **<big>Abs</big>** : returns the absolute value of param number.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/mathutil.md#Sum)]
     [[play](https://go.dev/play/p/fsyBh1Os-1d)]
 
@@ -1008,7 +1018,7 @@ import "github.com/duke-git/lancet/v2/netutil"
 -   **<big>DecodeResponse</big>** : decode http response into target object.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/netutil.md#DecodeResponse)]
     [[play](https://go.dev/play/p/jUSgynekH7G)]
--   **<big>StructToUrlValues</big>** : convert struct to url valuse.
+-   **<big>StructToUrlValues</big>** : convert struct to url values.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/netutil.md#StructToUrlValues)]
     [[play](https://go.dev/play/p/pFqMkM40w9z)]
 -   **<big>HttpGet<sup>deprecated</sup></big>** : send http get request.
@@ -1093,6 +1103,18 @@ import "github.com/duke-git/lancet/v2/random"
 -   **<big>RandUniqueIntSlice</big>** : generate a slice of random int of length n that do not repeat.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/random.md#RandUniqueIntSlice)]
     [[play](https://go.dev/play/p/uBkRSOz73Ec)]
+-   **<big>RandSymbolChar</big>** : Generate a random symbol char of specified length.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/random.md#RandSymbolChar)]
+    [[play](https://go.dev/play/p/Im6ZJxAykOm)]
+
+-   **<big>RandFloat</big>** : Generate a random float64 number between [min, max) with specific precision.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/random.md#RandFloat)]
+    [[play](https://go.dev/play/p/zbD_tuobJtr)]
+
+-   **<big>RandFloats</big>** : Generate a slice of random float64 numbers of length n that do not repeat.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/random.md#RandFloats)]
+    [[play](https://go.dev/play/p/I3yndUQ-rhh)]
+
 
 <h3 id="retry"> 17. Retry package is for executing a function repeatedly until it was successful or canceled by the context. &nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">index</a></h3>
 
@@ -1141,7 +1163,7 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>Chunk</big>** : creates a slice of elements split into groups the length of size.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/slice.md#Chunk)]
     [[play](https://go.dev/play/p/b4Pou5j2L_C)]
--   **<big>Compact</big>** : creates an slice with all falsey values removed. The values false, nil, 0, and "" are falsey.
+-   **<big>Compact</big>** : creates an slice with all falsy values removed. The values false, nil, 0, and "" are falsy.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/slice.md#Compact)]
     [[play](https://go.dev/play/p/pO5AnxEr3TK)]
 -   **<big>Concat</big>** : creates a new slice concatenating slice with any additional slices.
@@ -1162,9 +1184,12 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>DifferenceWith</big>** : accepts comparator which is invoked to compare elements of slice to values.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/slice.md#DifferenceWith)]
     [[play](https://go.dev/play/p/v2U2deugKuV)]
--   **<big>DeleteAt</big>** : delete the element of slice from specific start index to end index - 1.
+-   **<big>DeleteAt</big>** : delete the element of slice at index.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/slice.md#DeleteAt)]
-    [[play](https://go.dev/play/p/pJ-d6MUWcvK)]
+    [[play](https://go.dev/play/p/800B1dPBYyd)]
+-   **<big>DeleteRange</big>** : delete the element of slice from start index to end index（exclude).
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/slice.md#DeleteRange)]
+    [[play](https://go.dev/play/p/945HwiNrnle)]
 -   **<big>Drop</big>** : drop n elements from the start of a slice.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/slice.md#Drop)]
     [[play](https://go.dev/play/p/jnPO2yQsT8H)]
@@ -1222,7 +1247,7 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>GroupBy</big>** : iterate over elements of the slice, each element will be group by criteria, returns two slices.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/slice.md#GroupBy)]
     [[play](https://go.dev/play/p/QVkPxzPR0iA)]
--   **<big>GroupWith</big>** : return a map composed of keys generated from the resultults of running each element of slice thru iteratee.
+-   **<big>GroupWith</big>** : return a map composed of keys generated from the results of running each element of slice thru iteratee.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/slice.md#GroupWith)]
     [[play](https://go.dev/play/p/ApCvMNTLO8a)]
 -   **<big>IntSlice<sup>deprecated</sup></big>** : convert param to int slice.
@@ -1336,6 +1361,10 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>Partition</big>** : partition all slice elements with the evaluation of the given predicate functions.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/slice.md#Partition)]
     [[play](https://go.dev/play/p/lkQ3Ri2NQhV)]
+-   **<big>Random</big>** : get a random item of slice, return its index, when slice is empty, return -1. 
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/slice.md#Random)]
+    [[play](https://go.dev/play/p/UzpGQptWppw)]
+
 
 <h3 id="stream"> 19. Stream package implements a sequence of elements supporting sequential and operations. this package is an experiment to explore if stream in go can work as the way java does. its function is very limited. &nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">index</a></h3>
 
@@ -1357,7 +1386,7 @@ import "github.com/duke-git/lancet/v2/stream"
 -   **<big>FromRange</big>** : creates a number stream from start to end. both start and end are included. [start, end]
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/stream.md#FromRange)]
     [[play](https://go.dev/play/p/9Ex1-zcg-B-)]
--   **<big>Generate</big>** : creates a stream where each element is generated by the provided generater function.
+-   **<big>Generate</big>** : creates a stream where each element is generated by the provided generator function.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/stream.md#Generate)]
     [[play](https://go.dev/play/p/rkOWL1yA3j9)]
 -   **<big>Concat</big>** : creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.
@@ -1402,10 +1431,10 @@ import "github.com/duke-git/lancet/v2/stream"
 -   **<big>FindLast</big>** : returns the last element of this stream and true, or zero value and false if the stream is empty.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/stream.md#FindLast)]
     [[play](https://go.dev/play/p/WZD2rDAW-2h)]
--   **<big>Max</big>** : returns the maximum element of this stream according to the provided less function. less fuction: a > b
+-   **<big>Max</big>** : returns the maximum element of this stream according to the provided less function. less function: a > b
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/stream.md#Max)]
     [[play](https://go.dev/play/p/fm-1KOPtGzn)]
--   **<big>Min</big>** : returns the minimum element of this stream according to the provided less function. less fuction: a < b
+-   **<big>Min</big>** : returns the minimum element of this stream according to the provided less function. less function: a < b
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/stream.md#Min)]
     [[play](https://go.dev/play/p/vZfIDgGNRe_0)]
 -   **<big>AllMatch</big>** : returns whether all elements of this stream match the provided predicate.
@@ -1433,29 +1462,31 @@ import "github.com/duke-git/lancet/v2/structs"
 #### Function list:
 
 -   **<big>New</big>** : creates a `Struct` instance.
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/structs/struct.md#New)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#New)]
 -   **<big>ToMap</big>** : converts a valid struct to a map.
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/structs/struct.md#ToMap)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#ToMap)]
 -   **<big>Fields</big>** : get all fields of a given struct, that the fields are abstract struct field.
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/structs/struct.md#Fields)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#Fields)]
 -   **<big>IsStruct</big>** : check if the struct is valid.
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/structs/struct.md#IsStruct)]
--   **<big>Tag</big>** : get a `Tag` of the `Field`, `Tag` is a abstract struct field tag
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/structs/field.md#Tag)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#IsStruct)]
+-   **<big>Tag</big>** : get a `Tag` of the `Field`, `Tag` is a abstract struct field tag.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#Tag)]
 -   **<big>Name</big>** : get the field name.
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/structs/field.md#Name)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#Name)]
 -   **<big>Value</big>** : get the `Field` underlying value.
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/structs/field.md#Value)]
--   **<big>Kind</big>** : get the field's kind
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/structs/field.md#Kind)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#Value)]
+-   **<big>Kind</big>** : get the field's kind.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#Kind)]
 -   **<big>IsEmbedded</big>** : check if the field is an embedded field.
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/structs/field.md#IsEmbedded)]
--   **<big>IsExported</big>** : check if the field is exporte
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/structs/field.md#IsExported)]
--   **<big>IsZero</big>** : check if the field is zero value
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/structs/field.md#IsZero)]
--   **<big>IsSlice</big>** : check if the field is a slice
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/structs/field.md#IsSlice)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#IsEmbedded)]
+-   **<big>IsExported</big>** : check if the field is exported.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#IsExported)]
+-   **<big>IsZero</big>** : check if the field is zero value.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#IsZero)]
+-   **<big>IsSlice</big>** : check if the field is a slice.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#IsSlice)]
+-   **<big>IsTargetType</big>** : check if the field is target type.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/struct.md#IsTargetType)]
 
 <h3 id="strutil"> 21. Strutil package contains some functions to manipulate string. &nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">index</a></h3>
 
@@ -1553,6 +1584,7 @@ import "github.com/duke-git/lancet/v2/strutil"
     [[play](https://go.dev/play/p/6zXRH_c0Qd3)]
 -   **<big>IsNotBlank</big>** : checks if a string is not whitespace or not empty.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/strutil.md#IsNotBlank)]
+    [[play](https://go.dev/play/p/e_oJW0RAquA)]
 -   **<big>HasPrefixAny</big>** : checks if a string starts with any of an array of specified strings.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/strutil.md#HasPrefixAny)]
     [[play](https://go.dev/play/p/8UUTl2C5slo)]
@@ -1623,7 +1655,7 @@ import "github.com/duke-git/lancet/v2/tuple"
 
 #### Function list:
 
--   **<big>Tuple2</big>** : represents a 2 elemnets tuple.
+-   **<big>Tuple2</big>** : represents a 2 elements tuple.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Tuple2)]
     [[play](https://go.dev/play/p/3sHVqBQpLYN)]
 -   **<big>Tuple2_Unbox</big>** : returns values in Tuple2.
@@ -1635,7 +1667,7 @@ import "github.com/duke-git/lancet/v2/tuple"
 -   **<big>Unzip2</big>** : create a group of slice from a slice of Tuple2.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Unzip2)]
     [[play](https://go.dev/play/p/KBecr60feXb)]
--   **<big>Tuple3</big>** : represents a 3 elemnets tuple.
+-   **<big>Tuple3</big>** : represents a 3 elements tuple.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Tuple3)]
     [[play](https://go.dev/play/p/FtH2sdCLlCf)]
 -   **<big>Tuple3_Unbox</big>** : returns values in Tuple3.
@@ -1647,7 +1679,7 @@ import "github.com/duke-git/lancet/v2/tuple"
 -   **<big>Unzip3</big>** : create a group of slice from a slice of Tuple3.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Unzip3)]
     [[play](https://go.dev/play/p/bba4cpAa7KO)]
--   **<big>Tuple4</big>** : represents a 4 elemnets tuple.
+-   **<big>Tuple4</big>** : represents a 4 elements tuple.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Tuple4)]
     [[play](https://go.dev/play/p/D2EqDz096tk)]
 -   **<big>Tuple4_Unbox</big>** : returns values in Tuple4.
@@ -1659,7 +1691,7 @@ import "github.com/duke-git/lancet/v2/tuple"
 -   **<big>Unzip4</big>** : create a group of slice from a slice of Tuple4.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Unzip4)]
     [[play](https://go.dev/play/p/rb8z4gyYSRN)]
--   **<big>Tuple5</big>** : represents a 5 elemnets tuple.
+-   **<big>Tuple5</big>** : represents a 5 elements tuple.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Tuple5)]
     [[play](https://go.dev/play/p/2WndmVxPg-r)]
 -   **<big>Tuple5_Unbox</big>** : returns values in Tuple4.
@@ -1671,7 +1703,7 @@ import "github.com/duke-git/lancet/v2/tuple"
 -   **<big>Unzip5</big>** : create a group of slice from a slice of Tuple5.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Unzip5)]
     [[play](https://go.dev/play/p/gyl6vKfhqPb)]
--   **<big>Tuple6</big>** : represents a 6 elemnets tuple.
+-   **<big>Tuple6</big>** : represents a 6 elements tuple.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Tuple6)]
     [[play](https://go.dev/play/p/VjqcCwEJZbs)]
 -   **<big>Tuple6_Unbox</big>** : returns values in Tuple6.
@@ -1683,7 +1715,7 @@ import "github.com/duke-git/lancet/v2/tuple"
 -   **<big>Unzip6</big>** : create a group of slice from a slice of Tuple6.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Unzip6)]
     [[play](https://go.dev/play/p/l41XFqCyh5E)]
--   **<big>Tuple7</big>** : represents a 7 elemnets tuple.
+-   **<big>Tuple7</big>** : represents a 7 elements tuple.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Tuple7)]
     [[play](https://go.dev/play/p/dzAgv_Ezub9)]
 -   **<big>Tuple7_Unbox</big>** : returns values in Tuple7.
@@ -1695,7 +1727,7 @@ import "github.com/duke-git/lancet/v2/tuple"
 -   **<big>Unzip7</big>** : create a group of slice from a slice of Tuple7.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Unzip7)]
     [[play](https://go.dev/play/p/hws_P1Fr2j3)]
--   **<big>Tuple8</big>** : represents a 8 elemnets tuple.
+-   **<big>Tuple8</big>** : represents a 8 elements tuple.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Tuple8)]
     [[play](https://go.dev/play/p/YA9S0rz3dRz)]
 -   **<big>Tuple8_Unbox</big>** : returns values in Tuple8.
@@ -1707,7 +1739,7 @@ import "github.com/duke-git/lancet/v2/tuple"
 -   **<big>Unzip8</big>** : create a group of slice from a slice of Tuple8.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Unzip8)]
     [[play](https://go.dev/play/p/1SndOwGsZB4)]
--   **<big>Tuple9</big>** : represents a 9 elemnets tuple.
+-   **<big>Tuple9</big>** : represents a 9 elements tuple.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Tuple9)]
     [[play](https://go.dev/play/p/yS2NGGtZpQr)]
 -   **<big>Tuple9_Unbox</big>** : returns values in Tuple9.
@@ -1719,7 +1751,7 @@ import "github.com/duke-git/lancet/v2/tuple"
 -   **<big>Unzip9</big>** : create a group of slice from a slice of Tuple9.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Unzip9)]
     [[play](https://go.dev/play/p/91-BU_KURSA)]
--   **<big>Tuple10</big>** : represents a 10 elemnets tuple.
+-   **<big>Tuple10</big>** : represents a 10 elements tuple.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/tuple.md#Tuple10)]
     [[play](https://go.dev/play/p/799qqZg0hUv)]
 -   **<big>Tuple10_Unbox</big>** : returns values in Tuple10.
@@ -1851,19 +1883,19 @@ import "github.com/duke-git/lancet/v2/validator"
 -   **<big>IsJWT</big>** : check if a give string is a valid JSON Web Token (JWT).
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/validator.md#IsJWT)]
     [[play](https://go.dev/play/p/R6Op7heJbKI)]
--   **<big>IsVisa</big>** : check if a give string is a valid visa card nubmer or not.
+-   **<big>IsVisa</big>** : check if a give string is a valid visa card number or not.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/validator.md#IsVisa)]
     [[play](https://go.dev/play/p/SdS2keOyJsl)]
--   **<big>IsMasterCard</big>** : check if a give string is a valid master card nubmer or not.
+-   **<big>IsMasterCard</big>** : check if a give string is a valid master card number or not.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/validator.md#IsMasterCard)]
     [[play](https://go.dev/play/p/CwWBFRrG27b)]
--   **<big>IsAmericanExpress</big>** : check if a give string is a valid american expression card nubmer or not.
+-   **<big>IsAmericanExpress</big>** : check if a give string is a valid american expression card number or not.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/validator.md#IsAmericanExpress)]
     [[play](https://go.dev/play/p/HIDFpcOdpkd)]
--   **<big>IsUnionPay</big>** : check if a give string is a valid union pay nubmer or not.
+-   **<big>IsUnionPay</big>** : check if a give string is a valid union pay number or not.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/validator.md#IsUnionPay)]
     [[play](https://go.dev/play/p/CUHPEwEITDf)]
--   **<big>IsChinaUnionPay</big>** : check if a give string is a valid china union pay nubmer or not.
+-   **<big>IsChinaUnionPay</big>** : check if a give string is a valid china union pay number or not.
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/en/api/packages/validator.md#IsChinaUnionPay)]
     [[play](https://go.dev/play/p/yafpdxLiymu)]
 
@@ -1919,22 +1951,6 @@ import "github.com/duke-git/lancet/v2/xerror"
 
 #### [Contributing Guide](./CONTRIBUTING.en-US.md)
 
-
-## Sponsor
-
-Hello, I am a software developer and have been engaged in development work for 13 years. Love open source software. And be willing to put in the energy for it. I am the creator of project lancet. Since Lancet was released as open source two years ago, it has been used by more than 1,000 internal and external projects. lancet will always be free for all users. Your support is a powerful encouragement for me to continue my struggle. Thanks! You can use WeChat to scans the following QR code or clicks the following sponsor button to initiate sponsorship.
-
-<div style="position: relative;display: inline-block;">
-    <img src="./docs/public/wechat_pay.png" width="260" height="260"/>
-    <a href="https://en.liberapay.com/Duke_Du/donate" target="\_blank"><img src="./docs/public/sponsor_btn.png" width="220" height="60"/></a>
-</div>
-
-<br/>
-<br/>
-
-*Donated funds will be used to maintain [lancet](https://www.golancet.cn/en/) website and pay for cloud server costs. Or just buy me a cup of ☕️ when I'm sleepy writing code.*
-
-
 ## Contributors
 Thank you to all the people who contributed to lancet!
 

README_zh-CN.md

@@ -4,7 +4,7 @@
 <br/>
 
 ![Go version](https://img.shields.io/badge/go-%3E%3Dv1.18-9cf)
-[![Release](https://img.shields.io/badge/release-2.2.7-green.svg)](https://github.com/duke-git/lancet/releases)
+[![Release](https://img.shields.io/badge/release-2.2.9-green.svg)](https://github.com/duke-git/lancet/releases)
 [![GoDoc](https://godoc.org/github.com/duke-git/lancet/v2?status.svg)](https://pkg.go.dev/github.com/duke-git/lancet/v2)
 [![Go Report Card](https://goreportcard.com/badge/github.com/duke-git/lancet/v2)](https://goreportcard.com/report/github.com/duke-git/lancet/v2)
 [![test](https://github.com/duke-git/lancet/actions/workflows/codecov.yml/badge.svg?branch=main&event=push)](https://github.com/duke-git/lancet/actions/workflows/codecov.yml)
@@ -453,10 +453,14 @@ import "github.com/duke-git/lancet/v2/cryptor"
     [[play](https://go.dev/play/p/uef0q1fz53I)]
 -   **<big>GenerateRsaKeyPair</big>** : 创建rsa公钥私钥和key。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/cryptor.md#GenerateRsaKeyPair)]
+    [[play](https://go.dev/play/p/sSVmkfENKMz)]
 -   **<big>RsaEncryptOAEP</big>** : rsa OAEP加密。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/cryptor.md#RsaEncryptOAEP)]
+    [[play](https://go.dev/play/p/sSVmkfENKMz)]
 -   **<big>RsaDecryptOAEP</big>** : rsa OAEP解密。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/cryptor.md#RsaDecryptOAEP)]
+    [[play](https://go.dev/play/p/sSVmkfENKMz)]
+
 
 <h3 id="datetime"> 7. datetime 日期时间处理包，格式化日期，比较日期。&nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">回到目录</a></h3>
 
@@ -568,9 +572,6 @@ import "github.com/duke-git/lancet/v2/datetime"
 -   **<big>IsLeapYear</big>** :验证是否是闰年。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/datetime.md#IsLeapYear)]
     [[play](https://go.dev/play/p/xS1eS2ejGew)]
--   **<big>IsLeapYear</big>** : check if param `year` is leap year or not.
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/datetime.md#IsLeapYear)]
-    [[play](https://go.dev/play/p/xS1eS2ejGew)]
 -   **<big>BetweenSeconds</big>** : 返回两个时间的间隔秒数。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/datetime.md#BetweenSeconds)]
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/datetime.md#BetweenSeconds)]
@@ -704,9 +705,11 @@ import "github.com/duke-git/lancet/v2/fileutil"
 -   **<big>ReadCsvFile</big>** : 读取 csv 文件内容到切片。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/fileutil.md#ReadCsvFile)]
     [[play](https://go.dev/play/p/OExTkhGEd3_u)]
--   **<big>WriteCsvFile</big>** : 向 csv 文件写入内容。
+-   **<big>WriteCsvFile</big>** : 向csv文件写入切片数据。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/fileutil.md#WriteCsvFile)]
-    [[play](https://go.dev/play/p/dAXm58Q5U1o)]
+-   **<big>WriteMapsToCsv</big>** : 将map切片写入csv文件中。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/fileutil.md#WriteMapsToCsv)]
+    [[play](https://go.dev/play/p/umAIomZFV1c)]
 -   **<big>WriteBytesToFile</big>** : 将 bytes 写入文件。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/fileutil.md#WriteBytesToFile)]
     [[play](https://go.dev/play/p/s7QlDxMj3P8)]
@@ -1097,6 +1100,16 @@ import "github.com/duke-git/lancet/v2/random"
 -   **<big>RandUniqueIntSlice</big>** : 生成一个不重复的长度为 n 的随机 int 切片。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/random.md#RandUniqueIntSlice)]
     [[play](https://go.dev/play/p/uBkRSOz73Ec)]
+-   **<big>RandSymbolChar</big>** : 生成给定长度的随机符号字符串。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/random.md#RandSymbolChar)]
+    [[play](https://go.dev/play/p/Im6ZJxAykOm)]
+-   **<big>RandFloat</big>** : 生成随机float64数字，可以指定范围和精度。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/random.md#RandFloat)]
+    [[play](https://go.dev/play/p/zbD_tuobJtr)]
+-   **<big>RandFloats</big>** : 生成随机float64数字切片，可以指定长度，范围和精度.
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/random.md#RandFloats)]
+    [[play](https://go.dev/play/p/uBkRSOz73Ec)]
+
 
 <h3 id="retry"> 17. retry 重试执行函数直到函数运行成功或被 context cancel。&nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">回到目录</a></h3>
 
@@ -1122,7 +1135,7 @@ import "github.com/duke-git/lancet/v2/retry"
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/retry.md#RetryTimes)]
     [[play](https://go.dev/play/p/ssfVeU2SwLO)]
 
-<h3 id="slice"> 18. slice 包含操作切片的方法集合。&nbsp; &nbsp; &nbsp; &nbsp; [回到目录](#index)
+<h3 id="slice"> 18. slice 包含操作切片的方法集合。&nbsp; &nbsp; &nbsp; &nbsp; <a href="#index">回到目录</a></h3>
 
 ```go
 import "github.com/duke-git/lancet/v2/slice"
@@ -1166,9 +1179,12 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>DifferenceWith</big>** : 接受比较器函数，该比较器被调用以将切片的元素与值进行比较。 结果值的顺序和引用由第一个切片确定。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/slice.md#DifferenceWith)]
     [[play](https://go.dev/play/p/v2U2deugKuV)]
--   **<big>DeleteAt</big>** : 删除切片中指定开始索引到结束索引的元素。
+-   **<big>DeleteAt</big>** : 删除切片中指定索引到的元素。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/slice.md#DeleteAt)]
-    [[play](https://go.dev/play/p/pJ-d6MUWcvK)]
+    [[play](https://go.dev/play/p/800B1dPBYyd)]
+-   **<big>DeleteRange</big>** : 删除切片中指定开始索引到结束索引的元素。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/slice.md#DeleteRange)]
+    [[play](https://go.dev/play/p/945HwiNrnle)]
 -   **<big>Drop</big>** : 从切片头部删除 n 个元素。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/slice.md#Drop)]
     [[play](https://go.dev/play/p/jnPO2yQsT8H)]
@@ -1331,7 +1347,6 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>Without</big>** : 创建一个不包括所有给定值的切片。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/slice.md#Without)]
     [[play](https://go.dev/play/p/bwhEXEypThg)]
--   **<big>KeyBy</big>** :将切片每个元素调用函数后转为 map。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/slice.md#KeyBy)]
     [[play](https://go.dev/play/p/uXod2LWD1Kg)]
 -   **<big>Join</big>** : 用指定的分隔符链接切片元素。
@@ -1340,6 +1355,11 @@ import "github.com/duke-git/lancet/v2/slice"
 -   **<big>Partition</big>** : 根据给定的predicate判断函数分组切片元素。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/slice.md#Partition)]
     [[play](https://go.dev/play/p/lkQ3Ri2NQhV)]
+-   **<big>Random</big>** : 随机返回切片中元素以及下标, 当切片长度为0时返回下标-1。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/slice.md#Random)]
+    [[play](https://go.dev/play/p/UzpGQptWppw)]
+
+
 
 <h3 id="stream"> 19. stream 流，该包仅验证简单的 stream 实现，功能有限。&nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">回到目录</a></h3>
 
@@ -1437,31 +1457,33 @@ import "github.com/duke-git/lancet/v2/structs"
 #### 函数列表:
 
 -   **<big>New</big>** : `Struct`结构体的构造函数。
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/structs/struct.md#New)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#New)]
 -   **<big>ToMap</big>** : 将一个合法的 struct 对象转换为 map[string]any。
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/structs/struct.md#ToMap)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#ToMap)]
 -   **<big>Fields</big>** : 获取一个 struct 对象的属性列表。
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/structs/struct.md#Fields)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#Fields)]
 -   **<big>Field</big>** : 根据属性名获取一个 struct 对象的属性。
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/structs/struct.md#Fields)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#Fields)]
 -   **<big>IsStruct</big>** : 判断是否为一个合法的 struct 对象。
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/structs/struct.md#IsStruct)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#IsStruct)]
 -   **<big>Tag</big>** : 获取`Field`的`Tag`，默认的 tag key 是 json。
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/structs/field.md#Tag)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#Tag)]
 -   **<big>Name</big>** : 获取属性名。
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/structs/field.md#Name)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#Name)]
 -   **<big>Value</big>** : 获取`Field`属性的值。
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/structs/field.md#Value)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#Value)]
 -   **<big>Kind</big>** : 获取属性 Kind。
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/structs/field.md#Kind)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#Kind)]
 -   **<big>IsEmbedded</big>** : 判断属性是否为嵌入。
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/structs/field.md#IsEmbedded)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#IsEmbedded)]
 -   **<big>IsExported</big>** : 判断属性是否导出。
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/structs/field.md#IsExported)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#IsExported)]
 -   **<big>IsZero</big>** : 判断属性是否为零值。
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/structs/field.md#IsZero)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#IsZero)]
 -   **<big>IsSlice</big>** : 判断属性是否是切片。
-    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/structs/field.md#IsSlice)]
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#IsSlice)]
+-   **<big>IsTargetType</big>** : 判断属性是否是目标类型。
+    [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/struct.md#IsTargetType)]
 
 <h3 id="strutil"> 21. strutil 包含字符串处理的相关函数。&nbsp; &nbsp; &nbsp; &nbsp;<a href="#index">回到目录</a></h3>
 
@@ -1560,6 +1582,7 @@ import "github.com/duke-git/lancet/v2/strutil"
     [[play](https://go.dev/play/p/6zXRH_c0Qd3)]
 -   **<big>IsNotBlank</big>** : 检查字符串是否不为空。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/strutil.md#IsNotBlank)]
+    [[play](https://go.dev/play/p/e_oJW0RAquA)]
 -   **<big>HasPrefixAny</big>** : 检查字符串是否以指定字符串数组中的任何一个开头。
     [[doc](https://github.com/duke-git/lancet/blob/main/docs/api/packages/strutil.md#HasPrefixAny)]
     [[play](https://go.dev/play/p/8UUTl2C5slo)]
@@ -1925,23 +1948,9 @@ import "github.com/duke-git/lancet/v2/xerror"
 
 #### [贡献代码指南](./CONTRIBUTING.zh-CN.md)
 
-## 赞助
-
-您好，我是一名软件开发者，从事开发工作 13 年。热爱软件开源。并愿意为此付出精力。是开源项目 lancet 的作者。Lancet 自两年前开源发布以来，已有超过 1000 个内外部项目使用。lancet 一直会对所有用户免费。您的支持是对我继续奋斗的有力鼓励。谢谢! 微信扫描以下二维码或点击以下赞助按钮发起赞助。
-
-<div style="position: relative;display: inline-block;">
-    <img src="./docs/public/wechat_pay.png" width="260" height="260"/>
-    <a href="https://liberapay.com/Duke_Du/donate" target="\_blank"><img src="./docs/public/sponsor_btn.png" width="220" height="60"/></a>
-</div>
-
-<br/>
-<br/>
-
-_捐赠的资金将用于后续[lancet](https://www.golancet.cn/)官网的维护和云服务器的费用支付。或者当我写代码困倦时，给我买杯 ☕️。_
-
 ## 贡献者
 
-感谢所有为 lancet 贡献过代码的人！
+感谢所有为lancet贡献过代码的人！
 
 <a href="https://github.com/duke-git/lancet/graphs/contributors">
   <img src="https://contrib.rocks/image?repo=duke-git/lancet" />

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

cryptor/crypto.go

@@ -508,14 +508,14 @@ func RsaDecrypt(data []byte, privateKeyFileName string) []byte {
 }
 
 // GenerateRsaKeyPair create rsa private and public key.
-// Play: todo
+// 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: todo
+// 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 {
@@ -526,7 +526,7 @@ func RsaEncryptOAEP(data []byte, label []byte, key rsa.PublicKey) ([]byte, error
 }
 
 // RsaDecryptOAEP decrypts the data with RSA-OAEP.
-// Play: todo
+// 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 {

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/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
-func NewSet[T comparable](items ...T) Set[T] {
+// New create a instance of set from given values.
+func New[T comparable](items ...T) Set[T] {
 	set := make(Set[T])
 	set.Add(items...)
 	return set
 }
 
-// NewSetFromSlice create a set from slice
-func NewSetFromSlice[T comparable](items []T) Set[T] {
+// FromSlice create a set from given slice.
+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)
-	set2 := NewSet(1, 2)
-	set3 := NewSet(1, 2, 3, 4)
+	set1 := New(1, 2, 3)
+	set2 := New(1, 2)
+	set3 := New(1, 2, 3, 4)
 
 	assert.Equal(true, set1.ContainAll(set2))
 	assert.Equal(false, set1.ContainAll(set3))
@@ -100,7 +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)
-	set2 := NewSet(1, 2, 3)
-	set3 := NewSet(1, 2, 3, 4)
+	set1 := New(1, 2, 3)
+	set2 := New(1, 2, 3)
+	set3 := New(1, 2, 3, 4)
 
 	assert.Equal(true, set1.Equal(set2))
 	assert.Equal(false, set1.Equal(set3))
@@ -137,7 +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)
-	set2 := NewSet(2, 3, 4, 5)
+	set1 := New(1, 2, 3)
+	set2 := New(2, 3, 4, 5)
 
 	unionSet := set1.Union(set2)
 
-	assert.Equal(NewSet(1, 2, 3, 4, 5), unionSet)
+	assert.Equal(New(1, 2, 3, 4, 5), unionSet)
 }
 
 func TestSet_Intersection(t *testing.T) {
@@ -193,11 +193,11 @@ func TestSet_Intersection(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Intersection")
 
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
+	set1 := New(1, 2, 3)
+	set2 := New(2, 3, 4, 5)
 	intersectionSet := set1.Intersection(set2)
 
-	assert.Equal(NewSet(2, 3), intersectionSet)
+	assert.Equal(New(2, 3), intersectionSet)
 }
 
 func TestSet_SymmetricDifference(t *testing.T) {
@@ -205,10 +205,10 @@ func TestSet_SymmetricDifference(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_SymmetricDifference")
 
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
+	set1 := New(1, 2, 3)
+	set2 := New(2, 3, 4, 5)
 
-	assert.Equal(NewSet(1, 4, 5), set1.SymmetricDifference(set2))
+	assert.Equal(New(1, 4, 5), set1.SymmetricDifference(set2))
 }
 
 func TestSet_Minus(t *testing.T) {
@@ -216,16 +216,16 @@ func TestSet_Minus(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSet_Minus")
 
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
-	set3 := NewSet(2, 3)
+	set1 := New(1, 2, 3)
+	set2 := New(2, 3, 4, 5)
+	set3 := New(2, 3)
 
-	assert.Equal(NewSet(1), set1.Minus(set2))
-	assert.Equal(NewSet(4, 5), set2.Minus(set3))
+	assert.Equal(New(1), set1.Minus(set2))
+	assert.Equal(New(4, 5), set2.Minus(set3))
 }
 
 func TestEachWithBreak(t *testing.T) {
-	// s := NewSet(1, 2, 3, 4, 5)
+	// s := New(1, 2, 3, 4, 5)
 
 	// var sum int
 
@@ -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/api/packages/algorithm.md

@@ -43,12 +43,12 @@ 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>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GNdv7Jg2Taj)</span></b>
@@ -91,12 +91,12 @@ 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>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/G5LJiWgJJW6)</span></b>
@@ -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,12 +154,12 @@ 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>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/oXovbkekayS)</span></b>
@@ -202,12 +202,12 @@ 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>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3ibkszpJEu3)</span></b>
@@ -250,12 +250,12 @@ 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>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/7Y7c1Elk3ax)</span></b>
@@ -298,12 +298,12 @@ 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>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/u6Iwa1VZS_f)</span></b>
@@ -346,12 +346,12 @@ 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>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ydinn9YzUJn)</span></b>
@@ -394,12 +394,12 @@ 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>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tB-Umgm0DrP)</span></b>
@@ -443,12 +443,12 @@ 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>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/t6MeGiUSN47)</span></b>
@@ -494,12 +494,12 @@ 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>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Anozfr8ZLH3)</span></b>

docs/api/packages/cryptor.md

@@ -1437,7 +1437,7 @@ func main() {
 func GenerateRsaKeyPair(keySize int) (*rsa.PrivateKey, *rsa.PublicKey)
 ```
 
-<b>示例:></b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sSVmkfENKMz)</span></b>
 
 ```go
 package main
@@ -1462,7 +1462,7 @@ func main() {
 func RsaEncryptOAEP(data []byte, label []byte, key rsa.PublicKey) ([]byte, error)
 ```
 
-<b>示例:></b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sSVmkfENKMz)</span></b>
 
 ```go
 package main
@@ -1505,7 +1505,7 @@ func main() {
 func RsaDecryptOAEP(ciphertext []byte, label []byte, key rsa.PrivateKey) ([]byte, error)
 ```
 
-<b>示例:></b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sSVmkfENKMz)</span></b>
 
 ```go
 package main

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/heap.md

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

docs/api/packages/datastructure/optional.md

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

docs/api/packages/datastructure/queue.md

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

docs/api/packages/datastructure/set.md

@@ -1,6 +1,6 @@
 # Set
 
-Set 集合数据结构，类似列表。Set 中元素不重复。
+集合数据结构，类似列表。Set中元素不重复。
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -22,8 +22,8 @@ import (
 
 ## 目录
 
--   [NewSet](#NewSet)
--   [NewSetFromSlice](#NewSetFromSlice)
+-   [New](#New)
+-   [FromSlice](#FromSlice)
 -   [Values](#Values)
 -   [Add](#Add)
 -   [AddIfNotExist](#AddIfNotExist)
@@ -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)
-    set2 := set.NewSet(1, 2)
-    set3 := set.NewSet(1, 2, 3, 4)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(1, 2)
+    set3 := set.New(1, 2, 3, 4)
 
     fmt.Println(set1.ContainAll(set2)) //true
     fmt.Println(set1.ContainAll(set3)) //false
@@ -333,7 +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)
-    set2 := set.NewSet(1, 2, 3)
-    set3 := set.NewSet(1, 2, 3, 4)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(1, 2, 3)
+    set3 := set.New(1, 2, 3, 4)
 
     fmt.Println(set1.Equal(set2)) //true
     fmt.Println(set1.Equal(set3)) //false
@@ -419,7 +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)
-    set2 := set.NewSet()
+    set1 := set.New(1, 2, 3)
+    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)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.Union(set2)
 
     fmt.Println(set3.Values()) //1,2,3,4,5
@@ -545,8 +545,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.Intersection(set2)
 
     fmt.Println(set3.Values()) //2,3
@@ -574,8 +574,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.SymmetricDifference(set2)
 
     fmt.Println(set3.Values()) //1,4,5
@@ -603,9 +603,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
-    set3 := set.NewSet(2, 3)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
+    set3 := set.New(2, 3)
 
     res1 := set1.Minus(set2)
     fmt.Println(res1.Values()) //1
@@ -636,7 +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/fileutil.md

@@ -26,6 +26,7 @@ import (
 -   [CreateFile](#CreateFile)
 -   [CreateDir](#CreateDir)
 -   [CopyFile](#CopyFile)
+-   [CopyDir](#CopyDir)
 -   [CurrentPath](#CurrentPath)
 -   [FileMode](#FileMode)
 -   [MiMeType](#MiMeType)
@@ -45,6 +46,7 @@ import (
 -   [Sha](#Sha)
 -   [ReadCsvFile](#ReadCsvFile)
 -   [WriteCsvFile](#WriteCsvFile)
+-   [WriteMapsToCsv](#WriteMapsToCsv)
 -   [WriteStringToFile](#WriteStringToFile)
 -   [WriteBytesToFile](#WriteBytesToFile)
 -   [ReadFile](#ReadFile)
@@ -161,6 +163,34 @@ func main() {
 }
 ```
 
+### <span id="CopyDir">CopyDir</span>
+
+<p>拷贝文件夹到目标路径，会递归复制文件夹下所有的文件及文件夹，并且访问权限也与源文件夹保持一致。当dstPath存在时会返回error</p>
+
+<b>函数签名:</b>
+
+```go
+func CopyDir(srcPath string, dstPath string) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YAyFTA_UuPb)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    err := fileutil.CopyFile("./test_src", "./test_dest")
+    if err != nil {
+        fmt.Println(err)
+    }
+}
+```
+
 ### <span id="CurrentPath">CurrentPath</span>
 
 <p>返回当前位置的绝对路径。</p>
@@ -669,7 +699,7 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func ReadCsvFile(filepath string) ([][]string, error)
+func ReadCsvFile(filepath string, delimiter ...rune) ([][]string, error)
 ```
 
 <b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OExTkhGEd3_u)</span></b>
@@ -701,7 +731,7 @@ 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>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dAXm58Q5U1o)</span></b>
@@ -743,6 +773,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>
@@ -843,7 +926,7 @@ func main() {
 
 ### <span id="ReadFile">ReadFile</span>
 
-<p>读取文件或者URL</p>
+<p>读取文件或者URL。</p>
 
 <b>函数签名:</b>
 
@@ -851,7 +934,7 @@ func main() {
 func ReadFile(path string) (reader io.ReadCloser, closeFn func(), err error) 
 ```
 
-<b>示例:<span style="float:right;display:inline-block;"></span></b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uNep3Tr8fqF)</span></b>
 
 ```go
 package main
@@ -862,19 +945,19 @@ import (
 )
 
 func main() {
-   reader, fn, err := ReadFile("https://httpbin.org/robots.txt")
-	if err != nil {
-		return
-	}
-	defer fn()
+    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
+    dat, err := io.ReadAll(reader)
+    if err != nil {
+        return
+    }
+    fmt.Println(string(dat))
+    // Output:
+    // User-agent: *
+    // Disallow: /deny
 }
 ```

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,12 @@ import (
 -   [Schedule](#Schedule)
 -   [Pipeline](#Pipeline)
 -   [Watcher](#Watcher)
+-   [And](#And)
+-   [Or](#Or)
+-   [Negate](#Negate)
+-   [Nor](#Nor)
+-   [Xnor](#Xnor)
+-   [Nand](#Nand)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -404,3 +411,231 @@ 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
+}
+```
+
+### <span id="Nand">Nand</span>
+
+<p>返回一个复合谓词函数，表示给定谓词函数列表的逻辑非与 (NAND)。仅当列表中所有函数对给定参数返回false时，才返回true，否则返回false。</p>
+
+<b>函数签名:</b>
+
+```go
+func Nand[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    isNumericAndLength5 := function.Nand(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return len(s) == 5 },
+    )
+
+    fmt.Println(isNumericAndLength5("12345"))
+    fmt.Println(isNumericAndLength5("1234"))
+    fmt.Println(isNumericAndLength5("abcdef"))
+
+    // Output:
+    // false
+    // false
+    // true
+}
+```
+
+### <span id="Xnor">Xnor</span>
+
+<p>返回一个复合谓词函数，表示给定一组谓词函数的逻辑异或 (XNOR)。只有当所有 谓词函数对给参数都返回true或false时，该谓词函数才返回true。</p>
+
+<b>函数签名:</b>
+
+```go
+func Xnor[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    isEven := func(i int) bool { return i%2 == 0 }
+    isPositive := func(i int) bool { return i > 0 }
+
+    match := function.Xnor(isEven, isPositive)
+
+    fmt.Println(match(2))
+    fmt.Println(match(-3))
+    fmt.Println(match(3))
+
+    // Output:
+    // true
+    // true
+    // false
+}
+```

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>
 
@@ -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>
@@ -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/slice.md

@@ -35,6 +35,7 @@ import (
 -   [DifferenceBy](#DifferenceBy)
 -   [DifferenceWith](#DifferenceWith)
 -   [DeleteAt](#DeleteAt)
+-   [DeleteRange](#DeleteRange)
 -   [Drop](#Drop)
 -   [DropRight](#DropRight)
 -   [DropWhile](#DropWhile)
@@ -516,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>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pJ-d6MUWcvK)</span></b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/800B1dPBYyd)</span></b>
 
 ```go
 import (
@@ -533,18 +534,66 @@ import (
 )
 
 func main() {
-    result1 := slice.DeleteAt([]string{"a", "b", "c"}, -1)
-    result2 := slice.DeleteAt([]string{"a", "b", "c"}, 0)
-    result3 := slice.DeleteAt([]string{"a", "b", "c"}, 0, 2)
+    chars := []string{"a", "b", "c", "d", "e"}
+
+    result1 := slice.DeleteAt(chars, 0)
+    result2 := slice.DeleteAt(chars, 4)
+    result3 := slice.DeleteAt(chars, 5)
+    result4 := slice.DeleteAt(chars, 6)
 
     fmt.Println(result1)
     fmt.Println(result2)
     fmt.Println(result3)
+    fmt.Println(result4)
 
     // Output:
-    // [a b c]
-    // [b c]
-    // [c]
+    // [b c d e]
+    // [a b c d]
+    // [a b c d]
+    // [a b c d]
+
+}
+```
+
+### <span id="DeleteRange">DeleteRange</span>
+
+<p>删除切片中指定索引范围的元素（不修改原切片）。</p>
+
+<b>函数签名:</b>
+
+```go
+func DeleteRange[T any](slice []T, start, end int) []T 
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/945HwiNrnle)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    chars := []string{"a", "b", "c", "d", "e"}
+
+    result1 := DeleteRange(chars, 0, 0)
+    result2 := DeleteRange(chars, 0, 1)
+    result3 := DeleteRange(chars, 0, 3)
+    result4 := DeleteRange(chars, 0, 4)
+    result5 := DeleteRange(chars, 0, 5)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+
+    // Output:
+    // [a b c d e]
+    // [b c d e]
+    // [d e]
+    // [e]
+    // []
 
 }
 ```
@@ -2475,17 +2524,48 @@ import (
 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 })
+    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)
+    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]]
+    // 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/struct.md

@@ -37,6 +37,7 @@ import (
 -   [IsExported](#IsExported)
 -   [IsZero](#IsZero)
 -   [IsSlice](#IsSlice)
+-   [IsTargetType](#IsTargetType)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -531,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

@@ -60,6 +60,7 @@ import (
 -   [ContainsAll](#ContainsAll)
 -   [ContainsAny](#ContainsAny)
 -   [RemoveWhiteSpace](#RemoveWhiteSpace)
+-   [SubInBetween](#SubInBetween)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -1080,13 +1081,13 @@ func main() {
 
 <p>Checks if a string is not whitespace or not empty.</p>
 
-<b>Signature:</b>
+<b>函数签名:</b>
 
 ```go
 func IsNotBlank(str string) bool
 ```
 
-<b>Example:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/e_oJW0RAquA)</span></b>
 
 ```go
 import (
@@ -1095,11 +1096,11 @@ import (
 )
 
 func main() {
-    result1 := IsNotBlank("")
-    result2 := IsNotBlank("	")
-    result3 := IsNotBlank("\t\v\f\n")
-    result4 := IsNotBlank(" 中文")
-    result5 := IsNotBlank(" 	world	")
+    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)
@@ -1462,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/en/api/packages/algorithm.md

@@ -43,12 +43,12 @@ 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: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/GNdv7Jg2Taj)</span></b>
@@ -91,12 +91,12 @@ 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: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/G5LJiWgJJW6)</span></b>
@@ -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,12 +154,12 @@ 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: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/oXovbkekayS)</span></b>
@@ -202,12 +202,12 @@ 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: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/3ibkszpJEu3)</span></b>
@@ -250,12 +250,12 @@ 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:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/7Y7c1Elk3ax)</span></b>
@@ -298,12 +298,12 @@ 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: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/u6Iwa1VZS_f)</span></b>
@@ -346,12 +346,12 @@ 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: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ydinn9YzUJn)</span></b>
@@ -394,12 +394,12 @@ 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: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tB-Umgm0DrP)</span></b>
@@ -448,7 +448,7 @@ 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: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/t6MeGiUSN47)</span></b>
@@ -499,7 +499,7 @@ 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: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Anozfr8ZLH3)</span></b>

docs/en/api/packages/cryptor.md

@@ -1437,7 +1437,7 @@ func main() {
 func GenerateRsaKeyPair(keySize int) (*rsa.PrivateKey, *rsa.PublicKey)
 ```
 
-<b>Example:></b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/sSVmkfENKMz)</span></b>
 
 ```go
 package main
@@ -1462,7 +1462,7 @@ func main() {
 func RsaEncryptOAEP(data []byte, label []byte, key rsa.PublicKey) ([]byte, error)
 ```
 
-<b>Example:></b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/sSVmkfENKMz)</span></b>
 
 ```go
 package main
@@ -1505,7 +1505,7 @@ func main() {
 func RsaDecryptOAEP(ciphertext []byte, label []byte, key rsa.PrivateKey) ([]byte, error)
 ```
 
-<b>Example:></b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/sSVmkfENKMz)</span></b>
 
 ```go
 package main

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/heap.md

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

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

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

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

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

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

@@ -22,8 +22,8 @@ import (
 
 ## Index
 
--   [NewSet](#NewSet)
--   [NewSetFromSlice](#NewSetFromSlice)
+-   [New](#New)
+-   [FromSlice](#FromSlice)
 -   [Values](#Values)
 -   [Add](#Add)
 -   [AddIfNotExist](#AddIfNotExist)
@@ -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)
-    set2 := set.NewSet(1, 2)
-    set3 := set.NewSet(1, 2, 3, 4)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(1, 2)
+    set3 := set.New(1, 2, 3, 4)
 
     fmt.Println(set1.ContainAll(set2)) //true
     fmt.Println(set1.ContainAll(set3)) //false
@@ -334,7 +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)
-    set2 := set.NewSet(1, 2, 3)
-    set3 := set.NewSet(1, 2, 3, 4)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(1, 2, 3)
+    set3 := set.New(1, 2, 3, 4)
 
     fmt.Println(set1.Equal(set2)) //true
     fmt.Println(set1.Equal(set3)) //false
@@ -420,7 +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)
-    set2 := set.NewSet()
+    set1 := set.New(1, 2, 3)
+    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)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.Union(set2)
 
     fmt.Println(set3.Values()) //1,2,3,4,5
@@ -546,8 +546,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.Intersection(set2)
 
     fmt.Println(set3.Values()) //2,3
@@ -575,8 +575,8 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
     set3 := set1.SymmetricDifference(set2)
 
     fmt.Println(set3.Values()) //1,4,5
@@ -604,9 +604,9 @@ import (
 )
 
 func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
-    set3 := set.NewSet(2, 3)
+    set1 := set.New(1, 2, 3)
+    set2 := set.New(2, 3, 4, 5)
+    set3 := set.New(2, 3)
 
     res1 := set1.Minus(set2)
     fmt.Println(res1.Values()) //1
@@ -637,7 +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/fileutil.md

@@ -26,6 +26,7 @@ import (
 -   [CreateFile](#CreateFile)
 -   [CreateDir](#CreateDir)
 -   [CopyFile](#CopyFile)
+-   [CopyDir](#CopyDir)
 -   [CurrentPath](#CurrentPath)
 -   [FileMode](#FileMode)
 -   [MiMeType](#MiMeType)
@@ -45,6 +46,7 @@ import (
 -   [Sha](#Sha)
 -   [ReadCsvFile](#ReadCsvFile)
 -   [WriteCsvFile](#WriteCsvFile)
+-   [WriteMapsToCsv](#WriteMapsToCsv)
 -   [WriteStringToFile](#WriteStringToFile)
 -   [WriteBytesToFile](#WriteBytesToFile)
 -   [ReadFile](#ReadFile)
@@ -161,6 +163,34 @@ func main() {
 }
 ```
 
+### <span id="CopyDir">CopyDir</span>
+
+<p>copy	src directory to dst directory, it will copy all files and directories recursively. the access permission will be the same as the source directory. if dstPath exists, it will return an error.</p>
+
+<b>Signature:</b>
+
+```go
+func CopyDir(srcPath string, dstPath string) error
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/YAyFTA_UuPb)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    err := fileutil.CopyFile("./test_src", "./test_dest")
+    if err != nil {
+        fmt.Println(err)
+    }
+}
+```
+
 ### <span id="CurrentPath">CurrentPath</span>
 
 <p>return current absolute path.</p>
@@ -669,7 +699,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func ReadCsvFile(filepath string) ([][]string, error)
+func ReadCsvFile(filepath string, delimiter ...rune) ([][]string, error)
 ```
 
 <b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/OExTkhGEd3_u)</span></b>
@@ -701,7 +731,7 @@ 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:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/dAXm58Q5U1o)</span></b>
@@ -743,6 +773,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>
@@ -843,7 +926,7 @@ func main() {
 
 ### <span id="ReadFile">ReadFile</span>
 
-<p>Read File/URL</p>
+<p>Read File or URL.</p>
 
 <b>Signature:</b>
 
@@ -851,7 +934,7 @@ func main() {
 func ReadFile(path string) (reader io.ReadCloser, closeFn func(), err error) 
 ```
 
-<b>Example:<span style="float:right;display:inline-block;"> </span></b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uNep3Tr8fqF)</span></b>
 
 ```go
 package main
@@ -862,19 +945,19 @@ import (
 )
 
 func main() {
-   reader, fn, err := ReadFile("https://httpbin.org/robots.txt")
-	if err != nil {
-		return
-	}
-	defer fn()
+    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
+    dat, err := io.ReadAll(reader)
+    if err != nil {
+        return
+    }
+    fmt.Println(string(dat))
+    // Output:
+    // User-agent: *
+    // Disallow: /deny
 }
 ```

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,12 @@ import (
 -   [Schedule](#Schedule)
 -   [Pipeline](#Pipeline)
 -   [Watcher](#Watcher)
+-   [And](#And)
+-   [Or](#Or)
+-   [Negate](#Negate)
+-   [Nor](#Nor)
+-   [Xnor](#Xnor)
+-   [Nand](#Nand)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -403,3 +410,232 @@ 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
+}
+```
+
+### <span id="Nand">Nand</span>
+
+<p>Returns a composed predicate that represents the logical NAND of a list of predicates. It evaluates to true only if all predicates evaluate to false for the given value.</p>
+
+<b>Signature:</b>
+
+```go
+func Nand[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    isNumericAndLength5 := function.Nand(
+        func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+        func(s string) bool { return len(s) == 5 },
+    )
+
+    fmt.Println(isNumericAndLength5("12345"))
+    fmt.Println(isNumericAndLength5("1234"))
+    fmt.Println(isNumericAndLength5("abcdef"))
+
+    // Output:
+    // false
+    // false
+    // true
+}
+```
+
+### <span id="Xnor">Xnor</span>
+
+<p>Returns a composed predicate that represents the logical XNOR of a list of predicates. It evaluates to true only if all predicates evaluate to true or false for the given value.</p>
+
+<b>Signature:</b>
+
+```go
+func Xnor[T any](predicates ...func(T) bool) func(T) bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/function"
+)
+
+func main() {
+    isEven := func(i int) bool { return i%2 == 0 }
+    isPositive := func(i int) bool { return i > 0 }
+
+    match := function.Xnor(isEven, isPositive)
+
+    fmt.Println(match(2))
+    fmt.Println(match(-3))
+    fmt.Println(match(3))
+
+    // Output:
+    // true
+    // true
+    // false
+}
+```

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>
 
@@ -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>
@@ -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/slice.md

@@ -35,6 +35,7 @@ import (
 -   [DifferenceBy](#DifferenceBy)
 -   [DifferenceWith](#DifferenceWith)
 -   [DeleteAt](#DeleteAt)
+-   [DeleteRange](#DeleteRange)
 -   [Drop](#Drop)
 -   [DropRight](#DropRight)
 -   [DropWhile](#DropWhile)
@@ -515,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:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/pJ-d6MUWcvK)</span></b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/800B1dPBYyd)</span></b>
 
 ```go
 import (
@@ -532,18 +533,66 @@ import (
 )
 
 func main() {
-    result1 := slice.DeleteAt([]string{"a", "b", "c"}, -1)
-    result2 := slice.DeleteAt([]string{"a", "b", "c"}, 0)
-    result3 := slice.DeleteAt([]string{"a", "b", "c"}, 0, 2)
+    chars := []string{"a", "b", "c", "d", "e"}
+
+    result1 := slice.DeleteAt(chars, 0)
+    result2 := slice.DeleteAt(chars, 4)
+    result3 := slice.DeleteAt(chars, 5)
+    result4 := slice.DeleteAt(chars, 6)
 
     fmt.Println(result1)
     fmt.Println(result2)
     fmt.Println(result3)
+    fmt.Println(result4)
 
     // Output:
-    // [a b c]
-    // [b c]
-    // [c]
+    // [b c d e]
+    // [a b c d]
+    // [a b c d]
+    // [a b c d]
+}
+```
+
+### <span id="DeleteRange">DeleteRange</span>
+
+<p>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]
+    // []
+
 }
 ```
 
@@ -2473,17 +2522,47 @@ import (
 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 })
+    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)
+    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]]
+    // 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
 }
 ```

docs/en/api/packages/struct.md

@@ -37,6 +37,7 @@ import (
 -   [IsExported](#IsExported)
 -   [IsZero](#IsZero)
 -   [IsSlice](#IsSlice)
+-   [IsTargetType](#IsTargetType)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -533,3 +534,44 @@ func main() {
     // true
 }
 ```
+
+### <span id="IsTargetType">IsTargetType</span>
+
+<p>check if a struct field type is target type or not</p>
+
+<b>Signature:</b>
+
+```go
+func (f *Field) IsTargetType(targetType reflect.Kind) bool
+```
+
+<b>Example:</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/en/api/packages/strutil.md

@@ -1087,7 +1087,7 @@ func main() {
 func IsNotBlank(str string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/e_oJW0RAquA)</span></b>
 
 ```go
 import (
@@ -1096,11 +1096,11 @@ import (
 )
 
 func main() {
-    result1 := IsNotBlank("")
-    result2 := IsNotBlank("	")
-    result3 := IsNotBlank("\t\v\f\n")
-    result4 := IsNotBlank(" 中文")
-    result5 := IsNotBlank(" 	world	")
+    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)
@@ -1463,3 +1463,37 @@ func main() {
     // hello world
 }
 ```
+
+
+### <span id="SubInBetween">SubInBetween</span>
+
+<p>Return substring between the start and end position(excluded) of source string.</p>
+
+<b>Signature:</b>
+
+```go
+func SubInBetween(str string, start string, end string) string
+```
+
+<b>Example:</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
+}
+```

fileutil/file.go

@@ -20,11 +20,67 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
+	"sort"
 	"strings"
 
 	"github.com/duke-git/lancet/v2/validator"
 )
 
+// FileReader is a reader supporting offset seeking and reading one
+// line at a time, this is especially useful for large files
+type FileReader struct {
+	*bufio.Reader
+	file   *os.File
+	offset int64
+}
+
+// NewFileReader creates the FileReader struct for reading
+func NewFileReader(path string) (*FileReader, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	return &FileReader{
+		file:   f,
+		Reader: bufio.NewReader(f),
+		offset: 0,
+	}, nil
+}
+
+// ReadLine reads and returns one line at a time excluding the trailing '\r' and '\n'
+func (f *FileReader) ReadLine() (string, error) {
+	data, err := f.Reader.ReadBytes('\n')
+	f.offset += int64(len(data))
+	if err == nil || err == io.EOF {
+		for len(data) > 0 && (data[len(data)-1] == '\r' || data[len(data)-1] == '\n') {
+			data = data[:len(data)-1]
+		}
+		return string(data), err
+	}
+	return "", err
+}
+
+// Offset returns the current offset of the file
+func (f *FileReader) Offset() int64 {
+	return f.offset
+}
+
+// SeekOffset sets the current offset of the reading
+func (f *FileReader) SeekOffset(offset int64) error {
+	_, err := f.file.Seek(offset, 0)
+	if err != nil {
+		return err
+	}
+	f.Reader = bufio.NewReader(f.file)
+	f.offset = offset
+	return nil
+}
+
+// Close takes care of the opened file
+func (f *FileReader) Close() error {
+	return f.file.Close()
+}
+
 // IsExist checks if a file or directory exists.
 // Play: https://go.dev/play/p/nKKXt8ZQbmh
 func IsExist(path string) bool {
@@ -57,6 +113,65 @@ func CreateDir(absPath string) error {
 	return os.MkdirAll(absPath, os.ModePerm)
 }
 
+// CopyDir copy	src directory to dst directory, it will copy all files and directories recursively.
+// the access permission will be the same as the source directory.
+// if dstPath exists, it will return an error.
+// Play: https://go.dev/play/p/YAyFTA_UuPb
+func CopyDir(srcPath string, dstPath string) error {
+	if !IsDir(srcPath) {
+		return errors.New("source path is not a directory")
+	}
+	var err error
+	srcPath, err = filepath.Abs(srcPath)
+	if err != nil {
+		return err
+	}
+	if IsExist(dstPath) {
+		return errors.New("destination path already exists")
+	}
+	dstPath, err = filepath.Abs(dstPath)
+	if err != nil {
+		return err
+	}
+
+	// get srcPath's file info
+	srcFileInfo, err := os.Stat(srcPath)
+	if err != nil {
+		return err
+	}
+
+	// create dstPath with srcPath's mode
+	err = os.MkdirAll(dstPath, srcFileInfo.Mode())
+	if err != nil {
+		return err
+	}
+
+	err = filepath.Walk(srcPath, func(path string, info os.FileInfo, err error) error {
+		if srcPath == path {
+			return nil
+		}
+		curDstPath := filepath.Join(dstPath, filepath.Base(path))
+		if info.IsDir() {
+			err = CopyDir(path, curDstPath)
+			if err != nil {
+				return err
+			}
+		} else {
+			err = CopyFile(path, curDstPath)
+			if err != nil {
+				return err
+			}
+			err = os.Chmod(curDstPath, info.Mode())
+			if err != nil {
+				return err
+			}
+		}
+		return err
+	})
+
+	return err
+}
+
 // IsDir checks if the path is directory or not.
 // Play: https://go.dev/play/p/WkVwEKqtOWk
 func IsDir(path string) bool {
@@ -321,7 +436,7 @@ func UnZip(zipFile string, destPath string) error {
 	defer zipReader.Close()
 
 	for _, f := range zipReader.File {
-		//issue#62: fix ZipSlip bug
+		// issue#62: fix ZipSlip bug
 		path, err := safeFilepathJoin(destPath, f.Name)
 		if err != nil {
 			return err
@@ -508,6 +623,25 @@ func FileSize(path string) (int64, error) {
 	return f.Size(), nil
 }
 
+// DirSize walks the folder recursively and returns folder size in bytes.
+func DirSize(path string) (int64, error) {
+	var size int64
+	err := filepath.WalkDir(path, func(_ string, d os.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if !d.IsDir() {
+			info, err := d.Info()
+			if err != nil {
+				return err
+			}
+			size += info.Size()
+		}
+		return err
+	})
+	return size, err
+}
+
 // MTime returns file modified time.
 // Play: https://go.dev/play/p/s_Tl7lZoAaY
 func MTime(filepath string) (int64, error) {
@@ -536,7 +670,7 @@ func Sha(filepath string, shaType ...int) (string, error) {
 		} else if shaType[0] == 512 {
 			h = sha512.New()
 		} else {
-			return "", errors.New("param `shaType` should be 1, 256 or 512.")
+			return "", errors.New("param `shaType` should be 1, 256 or 512")
 		}
 	}
 
@@ -554,15 +688,19 @@ func Sha(filepath string, shaType ...int) (string, error) {
 
 // ReadCsvFile read file content into slice.
 // Play: https://go.dev/play/p/OExTkhGEd3_u
-func ReadCsvFile(filepath string) ([][]string, error) {
+func ReadCsvFile(filepath string, delimiter ...rune) ([][]string, error) {
 	f, err := os.Open(filepath)
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()
 
-	csvReader := csv.NewReader(f)
-	records, err := csvReader.ReadAll()
+	reader := csv.NewReader(f)
+	if len(delimiter) > 0 {
+		reader.Comma = delimiter[0]
+	}
+
+	records, err := reader.ReadAll()
 	if err != nil {
 		return nil, err
 	}
@@ -571,8 +709,10 @@ func ReadCsvFile(filepath string) ([][]string, error) {
 }
 
 // WriteCsvFile write content to target csv file.
+// append: append to existing csv file
+// delimiter: specifies csv delimiter
 // Play: https://go.dev/play/p/dAXm58Q5U1o
-func WriteCsvFile(filepath string, records [][]string, append bool) error {
+func WriteCsvFile(filepath string, records [][]string, append bool, delimiter ...rune) error {
 	flag := os.O_RDWR | os.O_CREATE
 
 	if append {
@@ -587,7 +727,19 @@ func WriteCsvFile(filepath string, records [][]string, append bool) error {
 	defer f.Close()
 
 	writer := csv.NewWriter(f)
-	writer.Comma = ','
+	// 设置默认分隔符为逗号，除非另外指定
+	if len(delimiter) > 0 {
+		writer.Comma = delimiter[0]
+	} else {
+		writer.Comma = ','
+	}
+
+	// 遍历所有记录并处理包含分隔符或双引号的单元格
+	for i := range records {
+		for j := range records[i] {
+			records[i][j] = escapeCSVField(records[i][j], writer.Comma)
+		}
+	}
 
 	return writer.WriteAll(records)
 }
@@ -627,7 +779,7 @@ func WriteBytesToFile(filepath string, content []byte) error {
 }
 
 // ReadFile get file reader by a url or a local file
-// Play: todo
+// Play: https://go.dev/play/p/uNep3Tr8fqF
 func ReadFile(path string) (reader io.ReadCloser, closeFn func(), err error) {
 	switch {
 	case validator.IsUrl(path):
@@ -646,3 +798,71 @@ func ReadFile(path string) (reader io.ReadCloser, closeFn func(), err error) {
 		return nil, func() {}, errors.New("unknown file type")
 	}
 }
+
+// escapeCSVField 处理单元格内容，如果包含分隔符，则用双引号包裹
+func escapeCSVField(field string, delimiter rune) string {
+	// 替换所有的双引号为两个双引号
+	escapedField := strings.ReplaceAll(field, "\"", "\"\"")
+
+	// 如果字段包含分隔符、双引号或换行符，用双引号包裹整个字段
+	if strings.ContainsAny(escapedField, string(delimiter)+"\"\n") {
+		escapedField = fmt.Sprintf("\"%s\"", escapedField)
+	}
+
+	return escapedField
+}
+
+// WriteMapsToCsv write slice of map to csv file.
+// Play: https://go.dev/play/p/umAIomZFV1c
+// filepath: Path to 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 {
+	for _, record := range records {
+		for _, value := range record {
+			if !isCsvSupportedType(value) {
+				return errors.New("unsupported value type detected; only basic types are supported: \nbool, rune, string, int, int64, float32, float64, uint, byte, complex128, complex64, uintptr")
+			}
+		}
+	}
+
+	var columnHeaders []string
+	if len(headers) > 0 {
+		columnHeaders = headers[0]
+	} else {
+		for key := range records[0] {
+			columnHeaders = append(columnHeaders, key)
+		}
+		// sort keys in alphabeta order
+		sort.Strings(columnHeaders)
+	}
+
+	var datasToWrite [][]string
+	if !appendToExistingFile {
+		datasToWrite = append(datasToWrite, columnHeaders)
+	}
+
+	for _, record := range records {
+		var row []string
+		for _, h := range columnHeaders {
+			row = append(row, fmt.Sprintf("%v", record[h]))
+		}
+		datasToWrite = append(datasToWrite, row)
+	}
+
+	return WriteCsvFile(filepath, datasToWrite, appendToExistingFile, delimiter)
+}
+
+// check if the value of map which to be written into csv is basic type.
+func isCsvSupportedType(v interface{}) bool {
+	switch v.(type) {
+	case bool, rune, string, int, int64, float32, float64, uint, byte, complex128, complex64, uintptr:
+		return true
+	default:
+		return false
+	}
+}

fileutil/file_example_test.go

@@ -3,6 +3,7 @@ package fileutil
 import (
 	"fmt"
 	"io"
+	"log"
 	"os"
 )
 
@@ -331,6 +332,28 @@ func ExampleWriteCsvFile() {
 	// [[Lili 22 female] [Jim 21 male]]
 }
 
+func ExampleWriteMapsToCsv() {
+	csvFilePath := "./testdata/test3.csv"
+	records := []map[string]any{
+		{"Name": "Lili", "Age": "22", "Gender": "female"},
+		{"Name": "Jim", "Age": "21", "Gender": "male"},
+	}
+
+	headers := []string{"Name", "Age", "Gender"}
+	err := WriteMapsToCsv(csvFilePath, records, false, ';', headers)
+
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	content, err := ReadCsvFile(csvFilePath, ';')
+
+	fmt.Println(content)
+
+	// Output:
+	// [[Name Age Gender] [Lili 22 female] [Jim 21 male]]
+}
+
 func ExampleWriteStringToFile() {
 	filepath := "./test.txt"
 

fileutil/file_test.go

@@ -3,6 +3,8 @@ package fileutil
 import (
 	"io"
 	"os"
+	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/duke-git/lancet/v2/internal"
@@ -27,7 +29,7 @@ func TestCreateFile(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestCreateFile")
 
-	f := "./text.txt"
+	f := "./testdata/text.txt"
 	if CreateFile(f) {
 		file, err := os.Open(f)
 		assert.IsNil(err)
@@ -340,10 +342,14 @@ func TestSha(t *testing.T) {
 	assert := internal.NewAssert(t, "TestSha")
 
 	sha1, err := Sha("./testdata/test.txt", 1)
-	sha256, err := Sha("./testdata/test.txt", 256)
-	sha512, err := Sha("./testdata/test.txt", 512)
-
 	assert.IsNil(err)
+
+	sha256, err := Sha("./testdata/test.txt", 256)
+	assert.IsNil(err)
+
+	sha512, err := Sha("./testdata/test.txt", 512)
+	assert.IsNil(err)
+
 	assert.Equal("dda3cf10c5a6ff6c6659a497bf7261b287af2bc7", sha1)
 	assert.Equal("aa6d0a3fbc3442c228d606da09e0c1dc98c69a1cac3da1909199e0266171df35", sha256)
 	assert.Equal("d22aba2a1b7a2e2f512756255cc1c3708905646920cb1eb95e45b531ba74774dbbb89baebf1f716220eb9cf4908f1cfc5b2a01267704d9a59f59d77cab609870", sha512)
@@ -379,11 +385,36 @@ func TestWriteCsvFile(t *testing.T) {
 
 	assert.Equal(2, len(readContent))
 	assert.Equal(3, len(readContent[0]))
-	assert.Equal("Lili", content[0][0])
+	assert.Equal("Lili", readContent[0][0])
 
 	// RemoveFile(csvFilePath)
 }
 
+func TestWriteMapsToCsv(t *testing.T) {
+	assert := internal.NewAssert(t, "TestWriteMapsToCSV")
+
+	csvFilePath := "./testdata/test4.csv"
+	records := []map[string]any{
+		{"Name": "Lili", "Age": "22", "Gender": "female"},
+		{"Name": "Jim", "Age": "21", "Gender": "male"},
+	}
+
+	headers := []string{"Name", "Age", "Gender"}
+	err := WriteMapsToCsv(csvFilePath, records, false, ';', headers)
+
+	assert.IsNil(err)
+
+	content, err := ReadCsvFile(csvFilePath, ';')
+
+	assert.IsNil(err)
+
+	assert.Equal(3, len(content))
+	assert.Equal(3, len(content[0]))
+	assert.Equal("Lili", content[1][0])
+	assert.Equal("22", content[1][1])
+	assert.Equal("female", content[1][2])
+}
+
 func TestWriteStringToFile(t *testing.T) {
 	assert := internal.NewAssert(t, "TestWriteStringToFile")
 
@@ -476,3 +507,62 @@ Disallow: /deny
 `
 	internal.NewAssert(t, "TestReadFile").Equal(want, string(dat))
 }
+
+func TestReadlineFile(t *testing.T) {
+	path := "./testdata/demo.csv"
+	reader, err := NewFileReader(path)
+	if err != nil {
+		t.Fail()
+	}
+	defer reader.Close()
+
+	indexMap := make(map[string]int64)
+	defer reader.Close()
+	for {
+		offset := reader.Offset()
+		line, err := reader.ReadLine()
+		if err == io.EOF {
+			break
+		}
+		indexMap[line] = offset
+	}
+
+	lines, err := ReadFileByLine(path)
+	if err != nil {
+		t.Fail()
+	}
+	for _, line := range lines {
+		offset, ok := indexMap[line]
+		if !ok {
+			t.Fail()
+		}
+		if err = reader.SeekOffset(offset); err != nil {
+			t.Fail()
+		}
+		lineRead, err := reader.ReadLine()
+		if err == io.EOF {
+			break
+		}
+		internal.NewAssert(t, "TestReadlineFile").Equal(line, lineRead)
+	}
+}
+
+func TestCopyDir(t *testing.T) {
+	assert := internal.NewAssert(t, "TestCopyDir")
+
+	src := "./testdata"
+	dest := "./testdata_copy"
+
+	err := CopyDir(src, dest)
+	assert.IsNil(err)
+
+	assert.Equal(true, IsExist(dest))
+
+	filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
+		destPath := strings.Replace(path, src, dest, 1)
+		assert.Equal(true, IsExist(destPath))
+		return nil
+	})
+
+	os.RemoveAll(dest)
+}

fileutil/testdata/test01/demo2.csv

@@ -0,0 +1 @@
+makj1

fileutil/testdata/test1.csv

@@ -1,3 +1,5 @@
 Lili,22,female
 Jim,21,male
 
+
+

fileutil/testdata/test2.csv

@@ -1,3 +1,5 @@
 Lili,22,female
 Jim,21,male
 
+
+

fileutil/testdata/test3.csv

@@ -0,0 +1,3 @@
+Name;Age;Gender
+Lili;22;female
+Jim;21;male

fileutil/testdata/test4.csv

@@ -0,0 +1,3 @@
+Name;Age;Gender
+Lili;22;female
+Jim;21;male

formatter/formatter.go

@@ -6,12 +6,11 @@ package formatter
 
 import (
 	"encoding/json"
-	"fmt"
 	"io"
+	"strconv"
+	"strings"
 
 	"github.com/duke-git/lancet/v2/convertor"
-	"github.com/duke-git/lancet/v2/strutil"
-	"github.com/duke-git/lancet/v2/validator"
 	"golang.org/x/exp/constraints"
 )
 
@@ -20,31 +19,24 @@ import (
 // Comma("12345", "$") => "$12,345", Comma(12345, "$") => "$12,345"
 // Play: https://go.dev/play/p/eRD5k2vzUVX
 func Comma[T constraints.Float | constraints.Integer | string](value T, symbol string) string {
-	if validator.IsInt(value) {
-		v, err := convertor.ToInt(value)
-		if err != nil {
-			return ""
-		}
-		return symbol + commaInt(v)
-	}
+	numString := convertor.ToString(value)
 
-	if validator.IsFloat(value) {
-		v, err := convertor.ToFloat(value)
-		if err != nil {
-			return ""
-		}
-		return symbol + commaFloat(v)
-	}
-
-	if strutil.IsString(value) {
-		v := fmt.Sprintf("%v", value)
-		if validator.IsNumberStr(v) {
-			return symbol + commaStr(v)
-		}
+	_, err := strconv.ParseFloat(numString, 64)
+	if err != nil {
 		return ""
 	}
 
-	return ""
+	index := strings.Index(numString, ".")
+	if index == -1 {
+		index = len(numString)
+	}
+
+	for index > 3 {
+		index = index - 3
+		numString = numString[:index] + "," + numString[index:]
+	}
+
+	return symbol + numString
 }
 
 // Pretty data to JSON string.

formatter/formatter_internal.go

@@ -1,85 +0,0 @@
-package formatter
-
-import (
-	"bytes"
-	"math"
-	"strconv"
-	"strings"
-)
-
-// see https://github.com/dustin/go-humanize/blob/master/comma.go
-func commaInt(v int64) string {
-	sign := ""
-
-	// Min int64 can't be negated to a usable value, so it has to be special cased.
-	if v == math.MinInt64 {
-		return "-9,223,372,036,854,775,808"
-	}
-
-	if v < 0 {
-		sign = "-"
-		v = 0 - v
-	}
-
-	parts := []string{"", "", "", "", "", "", ""}
-	j := len(parts) - 1
-
-	for v > 999 {
-		parts[j] = strconv.FormatInt(v%1000, 10)
-		switch len(parts[j]) {
-		case 2:
-			parts[j] = "0" + parts[j]
-		case 1:
-			parts[j] = "00" + parts[j]
-		}
-		v = v / 1000
-		j--
-	}
-	parts[j] = strconv.Itoa(int(v))
-	return sign + strings.Join(parts[j:], ",")
-}
-
-func commaFloat(v float64) string {
-	buf := &bytes.Buffer{}
-	if v < 0 {
-		buf.Write([]byte{'-'})
-		v = 0 - v
-	}
-
-	comma := []byte{','}
-
-	parts := strings.Split(strconv.FormatFloat(v, 'f', -1, 64), ".")
-	pos := 0
-	if len(parts[0])%3 != 0 {
-		pos += len(parts[0]) % 3
-		buf.WriteString(parts[0][:pos])
-		buf.Write(comma)
-	}
-	for ; pos < len(parts[0]); pos += 3 {
-		buf.WriteString(parts[0][pos : pos+3])
-		buf.Write(comma)
-	}
-	buf.Truncate(buf.Len() - 1)
-
-	if len(parts) > 1 {
-		buf.Write([]byte{'.'})
-		buf.WriteString(parts[1])
-	}
-	return buf.String()
-}
-
-func commaStr(s string) string {
-	dotIndex := strings.Index(s, ".")
-	if dotIndex != -1 {
-		return commaStrRecursive(s[:dotIndex]) + s[dotIndex:]
-	}
-
-	return commaStrRecursive(s)
-}
-
-func commaStrRecursive(s string) string {
-	if len(s) <= 3 {
-		return s
-	}
-	return commaStrRecursive(s[:len(s)-3]) + "," + commaStrRecursive(s[len(s)-3:])
-}

function/predicate.go

@@ -0,0 +1,91 @@
+package function
+
+// And 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.
+func And[T any](predicates ...func(T) bool) func(T) bool {
+	if len(predicates) < 2 {
+		panic("programming error: predicates count must be at least 2")
+	}
+	return func(value T) bool {
+		for _, predicate := range predicates {
+			if !predicate(value) {
+				return false // Short-circuit on the first false predicate
+			}
+		}
+		return true // True if all predicates are true
+	}
+}
+
+// Nand returns a composed predicate that represents the logical NAND of a list of predicates.
+// It evaluates to true only if all predicates evaluate to false for the given value.
+func Nand[T any](predicates ...func(T) bool) func(T) bool {
+	if len(predicates) < 2 {
+		panic("programming error: predicates count must be at least 2")
+	}
+	return func(value T) bool {
+		for _, predicate := range predicates {
+			if predicate(value) {
+				return false // Short-circuit on the first true predicate
+			}
+		}
+		return true // True if all predicates are false
+	}
+}
+
+// Negate returns a predicate that represents the logical negation of this predicate.
+func Negate[T any](predicate func(T) bool) func(T) bool {
+	return func(value T) bool {
+		return !predicate(value)
+	}
+}
+
+// Or 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.
+func Or[T any](predicates ...func(T) bool) func(T) bool {
+	if len(predicates) < 2 {
+		panic("programming error: predicates count must be at least 2")
+	}
+	return func(value T) bool {
+		for _, predicate := range predicates {
+			if predicate(value) {
+				return true // Short-circuit on the first true predicate
+			}
+		}
+		return false // False if all predicates are false
+	}
+}
+
+// Nor 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.
+func Nor[T any](predicates ...func(T) bool) func(T) bool {
+	if len(predicates) < 2 {
+		panic("programming error: predicates count must be at least 2")
+	}
+	return func(value T) bool {
+		for _, predicate := range predicates {
+			if predicate(value) {
+				return false // If any predicate evaluates to true, the NOR result is false
+			}
+		}
+		return true // Only returns true if all predicates evaluate to false
+	}
+}
+
+// Xnor returns a composed predicate that represents the logical XNOR of a list of predicates.
+// It evaluates to true only if all predicates evaluate to true or false for the given value.
+func Xnor[T any](predicates ...func(T) bool) func(T) bool {
+	if len(predicates) < 2 {
+		panic("programming error: predicates count must be at least 2")
+	}
+	return func(value T) bool {
+		trueCount := 0
+		for _, predicate := range predicates {
+			if predicate(value) {
+				trueCount++
+			}
+		}
+		// XNOR is true if either all predicates are true or all are false
+		// This is the same as saying trueCount is 0 (all false) or trueCount is len(predicates) (all true)
+		return trueCount == 0 || trueCount == len(predicates)
+	}
+}

function/predicate_example_test.go

@@ -0,0 +1,128 @@
+package function
+
+import (
+	"fmt"
+	"strings"
+)
+
+func ExampleNegate() {
+	// 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 := Negate(Or(isUpperCase, isLowerCase))
+
+	fmt.Println(isMixedCase("ABC"))
+	fmt.Println(isMixedCase("AbC"))
+
+	// Output:
+	// false
+	// true
+}
+
+func ExampleOr() {
+	containsDigitOrSpecialChar := 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
+}
+
+func ExampleAnd() {
+	isNumericAndLength5 := 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
+}
+
+func ExampleNand() {
+	isNumericAndLength5 := Nand(
+		func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+		func(s string) bool { return len(s) == 5 },
+	)
+
+	fmt.Println(isNumericAndLength5("12345"))
+	fmt.Println(isNumericAndLength5("1234"))
+	fmt.Println(isNumericAndLength5("abcdef"))
+
+	// Output:
+	// false
+	// false
+	// true
+}
+
+func ExampleNor() {
+	match := Nor(
+		func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+		func(s string) bool { return len(s) == 5 },
+	)
+
+	fmt.Println(match("dbcdckkeee"))
+
+	match = 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
+}
+
+func ExampleXnor() {
+	isEven := func(i int) bool { return i%2 == 0 }
+	isPositive := func(i int) bool { return i > 0 }
+
+	match := Xnor(isEven, isPositive)
+
+	fmt.Println(match(2))
+	fmt.Println(match(-3))
+	fmt.Println(match(3))
+
+	// Output:
+	// true
+	// true
+	// false
+}
+
+// func ExamplePredicatesMix() {
+// 	a := Or(
+// 		func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+// 		func(s string) bool { return strings.ContainsAny(s, "!") },
+// 	)
+
+// 	b := And(
+// 		func(s string) bool { return strings.ContainsAny(s, "hello") },
+// 		func(s string) bool { return strings.ContainsAny(s, "!") },
+// 	)
+
+// 	c := Negate(And(a, b))
+// 	fmt.Println(c("hello!"))
+
+// 	c = Nor(a, b)
+// 	fmt.Println(c("hello!"))
+
+// 	// Output:
+// 	// false
+// 	// false
+// }

function/predicate_test.go

@@ -0,0 +1,134 @@
+package function
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+func TestPredicatesNegatePure(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestPredicatesNegatePure")
+
+	// 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 := Negate(Or(isUpperCase, isLowerCase))
+
+	assert.ShouldBeFalse(isMixedCase("ABC"))
+	assert.ShouldBeTrue(isMixedCase("AbC"))
+}
+
+func TestPredicatesOrPure(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestPredicatesOrPure")
+
+	containsDigitOrSpecialChar := Or(
+		func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+		func(s string) bool { return strings.ContainsAny(s, "!@#$%") },
+	)
+
+	assert.ShouldBeTrue(containsDigitOrSpecialChar("hello!"))
+	assert.ShouldBeFalse(containsDigitOrSpecialChar("hello"))
+}
+
+func TestPredicatesAndPure(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestPredicatesAndPure")
+
+	isNumericAndLength5 := And(
+		func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+		func(s string) bool { return len(s) == 5 },
+	)
+
+	assert.ShouldBeTrue(isNumericAndLength5("12345"))
+	assert.ShouldBeFalse(isNumericAndLength5("1234"))
+	assert.ShouldBeFalse(isNumericAndLength5("abcde"))
+}
+
+func TestPredicatesNandPure(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestPredicatesNandPure")
+
+	isNumericAndLength5 := Nand(
+		func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+		func(s string) bool { return len(s) == 5 },
+	)
+
+	assert.ShouldBeFalse(isNumericAndLength5("12345"))
+	assert.ShouldBeFalse(isNumericAndLength5("1234"))
+	assert.ShouldBeTrue(isNumericAndLength5("abcdef"))
+}
+
+func TestPredicatesNorPure(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestPredicatesNorPure")
+
+	match := Nor(
+		func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+		func(s string) bool { return len(s) == 5 },
+	)
+
+	assert.ShouldBeTrue(match("dbcdckkeee"))
+
+	match = Nor(
+		func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+		func(s string) bool { return len(s) == 5 },
+	)
+
+	assert.ShouldBeFalse(match("0123456789"))
+}
+
+func TestPredicatesXnorPure(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestPredicatesXnorPure")
+
+	isEven := func(i int) bool { return i%2 == 0 }
+	isPositive := func(i int) bool { return i > 0 }
+
+	match := Xnor(isEven, isPositive)
+
+	assert.ShouldBeTrue(match(2))
+	assert.ShouldBeTrue(match(-3))
+	assert.ShouldBeFalse(match(3))
+}
+
+func TestPredicatesMix(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestPredicatesMix")
+
+	a := Or(
+		func(s string) bool { return strings.ContainsAny(s, "0123456789") },
+		func(s string) bool { return strings.ContainsAny(s, "!") },
+	)
+
+	b := And(
+		func(s string) bool { return strings.ContainsAny(s, "hello") },
+		func(s string) bool { return strings.ContainsAny(s, "!") },
+	)
+
+	c := Negate(And(a, b))
+
+	assert.ShouldBeFalse(c("hello!"))
+
+	k := Nor(a, b)
+	assert.ShouldBeFalse(k("hello!"))
+
+	o := Xnor(a, b)
+	assert.ShouldBeTrue(o("hello!"))
+
+	p := Nand(c, k)
+	assert.ShouldBeTrue(p("hello!"))
+}

internal/assert.go

@@ -37,6 +37,20 @@ func (a *Assert) Equal(expected, actual any) {
 	}
 }
 
+// ShouldBeFalse check if expected is false
+func (a *Assert) ShouldBeFalse(actual any) {
+	if compare(false, actual) != compareEqual {
+		makeTestFailed(a.T, a.CaseName, false, actual)
+	}
+}
+
+// ShouldBeTrue check if expected is true
+func (a *Assert) ShouldBeTrue(actual any) {
+	if compare(true, actual) != compareEqual {
+		makeTestFailed(a.T, a.CaseName, true, actual)
+	}
+}
+
 // NotEqual check if expected is not equal with actual
 func (a *Assert) NotEqual(expected, actual any) {
 	if compare(expected, actual) == compareEqual {

internal/assert_test.go

@@ -6,10 +6,11 @@ import (
 
 func TestAssert(t *testing.T) {
 	assert := NewAssert(t, "TestAssert")
+
 	assert.Equal(0, 0)
 	assert.NotEqual(1, 0)
-
 	assert.NotEqual("1", 1)
+
 	var uInt1 uint
 	var uInt2 uint
 	var uInt8 uint8
@@ -47,4 +48,11 @@ func TestAssert(t *testing.T) {
 	assert.IsNil(nil)
 	assert.IsNotNil("abc")
 
+	var valA int = 1
+	var valB int64 = 1
+	assert.NotEqual(valA, valB)
+	assert.EqualValues(valA, valB)
+
+	assert.ShouldBeFalse(false)
+	assert.ShouldBeTrue(true)
 }

maputil/map.go

@@ -5,6 +5,7 @@
 package maputil
 
 import (
+	"fmt"
 	"reflect"
 
 	"github.com/duke-git/lancet/v2/slice"
@@ -303,3 +304,83 @@ func HasKey[K comparable, V any](m map[K]V, key K) bool {
 	_, haskey := m[key]
 	return haskey
 }
+
+// MapToStruct converts map to struct
+// Play: todo
+func MapToStruct(m map[string]any, structObj any) error {
+	for k, v := range m {
+		err := setStructField(structObj, k, v)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func setStructField(structObj any, fieldName string, fieldValue any) error {
+	structVal := reflect.ValueOf(structObj).Elem()
+
+	fName := getFieldNameByJsonTag(structObj, fieldName)
+	if fName == "" {
+		return fmt.Errorf("Struct field json tag don't match map key : %s in obj", fieldName)
+	}
+
+	fieldVal := structVal.FieldByName(fName)
+
+	if !fieldVal.IsValid() {
+		return fmt.Errorf("No such field: %s in obj", fieldName)
+	}
+
+	if !fieldVal.CanSet() {
+		return fmt.Errorf("Cannot set %s field value", fieldName)
+	}
+
+	val := reflect.ValueOf(fieldValue)
+
+	if fieldVal.Type() != val.Type() {
+
+		if val.CanConvert(fieldVal.Type()) {
+			fieldVal.Set(val.Convert(fieldVal.Type()))
+			return nil
+		}
+
+		if m, ok := fieldValue.(map[string]any); ok {
+
+			if fieldVal.Kind() == reflect.Struct {
+				return MapToStruct(m, fieldVal.Addr().Interface())
+			}
+
+			if fieldVal.Kind() == reflect.Ptr && fieldVal.Type().Elem().Kind() == reflect.Struct {
+				if fieldVal.IsNil() {
+					fieldVal.Set(reflect.New(fieldVal.Type().Elem()))
+				}
+
+				return MapToStruct(m, fieldVal.Interface())
+			}
+
+		}
+
+		return fmt.Errorf("Map value type don't match struct field type")
+	}
+
+	fieldVal.Set(val)
+
+	return nil
+}
+
+func getFieldNameByJsonTag(structObj any, jsonTag string) string {
+	s := reflect.TypeOf(structObj).Elem()
+
+	for i := 0; i < s.NumField(); i++ {
+		field := s.Field(i)
+		tag := field.Tag
+		name := tag.Get("json")
+
+		if name == jsonTag {
+			return field.Name
+		}
+	}
+
+	return ""
+}

maputil/map_test.go

@@ -472,3 +472,42 @@ func TestHasKey(t *testing.T) {
 	assert.Equal(true, HasKey(m, "a"))
 	assert.Equal(false, HasKey(m, "c"))
 }
+
+func TestMapToStruct(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestMapToStruct")
+
+	type (
+		Person struct {
+			Name  string   `json:"name"`
+			Age   int      `json:"age"`
+			Phone string   `json:"phone"`
+			Addr  *Address `json:"address"`
+		}
+
+		Address struct {
+			Street string `json:"street"`
+			Number int    `json:"number"`
+		}
+	)
+
+	m := map[string]interface{}{
+		"name":  "Nothin",
+		"age":   28,
+		"phone": "123456789",
+		"address": map[string]interface{}{
+			"street": "test",
+			"number": 1,
+		},
+	}
+
+	var p Person
+	err := MapToStruct(m, &p)
+	assert.IsNil(err)
+	assert.Equal(m["name"], p.Name)
+	assert.Equal(m["age"], p.Age)
+	assert.Equal(m["phone"], p.Phone)
+	assert.Equal("test", p.Addr.Street)
+	assert.Equal(1, p.Addr.Number)
+}

maputil/typemap.go

@@ -62,18 +62,25 @@ var _ = func() struct{} {
 */
 // Play: https://go.dev/play/p/4K7KBEPgS5M
 func MapTo(src any, dst any) error {
-
 	dstRef := reflect.ValueOf(dst)
+
 	if dstRef.Kind() != reflect.Ptr {
 		return fmt.Errorf("dst is not ptr")
 	}
 
+	dstElem := dstRef.Type().Elem()
+	if dstElem.Kind() == reflect.Struct {
+		srcMap := src.(map[string]interface{})
+		return MapToStruct(srcMap, dst)
+	}
+
 	dstRef = reflect.Indirect(dstRef)
 
 	srcRef := reflect.ValueOf(src)
 	if srcRef.Kind() == reflect.Ptr || srcRef.Kind() == reflect.Interface {
 		srcRef = srcRef.Elem()
 	}
+
 	if f, ok := mapHandlers[srcRef.Kind()]; ok {
 		return f(srcRef, dstRef)
 	}
@@ -121,7 +128,7 @@ func convertSlice(src reflect.Value, dst reflect.Value) error {
 
 func convertMap(src reflect.Value, dst reflect.Value) error {
 	if src.Kind() != reflect.Map || dst.Kind() != reflect.Struct {
-		if src.Kind() == reflect.Interface {
+		if src.Kind() == reflect.Interface && dst.IsValid() {
 			return convertMap(src.Elem(), dst)
 		} else {
 			return fmt.Errorf("src or dst type error,%s,%s", src.Type().String(), dst.Type().String())
@@ -129,7 +136,9 @@ func convertMap(src reflect.Value, dst reflect.Value) error {
 	}
 	dstType := dst.Type()
 	num := dstType.NumField()
+
 	exist := map[string]int{}
+
 	for i := 0; i < num; i++ {
 		k := dstType.Field(i).Tag.Get("json")
 		if k == "" {
@@ -138,7 +147,6 @@ func convertMap(src reflect.Value, dst reflect.Value) error {
 		if strings.Contains(k, ",") {
 			taglist := strings.Split(k, ",")
 			if taglist[0] == "" {
-
 				k = dstType.Field(i).Name
 			} else {
 				k = taglist[0]
@@ -150,9 +158,11 @@ func convertMap(src reflect.Value, dst reflect.Value) error {
 	}
 
 	keys := src.MapKeys()
+
 	for _, key := range keys {
 		if index, ok := exist[key.String()]; ok {
 			v := dst.Field(index)
+
 			if v.Kind() == reflect.Struct {
 				err := convertMap(src.MapIndex(key), v)
 				if err != nil {

maputil/typemap_test.go

@@ -8,10 +8,10 @@ import (
 
 type (
 	Person struct {
-		Name  string  `json:"name"`
-		Age   int     `json:"age"`
-		Phone string  `json:"phone"`
-		Addr  Address `json:"address"`
+		Name    string   `json:"name"`
+		Age     int      `json:"age"`
+		Phone   string   `json:"phone"`
+		Address *Address `json:"address"`
 	}
 
 	Address struct {
@@ -38,11 +38,12 @@ func TestStructType(t *testing.T) {
 	var p Person
 	err := MapTo(src, &p)
 	assert.IsNil(err)
+
 	assert.Equal(src["name"], p.Name)
 	assert.Equal(src["age"], p.Age)
 	assert.Equal(src["phone"], p.Phone)
-	assert.Equal("test", p.Addr.Street)
-	assert.Equal(1, p.Addr.Number)
+	assert.Equal("test", p.Address.Street)
+	assert.Equal(1, p.Address.Number)
 }
 
 func TestBaseType(t *testing.T) {

mathutil/mathutil.go

@@ -330,10 +330,10 @@ func Cos(radian float64, precision ...int) float64 {
 	return TruncRound(radian, 3)
 }
 
-// Cos returns the sine of the radian argument.
+// Sin returns the sine of the radian argument.
 // Play: https://go.dev/play/p/TWMQlMywDsP
 func Sin(radian float64, precision ...int) float64 {
-	return Cos((math.Pi / 2) - radian)
+	return Cos((math.Pi/2)-radian, precision...)
 }
 
 // Log returns the logarithm of base n.

netutil/http.go

@@ -14,6 +14,7 @@ package netutil
 
 import (
 	"bytes"
+	"context"
 	"crypto/tls"
 	"encoding/json"
 	"errors"
@@ -110,22 +111,23 @@ type HttpClientConfig struct {
 	Verbose          bool
 }
 
-// defaultHttpClientConfig defalut client config
+// defaultHttpClientConfig defalut client config.
 var defaultHttpClientConfig = &HttpClientConfig{
 	Compressed:       false,
 	HandshakeTimeout: 20 * time.Second,
 	ResponseTimeout:  40 * time.Second,
 }
 
-// HttpClient is used for sending http request
+// HttpClient is used for sending http request.
 type HttpClient struct {
 	*http.Client
 	TLS     *tls.Config
 	Request *http.Request
 	Config  HttpClientConfig
+	Context context.Context
 }
 
-// NewHttpClient make a HttpClient instance
+// NewHttpClient make a HttpClient instance.
 func NewHttpClient() *HttpClient {
 	client := &HttpClient{
 		Client: &http.Client{
@@ -141,7 +143,7 @@ func NewHttpClient() *HttpClient {
 	return client
 }
 
-// NewHttpClientWithConfig make a HttpClient instance with pass config
+// NewHttpClientWithConfig make a HttpClient instance with pass config.
 func NewHttpClientWithConfig(config *HttpClientConfig) *HttpClient {
 	if config == nil {
 		config = defaultHttpClientConfig
@@ -176,6 +178,11 @@ func (client *HttpClient) SendRequest(request *HttpRequest) (*http.Response, err
 	rawUrl := request.RawURL
 
 	req, err := http.NewRequest(request.Method, rawUrl, bytes.NewBuffer(request.Body))
+
+	if client.Context != nil {
+		req, err = http.NewRequestWithContext(client.Context, request.Method, rawUrl, bytes.NewBuffer(request.Body))
+	}
+
 	if err != nil {
 		return nil, err
 	}

netutil/net.go

@@ -230,7 +230,6 @@ func UploadFile(filepath string, server string) (bool, error) {
 }
 
 // DownloadFile will download the file exist in url to a local file.
-// Play: todo
 func DownloadFile(filepath string, url string) error {
 	resp, err := http.Get(url)
 	if err != nil {

pointer/pointer.go

@@ -4,7 +4,9 @@
 // Package pointer contains some util functions to operate go pointer.
 package pointer
 
-import "reflect"
+import (
+	"reflect"
+)
 
 // Of returns a pointer to the value `v`.
 // Play: https://go.dev/play/p/HFd70x4DrMj
@@ -47,5 +49,10 @@ func ExtractPointer(value any) any {
 	if t.Kind() != reflect.Pointer {
 		return value
 	}
-	return ExtractPointer(v.Elem().Interface())
+
+	if v.Elem().IsValid() {
+		return ExtractPointer(v.Elem().Interface())
+	}
+
+	return nil
 }

random/random.go

@@ -8,22 +8,30 @@ import (
 	crand "crypto/rand"
 	"fmt"
 	"io"
+	"math"
 	"math/rand"
 	"time"
+	"unsafe"
+
+	"github.com/duke-git/lancet/v2/mathutil"
 )
 
 const (
-	Numeral       = "0123456789"
-	LowwerLetters = "abcdefghijklmnopqrstuvwxyz"
-	UpperLetters  = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-	Letters       = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+	MaximumCapacity = 1 << 31
+	Numeral         = "0123456789"
+	LowwerLetters   = "abcdefghijklmnopqrstuvwxyz"
+	UpperLetters    = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+	Letters         = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+	SymbolChars     = "!@#$%^&*()_+-=[]{}|;':\",./<>?"
 )
 
+var rn = rand.NewSource(time.Now().UnixNano())
+
 func init() {
 	rand.Seed(time.Now().UnixNano())
 }
 
-// RandInt generate random int between min and max, maybe min,  not be max.
+// RandInt generate random int between [min, max).
 // Play: https://go.dev/play/p/pXyyAAI5YxD
 func RandInt(min, max int) int {
 	if min == max {
@@ -37,6 +45,22 @@ func RandInt(min, max int) int {
 	return rand.Intn(max-min) + min
 }
 
+// RandFloat generate random float64 number between [min, max) with specific precision.
+// Play: https://go.dev/play/p/zbD_tuobJtr
+func RandFloat(min, max float64, precision int) float64 {
+	if min == max {
+		return min
+	}
+
+	if max < min {
+		min, max = max, min
+	}
+
+	n := rand.Float64()*(max-min) + min
+
+	return mathutil.RoundToFloat(n, precision)
+}
+
 // RandBytes generate random byte slice.
 // Play: https://go.dev/play/p/EkiLESeXf8d
 func RandBytes(length int) []byte {
@@ -52,19 +76,19 @@ func RandBytes(length int) []byte {
 	return b
 }
 
-// RandString generate random string of specified length.
+// RandString generate random alpha string of specified length.
 // Play: https://go.dev/play/p/W2xvRUXA7Mi
 func RandString(length int) string {
 	return random(Letters, length)
 }
 
-// RandUpper generate a random upper case string.
+// RandUpper generate a random upper case string of specified length.
 // Play: https://go.dev/play/p/29QfOh0DVuh
 func RandUpper(length int) string {
 	return random(UpperLetters, length)
 }
 
-// RandLower generate a random lower case string.
+// RandLower generate a random lower case string of specified length.
 // Play: https://go.dev/play/p/XJtZ471cmtI
 func RandLower(length int) string {
 	return random(LowwerLetters, length)
@@ -76,24 +100,74 @@ func RandNumeral(length int) string {
 	return random(Numeral, length)
 }
 
-// RandNumeralOrLetter generate a random numeral or letter string.
+// RandNumeralOrLetter generate a random numeral or alpha string of specified length.
 // Play: https://go.dev/play/p/19CEQvpx2jD
 func RandNumeralOrLetter(length int) string {
 	return random(Numeral+Letters, length)
 }
 
+// RandSymbolChar generate a random symbol char of specified length.
+// symbol chars: !@#$%^&*()_+-=[]{}|;':\",./<>?.
+// Play: https://go.dev/play/p/Im6ZJxAykOm
+func RandSymbolChar(length int) string {
+	return random(SymbolChars, length)
+}
+
+// nearestPowerOfTwo 返回一个大于等于cap的最近的2的整数次幂，参考java8的hashmap的tableSizeFor函数
+func nearestPowerOfTwo(cap int) int {
+	n := cap - 1
+	n |= n >> 1
+	n |= n >> 2
+	n |= n >> 4
+	n |= n >> 8
+	n |= n >> 16
+	if n < 0 {
+		return 1
+	} else if n >= MaximumCapacity {
+		return MaximumCapacity
+	}
+	return n + 1
+}
+
 // random generate a random string based on given string range.
 func random(s string, length int) string {
-	b := make([]byte, length)
-
-	// fix: https://github.com/duke-git/lancet/issues/75
-	// r := rand.New(rand.NewSource(time.Now().UnixNano()))
-
-	for i := range b {
-		b[i] = s[rand.Int63()%int64(len(s))]
+	// 仿照strings.Builder
+	// 创建一个长度为 length 的字节切片
+	bytes := make([]byte, length)
+	strLength := len(s)
+	if strLength <= 0 {
+		return ""
+	} else if strLength == 1 {
+		for i := 0; i < length; i++ {
+			bytes[i] = s[0]
+		}
+		return *(*string)(unsafe.Pointer(&bytes))
 	}
-
-	return string(b)
+	// s的字符需要使用多少个比特位数才能表示完
+	// letterIdBits := int(math.Ceil(math.Log2(strLength))),下面比上面的代码快
+	letterIdBits := int(math.Log2(float64(nearestPowerOfTwo(strLength))))
+	// 最大的字母id掩码
+	var letterIdMask int64 = 1<<letterIdBits - 1
+	// 可用次数的最大值
+	letterIdMax := 63 / letterIdBits
+	// 循环生成随机字符串
+	for i, cache, remain := length-1, rn.Int63(), letterIdMax; i >= 0; {
+		// 检查随机数生成器是否用尽所有随机数
+		if remain == 0 {
+			cache, remain = rn.Int63(), letterIdMax
+		}
+		// 从可用字符的字符串中随机选择一个字符
+		if idx := int(cache & letterIdMask); idx < len(s) {
+			bytes[i] = s[idx]
+			i--
+		}
+		// 右移比特位数，为下次选择字符做准备
+		cache >>= letterIdBits
+		remain--
+	}
+	// 仿照strings.Builder用unsafe包返回一个字符串，避免拷贝
+	// 将字节切片转换为字符串并返回
+	return *(*string)(unsafe.Pointer(&bytes))
 }
 
 // UUIdV4 generate a random UUID of version 4 according to RFC 4122.
@@ -136,3 +210,21 @@ func RandUniqueIntSlice(n, min, max int) []int {
 
 	return nums
 }
+
+// RandFloats generate a slice of random float64 numbers of length n that do not repeat.
+// Play: https://go.dev/play/p/I3yndUQ-rhh
+func RandFloats(n int, min, max float64, precision int) []float64 {
+	nums := make([]float64, n)
+	used := make(map[float64]struct{}, n)
+	for i := 0; i < n; {
+		r := RandFloat(min, max, precision)
+		if _, use := used[r]; use {
+			continue
+		}
+		used[r] = struct{}{}
+		nums[i] = r
+		i++
+	}
+
+	return nums
+}

random/random_example_test.go

@@ -3,6 +3,7 @@ package random
 import (
 	"fmt"
 	"regexp"
+	"strconv"
 )
 
 func ExampleRandInt() {
@@ -134,3 +135,53 @@ func ExampleRandUniqueIntSlice() {
 	// Output:
 	// ok
 }
+
+func ExampleRandSymbolChar() {
+	pattern := `^[\W|_]+$`
+	reg := regexp.MustCompile(pattern)
+
+	s := RandSymbolChar(6)
+
+	result1 := reg.MatchString(s)
+	result2 := len(s)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+
+	// Output:
+	// true
+	// 6
+}
+
+func ExampleRandFloat() {
+	pattern := `^[\d{1}.\d{2}]+$`
+	reg := regexp.MustCompile(pattern)
+
+	num := RandFloat(1.0, 5.0, 2)
+
+	// check num is a random float in [1.0, 5.0)
+	result1 := num >= 1.0 && num < 5.0
+	result2 := reg.MatchString(strconv.FormatFloat(num, 'f', -1, 64))
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+
+	// Output:
+	// true
+	// true
+}
+
+func ExampleRandFloats() {
+	isInRange := true
+	numbers := RandFloats(5, 1.0, 5.0, 2)
+	for _, n := range numbers {
+		isInRange = (n >= 1.0 && n < 5.0)
+	}
+
+	fmt.Println(isInRange)
+	fmt.Println(len(numbers))
+
+	// Output:
+	// true
+	// 5
+}

random/random_test.go

@@ -154,3 +154,45 @@ func hasDuplicate(arr []int) bool {
 	}
 	return false
 }
+
+func TestRandSymbolChar(t *testing.T) {
+	t.Parallel()
+
+	pattern := `^[\W|_]+$`
+	reg := regexp.MustCompile(pattern)
+
+	symbolChars := RandSymbolChar(10)
+
+	assert := internal.NewAssert(t, "TestRandSymbolChar")
+	assert.Equal(10, len(symbolChars))
+	assert.Equal(true, reg.MatchString(symbolChars))
+}
+
+func TestRandFloat(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestRandFloat")
+
+	r1 := RandFloat(1.1, 10.1, 2)
+	assert.GreaterOrEqual(r1, 1.1)
+	assert.Less(r1, 10.1)
+
+	r2 := RandFloat(1.1, 1.1, 2)
+	assert.Equal(1.1, r2)
+
+	r3 := RandFloat(10.1, 1.1, 2)
+	assert.GreaterOrEqual(r1, 1.1)
+	assert.Less(r3, 10.1)
+}
+
+func TestRandFloats(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestRandFloats")
+
+	numbers := RandFloats(5, 1.0, 5.0, 2)
+	for _, n := range numbers {
+		assert.Equal(true, (n >= 1.0 && n < 5.0))
+	}
+
+	assert.Equal(len(numbers), 5)
+}

retry/retry.go

@@ -8,6 +8,8 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"math"
+	"math/rand"
 	"reflect"
 	"runtime"
 	"strings"
@@ -18,14 +20,14 @@ const (
 	// DefaultRetryTimes times of retry
 	DefaultRetryTimes = 5
 	// DefaultRetryDuration time duration of two retries
-	DefaultRetryDuration = time.Second * 3
+	DefaultRetryLinearInterval = time.Second * 3
 )
 
 // RetryConfig is config for retry
 type RetryConfig struct {
-	context       context.Context
-	retryTimes    uint
-	retryDuration time.Duration
+	context         context.Context
+	retryTimes      uint
+	backoffStrategy BackoffStrategy
 }
 
 // RetryFunc is function that retry executes
@@ -42,11 +44,59 @@ func RetryTimes(n uint) Option {
 	}
 }
 
-// RetryDuration set duration of retries.
-// Play: https://go.dev/play/p/nk2XRmagfVF
-func RetryDuration(d time.Duration) Option {
+// RetryWithCustomBackoff set abitary custom backoff strategy
+// todo: Add playground link
+func RetryWithCustomBackoff(backoffStrategy BackoffStrategy) Option {
+	if backoffStrategy == nil {
+		panic("programming error: backoffStrategy must be not nil")
+	}
+
 	return func(rc *RetryConfig) {
-		rc.retryDuration = d
+		rc.backoffStrategy = backoffStrategy
+	}
+}
+
+// RetryWithLinearBackoff set linear strategy backoff
+// todo: Add playground link
+func RetryWithLinearBackoff(interval time.Duration) Option {
+	if interval <= 0 {
+		panic("programming error: retry interval should not be lower or equal to 0")
+	}
+
+	return func(rc *RetryConfig) {
+		rc.backoffStrategy = &linear{
+			interval: interval,
+		}
+	}
+}
+
+// RetryWithExponentialWithJitterBackoff set exponential strategy backoff
+// todo: Add playground link
+func RetryWithExponentialWithJitterBackoff(interval time.Duration, base uint64, maxJitter time.Duration) Option {
+	if interval <= 0 {
+		panic("programming error: retry interval should not be lower or equal to 0")
+	}
+
+	if maxJitter < 0 {
+		panic("programming error: retry maxJitter should not be lower to 0")
+	}
+
+	if base%2 == 0 {
+		return func(rc *RetryConfig) {
+			rc.backoffStrategy = &shiftExponentialWithJitter{
+				interval:  interval,
+				maxJitter: maxJitter,
+				shifter:   uint64(math.Log2(float64(base))),
+			}
+		}
+	}
+
+	return func(rc *RetryConfig) {
+		rc.backoffStrategy = &exponentialWithJitter{
+			interval:  interval,
+			base:      time.Duration(base),
+			maxJitter: maxJitter,
+		}
 	}
 }
 
@@ -63,21 +113,26 @@ func Context(ctx context.Context) Option {
 // Play: https://go.dev/play/p/nk2XRmagfVF
 func Retry(retryFunc RetryFunc, opts ...Option) error {
 	config := &RetryConfig{
-		retryTimes:    DefaultRetryTimes,
-		retryDuration: DefaultRetryDuration,
-		context:       context.TODO(),
+		retryTimes: DefaultRetryTimes,
+		context:    context.TODO(),
 	}
 
 	for _, opt := range opts {
 		opt(config)
 	}
 
+	if config.backoffStrategy == nil {
+		config.backoffStrategy = &linear{
+			interval: DefaultRetryLinearInterval,
+		}
+	}
+
 	var i uint
 	for i < config.retryTimes {
 		err := retryFunc()
 		if err != nil {
 			select {
-			case <-time.After(config.retryDuration):
+			case <-time.After(config.backoffStrategy.CalculateInterval()):
 			case <-config.context.Done():
 				return errors.New("retry is cancelled")
 			}
@@ -93,3 +148,58 @@ func Retry(retryFunc RetryFunc, opts ...Option) error {
 
 	return fmt.Errorf("function %s run failed after %d times retry", funcName, i)
 }
+
+// BackoffStrategy is an interface that defines a method for calculating backoff intervals.
+type BackoffStrategy interface {
+	// CalculateInterval returns the time.Duration after which the next retry attempt should be made.
+	CalculateInterval() time.Duration
+}
+
+// linear is a struct that implements the BackoffStrategy interface using a linear backoff strategy.
+type linear struct {
+	// interval specifies the fixed duration to wait between retry attempts.
+	interval time.Duration
+}
+
+// CalculateInterval calculates the next interval returns a constant.
+func (l *linear) CalculateInterval() time.Duration {
+	return l.interval
+}
+
+// exponentialWithJitter is a struct that implements the BackoffStrategy interface using a exponential backoff strategy.
+type exponentialWithJitter struct {
+	base      time.Duration // base is the multiplier for the exponential backoff.
+	interval  time.Duration // interval is the current backoff interval, which will be adjusted over time.
+	maxJitter time.Duration // maxJitter is the maximum amount of jitter to apply to the backoff interval.
+}
+
+// CalculateInterval calculates the next backoff interval with jitter and updates the interval.
+func (e *exponentialWithJitter) CalculateInterval() time.Duration {
+	current := e.interval
+	e.interval = e.interval * e.base
+	return current + jitter(e.maxJitter)
+}
+
+// shiftExponentialWithJitter is a struct that implements the BackoffStrategy interface using a exponential backoff strategy.
+type shiftExponentialWithJitter struct {
+	interval  time.Duration // interval is the current backoff interval, which will be adjusted over time.
+	maxJitter time.Duration // maxJitter is the maximum amount of jitter to apply to the backoff interval.
+	shifter   uint64        // shift by n faster than multiplication
+}
+
+// CalculateInterval calculates the next backoff interval with jitter and updates the interval.
+// Uses shift instead of multiplication
+func (e *shiftExponentialWithJitter) CalculateInterval() time.Duration {
+	current := e.interval
+	e.interval = e.interval << e.shifter
+	return current + jitter(e.maxJitter)
+}
+
+// Jitter adds a random duration, up to maxJitter,
+// to the current interval to introduce randomness and avoid synchronized patterns in retry behavior
+func jitter(maxJitter time.Duration) time.Duration {
+	if maxJitter == 0 {
+		return 0
+	}
+	return time.Duration(rand.Int63n(int64(maxJitter)) + 1)
+}

retry/retry_example_test.go

@@ -20,7 +20,7 @@ func ExampleContext() {
 	}
 
 	Retry(increaseNumber,
-		RetryDuration(time.Microsecond*50),
+		RetryWithLinearBackoff(time.Microsecond*50),
 		Context(ctx),
 	)
 
@@ -30,7 +30,7 @@ func ExampleContext() {
 	// 4
 }
 
-func ExampleRetryDuration() {
+func ExampleRetryWithLinearBackoff() {
 	number := 0
 	increaseNumber := func() error {
 		number++
@@ -40,7 +40,57 @@ func ExampleRetryDuration() {
 		return errors.New("error occurs")
 	}
 
-	err := Retry(increaseNumber, RetryDuration(time.Microsecond*50))
+	err := Retry(increaseNumber, RetryWithLinearBackoff(time.Microsecond*50))
+	if err != nil {
+		return
+	}
+
+	fmt.Println(number)
+
+	// Output:
+	// 3
+}
+
+type ExampleCustomBackoffStrategy struct {
+	interval time.Duration
+}
+
+func (c *ExampleCustomBackoffStrategy) CalculateInterval() time.Duration {
+	return c.interval + 1
+}
+
+func ExampleRetryWithCustomBackoff() {
+	number := 0
+	increaseNumber := func() error {
+		number++
+		if number == 3 {
+			return nil
+		}
+		return errors.New("error occurs")
+	}
+
+	err := Retry(increaseNumber, RetryWithCustomBackoff(&ExampleCustomBackoffStrategy{interval: time.Microsecond * 50}))
+	if err != nil {
+		return
+	}
+
+	fmt.Println(number)
+
+	// Output:
+	// 3
+}
+
+func ExampleRetryWithExponentialWithJitterBackoff() {
+	number := 0
+	increaseNumber := func() error {
+		number++
+		if number == 3 {
+			return nil
+		}
+		return errors.New("error occurs")
+	}
+
+	err := Retry(increaseNumber, RetryWithExponentialWithJitterBackoff(time.Microsecond*50, 2, time.Microsecond*25))
 	if err != nil {
 		return
 	}
@@ -81,7 +131,7 @@ func ExampleRetry() {
 		return errors.New("error occurs")
 	}
 
-	err := Retry(increaseNumber, RetryDuration(time.Microsecond*50))
+	err := Retry(increaseNumber, RetryWithLinearBackoff(time.Microsecond*50))
 	if err != nil {
 		return
 	}

retry/retry_test.go

@@ -20,12 +20,86 @@ func TestRetryFailed(t *testing.T) {
 		return errors.New("error occurs")
 	}
 
-	err := Retry(increaseNumber, RetryDuration(time.Microsecond*50))
+	err := Retry(increaseNumber, RetryWithLinearBackoff(time.Microsecond*50))
 
 	assert.IsNotNil(err)
 	assert.Equal(DefaultRetryTimes, number)
 }
 
+func TestRetryShiftExponentialWithJitterFailed(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestRetryShiftExponentialWithJitterFailed")
+
+	var number int
+	increaseNumber := func() error {
+		number++
+		return errors.New("error occurs")
+	}
+
+	err := Retry(increaseNumber, RetryWithExponentialWithJitterBackoff(time.Microsecond*50, 2, time.Microsecond*25))
+
+	assert.IsNotNil(err)
+	assert.Equal(DefaultRetryTimes, number)
+}
+
+func TestRetryExponentialWithJitterFailed(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestRetryExponentialWithJitterFailed")
+
+	var number int
+	increaseNumber := func() error {
+		number++
+		return errors.New("error occurs")
+	}
+
+	err := Retry(increaseNumber, RetryWithExponentialWithJitterBackoff(time.Microsecond*50, 3, time.Microsecond*25))
+
+	assert.IsNotNil(err)
+	assert.Equal(DefaultRetryTimes, number)
+}
+
+func TestRetryWithExponentialSucceeded(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestRetryWithExponentialSucceeded")
+
+	var number int
+	increaseNumber := func() error {
+		number++
+		if number == DefaultRetryTimes {
+			return nil
+		}
+		return errors.New("error occurs")
+	}
+
+	err := Retry(increaseNumber, RetryWithExponentialWithJitterBackoff(time.Microsecond*50, 3, time.Microsecond*25))
+
+	assert.IsNil(err)
+	assert.Equal(DefaultRetryTimes, number)
+}
+
+func TestRetryWithExponentialShiftSucceeded(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestRetryWithExponentialShiftSucceeded")
+
+	var number int
+	increaseNumber := func() error {
+		number++
+		if number == DefaultRetryTimes {
+			return nil
+		}
+		return errors.New("error occurs")
+	}
+
+	err := Retry(increaseNumber, RetryWithExponentialWithJitterBackoff(time.Microsecond*50, 4, time.Microsecond*25))
+
+	assert.IsNil(err)
+	assert.Equal(DefaultRetryTimes, number)
+}
+
 func TestRetrySucceeded(t *testing.T) {
 	t.Parallel()
 
@@ -40,12 +114,108 @@ func TestRetrySucceeded(t *testing.T) {
 		return errors.New("error occurs")
 	}
 
-	err := Retry(increaseNumber, RetryDuration(time.Microsecond*50))
+	err := Retry(increaseNumber, RetryWithLinearBackoff(time.Microsecond*50))
 
 	assert.IsNil(err)
 	assert.Equal(DefaultRetryTimes, number)
 }
 
+func TestRetryOneShotSucceeded(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestRetryOneShotSucceeded")
+
+	var number int
+	increaseNumber := func() error {
+		number++
+		return nil
+	}
+
+	err := Retry(increaseNumber, RetryWithLinearBackoff(time.Microsecond*50))
+
+	assert.IsNil(err)
+	assert.Equal(1, number)
+}
+
+func TestRetryWitCustomBackoffOneShotSucceeded(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestRetryWitCustomBackoffOneShotSucceeded")
+
+	var number int
+	increaseNumber := func() error {
+		number++
+		if number == DefaultRetryTimes {
+			return nil
+		}
+		return errors.New("error occurs")
+	}
+
+	err := Retry(increaseNumber, RetryWithCustomBackoff(&TestCustomBackoffStrategy{interval: time.Microsecond * 50}))
+
+	assert.IsNil(err)
+	assert.Equal(5, number)
+}
+
+type TestCustomBackoffStrategy struct {
+	interval time.Duration
+}
+
+func (c *TestCustomBackoffStrategy) CalculateInterval() time.Duration {
+	return c.interval + 1
+}
+
+func TestRetryWithExponentialWithJitterBackoffShiftOneShotSucceeded(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestRetryWithExponentialWithJitterBackoffShiftOneShotSucceeded")
+
+	var number int
+	increaseNumber := func() error {
+		number++
+		return nil
+	}
+
+	err := Retry(increaseNumber, RetryWithExponentialWithJitterBackoff(time.Microsecond*50, 2, time.Microsecond*25))
+
+	assert.IsNil(err)
+	assert.Equal(1, number)
+}
+
+func TestRetryWithExponentialWithJitterBackoffOneShotSucceeded(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestRetryWithExponentialWithJitterBackoffOneShotSucceeded")
+
+	var number int
+	increaseNumber := func() error {
+		number++
+		return nil
+	}
+
+	err := Retry(increaseNumber, RetryWithExponentialWithJitterBackoff(time.Microsecond*50, 3, time.Microsecond*25))
+
+	assert.IsNil(err)
+	assert.Equal(1, number)
+}
+
+func TestRetryWithExponentialWithJitterBackoffNoJitterOneShotSucceeded(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestRetryWithExponentialWithJitterBackoffNoJitterOneShotSucceeded")
+
+	var number int
+	increaseNumber := func() error {
+		number++
+		return nil
+	}
+
+	err := Retry(increaseNumber, RetryWithExponentialWithJitterBackoff(time.Microsecond*50, 3, 0))
+
+	assert.IsNil(err)
+	assert.Equal(1, number)
+}
+
 func TestSetRetryTimes(t *testing.T) {
 	t.Parallel()
 
@@ -57,7 +227,7 @@ func TestSetRetryTimes(t *testing.T) {
 		return errors.New("error occurs")
 	}
 
-	err := Retry(increaseNumber, RetryDuration(time.Microsecond*50), RetryTimes(3))
+	err := Retry(increaseNumber, RetryWithLinearBackoff(time.Microsecond*50), RetryTimes(3))
 
 	assert.IsNotNil(err)
 	assert.Equal(3, number)
@@ -79,7 +249,7 @@ func TestCancelRetry(t *testing.T) {
 	}
 
 	err := Retry(increaseNumber,
-		RetryDuration(time.Microsecond*50),
+		RetryWithLinearBackoff(time.Microsecond*50),
 		Context(ctx),
 	)
 

slice/slice.go

@@ -12,6 +12,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/duke-git/lancet/v2/random"
 	"golang.org/x/exp/constraints"
 )
 
@@ -497,20 +498,13 @@ func FlatMap[T any, U any](slice []T, iteratee func(index int, item T) []U) []U
 // Reduce creates an slice of values by running each element of slice thru iteratee function.
 // Play: https://go.dev/play/p/_RfXJJWIsIm
 func Reduce[T any](slice []T, iteratee func(index int, item1, item2 T) T, initial T) T {
-	if len(slice) == 0 {
-		return initial
+	accumulator := initial
+
+	for i, v := range slice {
+		accumulator = iteratee(i, v, accumulator)
 	}
 
-	result := iteratee(0, initial, slice[0])
-
-	tmp := make([]T, 2)
-	for i := 1; i < len(slice); i++ {
-		tmp[0] = result
-		tmp[1] = slice[i]
-		result = iteratee(i, tmp[0], tmp[1])
-	}
-
-	return result
+	return accumulator
 }
 
 // ReduceBy produces a value from slice by accumulating the result of each element as passed through the reducer function.
@@ -624,35 +618,34 @@ func IntSlice(slice any) []int {
 	return result
 }
 
-// DeleteAt delete the element of slice from start index to end index - 1.
-// Play: https://go.dev/play/p/pJ-d6MUWcvK
-func DeleteAt[T any](slice []T, start int, end ...int) []T {
-	size := len(slice)
-
-	if start < 0 || start >= size {
-		return slice
+// DeleteAt delete the element of slice at index.
+// Play: https://go.dev/play/p/800B1dPBYyd
+func DeleteAt[T any](slice []T, index int) []T {
+	if index >= len(slice) {
+		index = len(slice) - 1
 	}
 
-	if len(end) > 0 {
-		end := end[0]
-		if end <= start {
-			return slice
-		}
-		if end > size {
-			end = size
-		}
+	result := make([]T, len(slice)-1)
+	copy(result, slice[:index])
+	copy(result[index:], slice[index+1:])
 
-		slice = append(slice[:start], slice[end:]...)
-		return slice
+	return result
+}
+
+// DeleteRange delete the element of slice from start index to end index（exclude).
+// Play: https://go.dev/play/p/945HwiNrnle
+func DeleteRange[T any](slice []T, start, end int) []T {
+	result := make([]T, 0, len(slice)-(end-start))
+
+	for i := 0; i < start; i++ {
+		result = append(result, slice[i])
 	}
 
-	if start == size-1 {
-		slice = slice[:start]
-	} else {
-		slice = append(slice[:start], slice[start+1:]...)
+	for i := end; i < len(slice); i++ {
+		result = append(result, slice[i])
 	}
 
-	return slice
+	return result
 }
 
 // Drop drop n elements from the start of a slice.
@@ -1229,3 +1222,14 @@ func Partition[T any](slice []T, predicates ...func(item T) bool) [][]T {
 
 	return result
 }
+
+// Random get a random item of slice, return idx=-1 when slice is empty
+// Play: https://go.dev/play/p/UzpGQptWppw
+func Random[T any](slice []T) (val T, idx int) {
+	if len(slice) == 0 {
+		return val, -1
+	}
+
+	idx = random.RandInt(0, len(slice))
+	return slice[idx], idx
+}

slice/slice_example_test.go

@@ -594,18 +594,46 @@ func ExampleIntSlice() {
 }
 
 func ExampleDeleteAt() {
-	result1 := DeleteAt([]string{"a", "b", "c"}, -1)
-	result2 := DeleteAt([]string{"a", "b", "c"}, 0)
-	result3 := DeleteAt([]string{"a", "b", "c"}, 0, 2)
+	chars := []string{"a", "b", "c", "d", "e"}
+
+	result1 := DeleteAt(chars, 0)
+	result2 := DeleteAt(chars, 4)
+	result3 := DeleteAt(chars, 5)
+	result4 := DeleteAt(chars, 6)
 
 	fmt.Println(result1)
 	fmt.Println(result2)
 	fmt.Println(result3)
+	fmt.Println(result4)
 
 	// Output:
-	// [a b c]
-	// [b c]
-	// [c]
+	// [b c d e]
+	// [a b c d]
+	// [a b c d]
+	// [a b c d]
+}
+
+func ExampleDeleteRange() {
+	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]
+	// []
 }
 
 func ExampleDrop() {
@@ -1063,3 +1091,14 @@ func ExamplePartition() {
 	// [[2 4] [1 3 5]]
 	// [[1 2] [3 4] [5]]
 }
+
+func ExampleRandom() {
+	nums := []int{1, 2, 3, 4, 5}
+
+	val, idx := Random(nums)
+	if idx >= 0 && idx < len(nums) && Contain(nums, val) {
+		fmt.Println("okk")
+	}
+	// Output:
+	// okk
+}

slice/slice_test.go

@@ -572,19 +572,27 @@ func TestDeleteAt(t *testing.T) {
 	t.Parallel()
 
 	assert := internal.NewAssert(t, "TestDeleteAt")
+	arr := []int{1, 2, 3, 4, 5}
 
-	assert.Equal([]string{"a", "b", "c"}, DeleteAt([]string{"a", "b", "c"}, -1))
-	assert.Equal([]string{"a", "b", "c"}, DeleteAt([]string{"a", "b", "c"}, 3))
-	assert.Equal([]string{"b", "c"}, DeleteAt([]string{"a", "b", "c"}, 0))
-	assert.Equal([]string{"a", "c"}, DeleteAt([]string{"a", "b", "c"}, 1))
-	assert.Equal([]string{"a", "b"}, DeleteAt([]string{"a", "b", "c"}, 2))
+	assert.Equal([]int{2, 3, 4, 5}, DeleteAt(arr, 0))
+	assert.Equal([]int{1, 2, 3, 4}, DeleteAt(arr, 4))
 
-	assert.Equal([]string{"b", "c"}, DeleteAt([]string{"a", "b", "c"}, 0, 1))
-	assert.Equal([]string{"c"}, DeleteAt([]string{"a", "b", "c"}, 0, 2))
-	assert.Equal([]string{}, DeleteAt([]string{"a", "b", "c"}, 0, 3))
-	assert.Equal([]string{}, DeleteAt([]string{"a", "b", "c"}, 0, 4))
-	assert.Equal([]string{"a"}, DeleteAt([]string{"a", "b", "c"}, 1, 3))
-	assert.Equal([]string{"a"}, DeleteAt([]string{"a", "b", "c"}, 1, 4))
+	assert.Equal([]int{1, 2, 3, 4}, DeleteAt(arr, 5))
+	assert.Equal([]int{1, 2, 3, 4}, DeleteAt(arr, 6))
+
+	assert.Equal([]int{1, 2, 3, 4, 5}, arr)
+}
+
+func TestDeleteRange(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestDeleteRange")
+
+	arr := []int{1, 2, 3, 4, 5}
+
+	assert.Equal([]int{1, 2, 3, 4, 5}, DeleteRange(arr, 0, 0))
+	assert.Equal([]int{2, 3, 4, 5}, DeleteRange(arr, 0, 1))
+	assert.Equal([]int{4, 5}, DeleteRange(arr, 0, 3))
 }
 
 func TestDrop(t *testing.T) {
@@ -1185,3 +1193,28 @@ func TestPartition(t *testing.T) {
 	assert.Equal([][]int{{2, 4}, {1, 3, 5}}, Partition([]int{1, 2, 3, 4, 5}, func(n int) bool { return n%2 == 0 }))
 	assert.Equal([][]int{{1, 2}, {3, 4}, {5}}, Partition([]int{1, 2, 3, 4, 5}, func(n int) bool { return n == 1 || n == 2 }, func(n int) bool { return n == 2 || n == 3 || n == 4 }))
 }
+
+func TestRandom(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestRandom")
+
+	var arr []int
+	var val, idx int
+
+	_, idx = Random(arr)
+	assert.Equal(-1, idx)
+
+	arr = []int{}
+	_, idx = Random(arr)
+	assert.Equal(-1, idx)
+
+	arr = []int{1}
+	val, idx = Random(arr)
+	assert.Equal(0, idx)
+	assert.Equal(arr[idx], val)
+
+	arr = []int{1, 2, 3}
+	val, idx = Random(arr)
+	assert.Greater(len(arr), idx)
+	assert.Equal(arr[idx], val)
+}

stream/stream.go

@@ -47,19 +47,19 @@ import (
 // 	Concat(streams ...StreamI[T]) StreamI[T]
 // }
 
-type stream[T any] struct {
+type Stream[T any] struct {
 	source []T
 }
 
 // Of creates a stream whose elements are the specified values.
 // Play: https://go.dev/play/p/jI6_iZZuVFE
-func Of[T any](elems ...T) stream[T] {
+func Of[T any](elems ...T) Stream[T] {
 	return FromSlice(elems)
 }
 
 // Generate stream where each element is generated by the provided generater function
 // Play: https://go.dev/play/p/rkOWL1yA3j9
-func Generate[T any](generator func() func() (item T, ok bool)) stream[T] {
+func Generate[T any](generator func() func() (item T, ok bool)) Stream[T] {
 	source := make([]T, 0)
 
 	var zeroValue T
@@ -76,13 +76,13 @@ func Generate[T any](generator func() func() (item T, ok bool)) stream[T] {
 
 // FromSlice creates stream from slice.
 // Play: https://go.dev/play/p/wywTO0XZtI4
-func FromSlice[T any](source []T) stream[T] {
-	return stream[T]{source: source}
+func FromSlice[T any](source []T) Stream[T] {
+	return Stream[T]{source: source}
 }
 
 // FromChannel creates stream from channel.
 // Play: https://go.dev/play/p/9TZYugGMhXZ
-func FromChannel[T any](source <-chan T) stream[T] {
+func FromChannel[T any](source <-chan T) Stream[T] {
 	s := make([]T, 0)
 
 	for v := range source {
@@ -94,7 +94,7 @@ func FromChannel[T any](source <-chan T) stream[T] {
 
 // FromRange creates a number stream from start to end. both start and end are included. [start, end]
 // Play: https://go.dev/play/p/9Ex1-zcg-B-
-func FromRange[T constraints.Integer | constraints.Float](start, end, step T) stream[T] {
+func FromRange[T constraints.Integer | constraints.Float](start, end, step T) Stream[T] {
 	if end < start {
 		panic("stream.FromRange: param start should be before param end")
 	} else if step <= 0 {
@@ -113,7 +113,7 @@ func FromRange[T constraints.Integer | constraints.Float](start, end, step T) st
 
 // Concat creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.
 // Play: https://go.dev/play/p/HM4OlYk_OUC
-func Concat[T any](a, b stream[T]) stream[T] {
+func Concat[T any](a, b Stream[T]) Stream[T] {
 	source := make([]T, 0)
 
 	source = append(source, a.source...)
@@ -124,7 +124,7 @@ func Concat[T any](a, b stream[T]) stream[T] {
 
 // Distinct returns a stream that removes the duplicated items.
 // Play: https://go.dev/play/p/eGkOSrm64cB
-func (s stream[T]) Distinct() stream[T] {
+func (s Stream[T]) Distinct() Stream[T] {
 	source := make([]T, 0)
 
 	distinct := map[string]bool{}
@@ -153,7 +153,7 @@ func hashKey(data any) string {
 
 // Filter returns a stream consisting of the elements of this stream that match the given predicate.
 // Play: https://go.dev/play/p/MFlSANo-buc
-func (s stream[T]) Filter(predicate func(item T) bool) stream[T] {
+func (s Stream[T]) Filter(predicate func(item T) bool) Stream[T] {
 	source := make([]T, 0)
 
 	for _, v := range s.source {
@@ -167,7 +167,7 @@ func (s stream[T]) Filter(predicate func(item T) bool) stream[T] {
 
 // Map returns a stream consisting of the elements of this stream that apply the given function to elements of stream.
 // Play: https://go.dev/play/p/OtNQUImdYko
-func (s stream[T]) Map(mapper func(item T) T) stream[T] {
+func (s Stream[T]) Map(mapper func(item T) T) Stream[T] {
 	source := make([]T, s.Count())
 
 	for i, v := range s.source {
@@ -179,7 +179,7 @@ func (s stream[T]) Map(mapper func(item T) T) stream[T] {
 
 // Peek returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as elements are consumed from the resulting stream.
 // Play: https://go.dev/play/p/u1VNzHs6cb2
-func (s stream[T]) Peek(consumer func(item T)) stream[T] {
+func (s Stream[T]) Peek(consumer func(item T)) Stream[T] {
 	for _, v := range s.source {
 		consumer(v)
 	}
@@ -190,7 +190,7 @@ func (s stream[T]) Peek(consumer func(item T)) stream[T] {
 // Skip returns a stream consisting of the remaining elements of this stream after discarding the first n elements of the stream.
 // If this stream contains fewer than n elements then an empty stream will be returned.
 // Play: https://go.dev/play/p/fNdHbqjahum
-func (s stream[T]) Skip(n int) stream[T] {
+func (s Stream[T]) Skip(n int) Stream[T] {
 	if n <= 0 {
 		return s
 	}
@@ -211,7 +211,7 @@ func (s stream[T]) Skip(n int) stream[T] {
 
 // Limit returns a stream consisting of the elements of this stream, truncated to be no longer than maxSize in length.
 // Play: https://go.dev/play/p/qsO4aniDcGf
-func (s stream[T]) Limit(maxSize int) stream[T] {
+func (s Stream[T]) Limit(maxSize int) Stream[T] {
 	if s.source == nil {
 		return s
 	}
@@ -231,7 +231,7 @@ func (s stream[T]) Limit(maxSize int) stream[T] {
 
 // AllMatch returns whether all elements of this stream match the provided predicate.
 // Play: https://go.dev/play/p/V5TBpVRs-Cx
-func (s stream[T]) AllMatch(predicate func(item T) bool) bool {
+func (s Stream[T]) AllMatch(predicate func(item T) bool) bool {
 	for _, v := range s.source {
 		if !predicate(v) {
 			return false
@@ -243,7 +243,7 @@ func (s stream[T]) AllMatch(predicate func(item T) bool) bool {
 
 // AnyMatch returns whether any elements of this stream match the provided predicate.
 // Play: https://go.dev/play/p/PTCnWn4OxSn
-func (s stream[T]) AnyMatch(predicate func(item T) bool) bool {
+func (s Stream[T]) AnyMatch(predicate func(item T) bool) bool {
 	for _, v := range s.source {
 		if predicate(v) {
 			return true
@@ -255,13 +255,13 @@ func (s stream[T]) AnyMatch(predicate func(item T) bool) bool {
 
 // NoneMatch returns whether no elements of this stream match the provided predicate.
 // Play: https://go.dev/play/p/iWS64pL1oo3
-func (s stream[T]) NoneMatch(predicate func(item T) bool) bool {
+func (s Stream[T]) NoneMatch(predicate func(item T) bool) bool {
 	return !s.AnyMatch(predicate)
 }
 
 // ForEach performs an action for each element of this stream.
 // Play: https://go.dev/play/p/Dsm0fPqcidk
-func (s stream[T]) ForEach(action func(item T)) {
+func (s Stream[T]) ForEach(action func(item T)) {
 	for _, v := range s.source {
 		action(v)
 	}
@@ -269,7 +269,7 @@ func (s stream[T]) ForEach(action func(item T)) {
 
 // Reduce performs a reduction on the elements of this stream, using an associative accumulation function, and returns an Optional describing the reduced value, if any.
 // Play: https://go.dev/play/p/6uzZjq_DJLU
-func (s stream[T]) Reduce(initial T, accumulator func(a, b T) T) T {
+func (s Stream[T]) Reduce(initial T, accumulator func(a, b T) T) T {
 	for _, v := range s.source {
 		initial = accumulator(initial, v)
 	}
@@ -279,13 +279,13 @@ func (s stream[T]) Reduce(initial T, accumulator func(a, b T) T) T {
 
 // Count returns the count of elements in the stream.
 // Play: https://go.dev/play/p/r3koY6y_Xo-
-func (s stream[T]) Count() int {
+func (s Stream[T]) Count() int {
 	return len(s.source)
 }
 
 // FindFirst returns the first element of this stream and true, or zero value and false if the stream is empty.
 // Play: https://go.dev/play/p/9xEf0-6C1e3
-func (s stream[T]) FindFirst() (T, bool) {
+func (s Stream[T]) FindFirst() (T, bool) {
 	var result T
 
 	if s.source == nil || len(s.source) == 0 {
@@ -297,7 +297,7 @@ func (s stream[T]) FindFirst() (T, bool) {
 
 // FindLast returns the last element of this stream and true, or zero value and false if the stream is empty.
 // Play: https://go.dev/play/p/WZD2rDAW-2h
-func (s stream[T]) FindLast() (T, bool) {
+func (s Stream[T]) FindLast() (T, bool) {
 	var result T
 
 	if s.source == nil || len(s.source) == 0 {
@@ -309,7 +309,7 @@ func (s stream[T]) FindLast() (T, bool) {
 
 // Reverse returns a stream whose elements are reverse order of given stream.
 // Play: https://go.dev/play/p/A8_zkJnLHm4
-func (s stream[T]) Reverse() stream[T] {
+func (s Stream[T]) Reverse() Stream[T] {
 	l := len(s.source)
 	source := make([]T, l)
 
@@ -321,7 +321,7 @@ func (s stream[T]) Reverse() stream[T] {
 
 // Range returns a stream whose elements are in the range from start(included) to end(excluded) original stream.
 // Play: https://go.dev/play/p/indZY5V2f4j
-func (s stream[T]) Range(start, end int) stream[T] {
+func (s Stream[T]) Range(start, end int) Stream[T] {
 	if start < 0 {
 		start = 0
 	}
@@ -347,7 +347,7 @@ func (s stream[T]) Range(start, end int) stream[T] {
 
 // Sorted returns a stream consisting of the elements of this stream, sorted according to the provided less function.
 // Play: https://go.dev/play/p/XXtng5uonFj
-func (s stream[T]) Sorted(less func(a, b T) bool) stream[T] {
+func (s Stream[T]) Sorted(less func(a, b T) bool) Stream[T] {
 	source := []T{}
 	source = append(source, s.source...)
 
@@ -359,7 +359,7 @@ func (s stream[T]) Sorted(less func(a, b T) bool) stream[T] {
 // Max returns the maximum element of this stream according to the provided less function.
 // less: a > b
 // Play: https://go.dev/play/p/fm-1KOPtGzn
-func (s stream[T]) Max(less func(a, b T) bool) (T, bool) {
+func (s Stream[T]) Max(less func(a, b T) bool) (T, bool) {
 	var max T
 
 	if len(s.source) == 0 {
@@ -377,7 +377,7 @@ func (s stream[T]) Max(less func(a, b T) bool) (T, bool) {
 // Min returns the minimum element of this stream according to the provided less function.
 // less: a < b
 // Play: https://go.dev/play/p/vZfIDgGNRe_0
-func (s stream[T]) Min(less func(a, b T) bool) (T, bool) {
+func (s Stream[T]) Min(less func(a, b T) bool) (T, bool) {
 	var min T
 
 	if len(s.source) == 0 {
@@ -395,6 +395,6 @@ func (s stream[T]) Min(less func(a, b T) bool) (T, bool) {
 
 // ToSlice return the elements in the stream.
 // Play: https://go.dev/play/p/jI6_iZZuVFE
-func (s stream[T]) ToSlice() []T {
+func (s Stream[T]) ToSlice() []T {
 	return s.source
 }

structs/field.go

@@ -52,6 +52,16 @@ func (f *Field) IsZero() bool {
 	return reflect.DeepEqual(z, v)
 }
 
+// IsNil returns true if the given field is nil value.
+func (f *Field) IsNil() bool {
+	v := f.Value()
+	if v == nil || (reflect.ValueOf(v)).Kind() == reflect.Ptr && reflect.ValueOf(v).IsNil() {
+		return true
+	}
+
+	return false
+}
+
 // Name returns the name of the given field
 func (f *Field) Name() string {
 	return f.field.Name
@@ -68,6 +78,11 @@ func (f *Field) IsSlice() bool {
 	return k == reflect.Slice
 }
 
+// IsTargetType check if a struct field type is target type or not
+func (f *Field) IsTargetType(targetType reflect.Kind) bool {
+	return f.rvalue.Kind() == targetType
+}
+
 // mapValue covert field value to map
 func (f *Field) mapValue(value any) any {
 	val := pointer.ExtractPointer(value)
@@ -106,7 +121,9 @@ func (f *Field) mapValue(value any) any {
 			ret = v.Interface()
 		}
 	default:
-		ret = v.Interface()
+		if v.Kind().String() != "invalid" {
+			ret = v.Interface()
+		}
 	}
 	return ret
 }

structs/field_test.go

@@ -154,6 +154,25 @@ func TestField_IsSlice(t *testing.T) {
 	assert.Equal(true, a.IsSlice())
 }
 
+func TestField_IsTargetType(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestField_IsTargetType")
+
+	type Parent struct {
+		Name string
+		arr  []int
+	}
+
+	p1 := &Parent{Name: "test", arr: []int{1, 2, 3}}
+	s := New(p1)
+	n, _ := s.Field("Name")
+	a, _ := s.Field("arr")
+
+	assert.Equal(true, n.IsTargetType(reflect.String))
+	assert.Equal(true, a.IsTargetType(reflect.Slice))
+}
+
 func TestField_MapValue(t *testing.T) {
 	t.Parallel()
 

structs/struct.go

@@ -2,6 +2,7 @@
 package structs
 
 import (
+	"fmt"
 	"reflect"
 
 	"github.com/duke-git/lancet/v2/pointer"
@@ -61,7 +62,7 @@ func New(value any, tagName ...string) *Struct {
 // ToMap convert the exported fields of a struct to map.
 func (s *Struct) ToMap() (map[string]any, error) {
 	if !s.IsStruct() {
-		return nil, errInvalidStruct(s)
+		return nil, fmt.Errorf("invalid struct %v", s)
 	}
 
 	result := make(map[string]any)
@@ -70,9 +71,15 @@ func (s *Struct) ToMap() (map[string]any, error) {
 		if !f.IsExported() || f.tag.IsEmpty() || f.tag.Name == "-" {
 			continue
 		}
+
 		if f.IsZero() && f.tag.HasOption("omitempty") {
 			continue
 		}
+
+		if f.IsNil() {
+			continue
+		}
+
 		result[f.tag.Name] = f.mapValue(f.Value())
 	}
 

structs/struct_internal.go

@@ -1,7 +0,0 @@
-package structs
-
-import "fmt"
-
-func errInvalidStruct(v any) error {
-	return fmt.Errorf("invalid struct %v", v)
-}

structs/struct_test.go

@@ -65,6 +65,45 @@ func TestStruct_ToMap(t *testing.T) {
 	})
 }
 
+func Test_ToMap2(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestStruct_ToMap")
+
+	type M struct {
+		Name string `json:"name"`
+	}
+
+	type S struct {
+		ID int `json:"id"`
+		M  *M  `json:"m"`
+	}
+
+	s1 := &S{
+		ID: 1,
+	}
+	var expect1 = map[string]any{"id": 1}
+	map1, err := ToMap(s1)
+
+	assert.IsNil(err)
+	assert.Equal(expect1, map1)
+
+	s2 := &S{
+		ID: 1,
+		M: &M{
+			Name: "test",
+		},
+	}
+	var expect2 = map[string]any{
+		"id": 1,
+		"m": map[string]any{
+			"name": "test",
+		}}
+	map2, err := ToMap(s2)
+
+	assert.IsNil(err)
+	assert.Equal(expect2, map2)
+}
+
 func TestStruct_Fields(t *testing.T) {
 	t.Parallel()
 

strutil/string.go

@@ -4,7 +4,6 @@
 package strutil
 
 import (
-	"reflect"
 	"regexp"
 	"strings"
 	"unicode"
@@ -122,40 +121,48 @@ func UpperSnakeCase(s string) string {
 // Before returns the substring of the source string up to the first occurrence of the specified string.
 // Play: https://go.dev/play/p/JAWTZDS4F5w
 func Before(s, char string) string {
-	if s == "" || char == "" {
+	i := strings.Index(s, char)
+
+	if s == "" || char == "" || i == -1 {
 		return s
 	}
-	i := strings.Index(s, char)
+
 	return s[0:i]
 }
 
 // BeforeLast returns the substring of the source string up to the last occurrence of the specified string.
 // Play: https://go.dev/play/p/pJfXXAoG_Te
 func BeforeLast(s, char string) string {
-	if s == "" || char == "" {
+	i := strings.LastIndex(s, char)
+
+	if s == "" || char == "" || i == -1 {
 		return s
 	}
-	i := strings.LastIndex(s, char)
+
 	return s[0:i]
 }
 
 // After returns the substring after the first occurrence of a specified string in the source string.
 // Play: https://go.dev/play/p/RbCOQqCDA7m
 func After(s, char string) string {
-	if s == "" || char == "" {
+	i := strings.Index(s, char)
+
+	if s == "" || char == "" || i == -1 {
 		return s
 	}
-	i := strings.Index(s, char)
+
 	return s[i+len(char):]
 }
 
 // AfterLast returns the substring after the last occurrence of a specified string in the source string.
 // Play: https://go.dev/play/p/1TegARrb8Yn
 func AfterLast(s, char string) string {
-	if s == "" || char == "" {
+	i := strings.LastIndex(s, char)
+
+	if s == "" || char == "" || i == -1 {
 		return s
 	}
-	i := strings.LastIndex(s, char)
+
 	return s[i+len(char):]
 }
 
@@ -380,10 +387,7 @@ func RemoveNonPrintable(str string) string {
 // StringToBytes converts a string to byte slice without a memory allocation.
 // Play: https://go.dev/play/p/7OyFBrf9AxA
 func StringToBytes(str string) (b []byte) {
-	sh := *(*reflect.StringHeader)(unsafe.Pointer(&str))
-	bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
-	bh.Data, bh.Len, bh.Cap = sh.Data, sh.Len, sh.Len
-	return b
+	return *(*[]byte)(unsafe.Pointer(&str))
 }
 
 // BytesToString converts a byte slice to string without a memory allocation.
@@ -409,6 +413,7 @@ func IsBlank(str string) bool {
 }
 
 // IsNotBlank checks if a string is not whitespace, not empty.
+// Play: https://go.dev/play/p/e_oJW0RAquA
 func IsNotBlank(str string) bool {
 	return !IsBlank(str)
 }
@@ -577,3 +582,15 @@ func RemoveWhiteSpace(str string, repalceAll bool) string {
 
 	return strings.TrimSpace(str)
 }
+
+// SubInBetween return substring between the start and end position(excluded) of source string.
+// Play: todo
+func SubInBetween(str string, start string, end string) string {
+	if _, after, ok := strings.Cut(str, start); ok {
+		if before, _, ok := strings.Cut(after, end); ok {
+			return before
+		}
+	}
+
+	return ""
+}

strutil/string_example_test.go

@@ -653,3 +653,17 @@ func ExampleRemoveWhiteSpace() {
 	// helloworld
 	// hello world
 }
+
+func ExampleSubInBetween() {
+	str := "abcde"
+
+	result1 := SubInBetween(str, "", "de")
+	result2 := SubInBetween(str, "a", "d")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+
+	// Output:
+	// abc
+	// bc
+}

strutil/string_internal.go

@@ -32,8 +32,10 @@ func splitIntoStrings(s string, upperCase bool) []string {
 
 	for i := 0; i < len(runes)-1; i++ {
 		if isUpper(runes[i][0]) && isLower(runes[i+1][0]) {
-			runes[i+1] = append([]rune{runes[i][len(runes[i])-1]}, runes[i+1]...)
-			runes[i] = runes[i][:len(runes[i])-1]
+			length := len(runes[i]) - 1
+			temp := runes[i][length]
+			runes[i+1] = append([]rune{temp}, runes[i+1]...)
+			runes[i] = runes[i][:length]
 		}
 	}
 

strutil/string_test.go

@@ -230,6 +230,8 @@ func TestBefore(t *testing.T) {
 
 	assert.Equal("lancet", Before("lancet", ""))
 	assert.Equal("", Before("lancet", "lancet"))
+	assert.Equal("lancet", Before("lancet", "abcdef"))
+
 	assert.Equal("github.com", Before("github.com/test/lancet", "/"))
 	assert.Equal("github.com/", Before("github.com/test/lancet", "test"))
 }
@@ -240,10 +242,10 @@ func TestBeforeLast(t *testing.T) {
 	assert := internal.NewAssert(t, "TestBeforeLast")
 
 	assert.Equal("lancet", BeforeLast("lancet", ""))
+	assert.Equal("lancet", BeforeLast("lancet", "abcdef"))
+
 	assert.Equal("github.com/test", BeforeLast("github.com/test/lancet", "/"))
 	assert.Equal("github.com/test/", BeforeLast("github.com/test/test/lancet", "test"))
-
-	assert.NotEqual("github.com/", BeforeLast("github.com/test/test/lancet", "test"))
 }
 
 func TestAfter(t *testing.T) {
@@ -255,6 +257,8 @@ func TestAfter(t *testing.T) {
 	assert.Equal("", After("lancet", "lancet"))
 	assert.Equal("test/lancet", After("github.com/test/lancet", "/"))
 	assert.Equal("/lancet", After("github.com/test/lancet", "test"))
+
+	assert.Equal("lancet", After("lancet", "abcdef"))
 }
 
 func TestAfterLast(t *testing.T) {
@@ -266,8 +270,7 @@ func TestAfterLast(t *testing.T) {
 	assert.Equal("lancet", AfterLast("github.com/test/lancet", "/"))
 	assert.Equal("/lancet", AfterLast("github.com/test/lancet", "test"))
 	assert.Equal("/lancet", AfterLast("github.com/test/test/lancet", "test"))
-
-	assert.NotEqual("/test/lancet", AfterLast("github.com/test/test/lancet", "test"))
+	assert.Equal("lancet", AfterLast("lancet", "abcdef"))
 }
 
 func TestIsString(t *testing.T) {
@@ -566,3 +569,15 @@ func TestRemoveWhiteSpace(t *testing.T) {
 	assert.Equal("helloworld", RemoveWhiteSpace(str, true))
 	assert.Equal("hello world", RemoveWhiteSpace(str, false))
 }
+
+func TestSubInBetween(t *testing.T) {
+	assert := internal.NewAssert(t, "TestSubInBetween")
+
+	str := "abcde"
+
+	assert.Equal("", SubInBetween(str, "", ""))
+	assert.Equal("ab", SubInBetween(str, "", "c"))
+	assert.Equal("bc", SubInBetween(str, "a", "d"))
+	assert.Equal("", SubInBetween(str, "a", ""))
+	assert.Equal("", SubInBetween(str, "a", "f"))
+}

validator/validator.go

@@ -6,12 +6,14 @@ package validator
 
 import (
 	"encoding/json"
+	"fmt"
 	"net"
 	"net/url"
 	"reflect"
 	"regexp"
 	"strconv"
 	"strings"
+	"time"
 	"unicode"
 )
 
@@ -21,10 +23,10 @@ var (
 	numberRegexMatcher     *regexp.Regexp = regexp.MustCompile(`\d`)
 	intStrMatcher          *regexp.Regexp = regexp.MustCompile(`^[\+-]?\d+$`)
 	urlMatcher             *regexp.Regexp = regexp.MustCompile(`^((ftp|http|https?):\/\/)?(\S+(:\S*)?@)?((([1-9]\d?|1\d\d|2[01]\d|22[0-3])(\.(1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.([0-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(([a-zA-Z0-9]+([-\.][a-zA-Z0-9]+)*)|((www\.)?))?(([a-z\x{00a1}-\x{ffff}0-9]+-?-?)*[a-z\x{00a1}-\x{ffff}0-9]+)(?:\.([a-z\x{00a1}-\x{ffff}]{2,}))?))(:(\d{1,5}))?((\/|\?|#)[^\s]*)?$`)
-	dnsMatcher             *regexp.Regexp = regexp.MustCompile(`^[a-zA-Z]([a-zA-Z0-9\-]+[\.]?)*[a-zA-Z0-9]$`)
+	dnsMatcher             *regexp.Regexp = regexp.MustCompile(`^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$`)
 	emailMatcher           *regexp.Regexp = regexp.MustCompile(`\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*`)
 	chineseMobileMatcher   *regexp.Regexp = regexp.MustCompile(`^1(?:3\d|4[4-9]|5[0-35-9]|6[67]|7[013-8]|8\d|9\d)\d{8}$`)
-	chineseIdMatcher       *regexp.Regexp = regexp.MustCompile(`^[1-9]\d{5}(18|19|20|21|22)\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$`)
+	chineseIdMatcher       *regexp.Regexp = regexp.MustCompile(`^(\d{17})([0-9]|X|x)$`)
 	chineseMatcher         *regexp.Regexp = regexp.MustCompile("[\u4e00-\u9fa5]")
 	chinesePhoneMatcher    *regexp.Regexp = regexp.MustCompile(`\d{3}-\d{8}|\d{4}-\d{7}|\d{4}-\d{8}`)
 	creditCardMatcher      *regexp.Regexp = regexp.MustCompile(`^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|(222[1-9]|22[3-9][0-9]|2[3-6][0-9]{2}|27[01][0-9]|2720)[0-9]{12}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\\d{3})\\d{11}|6[27][0-9]{14})$`)
@@ -39,6 +41,52 @@ var (
 	chinaUnionPay          *regexp.Regexp = regexp.MustCompile(`^62[0-9]{14,17}$`)
 )
 
+var (
+	// Identity card formula
+	factor = [17]int{7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2}
+	// ID verification bit
+	verifyStr = [11]string{"1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"}
+	// Starting year of ID card
+	birthStartYear = 1900
+	// Province code
+	provinceKv = map[string]struct{}{
+		"11": {},
+		"12": {},
+		"13": {},
+		"14": {},
+		"15": {},
+		"21": {},
+		"22": {},
+		"23": {},
+		"31": {},
+		"32": {},
+		"33": {},
+		"34": {},
+		"35": {},
+		"36": {},
+		"37": {},
+		"41": {},
+		"42": {},
+		"43": {},
+		"44": {},
+		"45": {},
+		"46": {},
+		"50": {},
+		"51": {},
+		"52": {},
+		"53": {},
+		"54": {},
+		"61": {},
+		"62": {},
+		"63": {},
+		"64": {},
+		"65": {},
+		//"71": {},
+		//"81": {},
+		//"82": {},
+	}
+)
+
 // IsAlpha checks if the string contains only letters (a-zA-Z).
 // Play: https://go.dev/play/p/7Q5sGOz2izQ
 func IsAlpha(str string) bool {
@@ -120,7 +168,7 @@ func ContainLetter(str string) bool {
 	return letterRegexMatcher.MatchString(str)
 }
 
-// ContainLetter check if the string contain at least one number.
+// ContainNumber check if the string contain at least one number.
 func ContainNumber(input string) bool {
 	return numberRegexMatcher.MatchString(input)
 }
@@ -228,7 +276,32 @@ func IsChineseMobile(mobileNum string) bool {
 // IsChineseIdNum check if the string is chinese id card.
 // Play: https://go.dev/play/p/d8EWhl2UGDF
 func IsChineseIdNum(id string) bool {
-	return chineseIdMatcher.MatchString(id)
+	// All characters should be numbers, and the last digit can be either x or X
+	if !chineseIdMatcher.MatchString(id) {
+		return false
+	}
+
+	// Verify province codes and complete all province codes according to GB/T2260
+	_, ok := provinceKv[id[0:2]]
+	if !ok {
+		return false
+	}
+
+	// Verify birthday, must be greater than birthStartYear and less than the current year
+	birthStr := fmt.Sprintf("%s-%s-%s", id[6:10], id[10:12], id[12:14])
+	birthday, err := time.Parse("2006-01-02", birthStr)
+	if err != nil || birthday.After(time.Now()) || birthday.Year() < birthStartYear {
+		return false
+	}
+
+	// Verification code
+	sum := 0
+	for i, c := range id[:17] {
+		v, _ := strconv.Atoi(string(c))
+		sum += v * factor[i]
+	}
+
+	return verifyStr[sum%11] == strings.ToUpper(id[17:18])
 }
 
 // ContainChinese check if the string contain mandarin chinese.
@@ -384,7 +457,7 @@ func IsGBK(data []byte) bool {
 	return true
 }
 
-// IsNumberStr check if the value is number(integer, float) or not.
+// IsNumber check if the value is number(integer, float) or not.
 // Play: https://go.dev/play/p/mdJHOAvtsvF
 func IsNumber(v any) bool {
 	return IsInt(v) || IsFloat(v)

validator/validator_example_test.go

@@ -154,7 +154,7 @@ func ExampleIsChineseMobile() {
 }
 
 func ExampleIsChineseIdNum() {
-	result1 := IsChineseIdNum("210911192105130715")
+	result1 := IsChineseIdNum("210911192105130714")
 	result2 := IsChineseIdNum("123456")
 
 	fmt.Println(result1)
@@ -200,7 +200,7 @@ func ExampleIsDns() {
 
 	// Output:
 	// true
-	// false
+	// true
 	// false
 }
 

validator/validator_test.go

@@ -271,7 +271,11 @@ func TestIsDns(t *testing.T) {
 	assert := internal.NewAssert(t, "TestIsDns")
 
 	assert.Equal(true, IsDns("abc.com"))
-	assert.Equal(false, IsDns("a.b.com"))
+	assert.Equal(true, IsDns("123.cn"))
+	assert.Equal(true, IsDns("a.b.com"))
+
+	assert.Equal(false, IsDns("a.b.c"))
+	assert.Equal(false, IsDns("a@b.com"))
 	assert.Equal(false, IsDns("http://abc.com"))
 }
 
@@ -320,10 +324,13 @@ func TestIsChineseIdNum(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestIsChineseIdNum")
 
-	assert.Equal(true, IsChineseIdNum("210911192105130715"))
-	assert.Equal(true, IsChineseIdNum("21091119210513071X"))
-	assert.Equal(true, IsChineseIdNum("21091119210513071x"))
+	assert.Equal(true, IsChineseIdNum("210911192105130714"))
+	assert.Equal(true, IsChineseIdNum("11010519491231002X"))
+	assert.Equal(true, IsChineseIdNum("11010519491231002x"))
 	assert.Equal(false, IsChineseIdNum("123456"))
+	assert.Equal(false, IsChineseIdNum("990911192105130714"))
+	assert.Equal(false, IsChineseIdNum("990911189905130714"))
+	assert.Equal(false, IsChineseIdNum("210911222205130714"))
 }
 
 func TestIsCreditCard(t *testing.T) {

xerror/xerror_test.go

@@ -14,12 +14,6 @@ func TestTryUnwrap(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestTryUnwrap")
 	assert.Equal(42, TryUnwrap(strconv.Atoi("42")))
-}
-
-func TestTryUnwrapFail(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestTryUnwrapFail")
 
 	_, err := strconv.Atoi("4o2")
 	defer func() {
@@ -76,8 +70,6 @@ func TestXError_Unwrap(t *testing.T) {
 }
 
 func TestXError_StackTrace(t *testing.T) {
-	// t.Parallel()
-
 	assert := internal.NewAssert(t, "TestXError_StackTrace")
 
 	err := New("error")
@@ -86,7 +78,7 @@ func TestXError_StackTrace(t *testing.T) {
 
 	assert.Equal(3, len(stacks))
 	assert.Equal("github.com/duke-git/lancet/v2/xerror.TestXError_StackTrace", stacks[0].Func)
-	assert.Equal(83, stacks[0].Line)
+	assert.Equal(75, stacks[0].Line)
 	assert.Equal(true, strings.Contains(stacks[0].File, "xerror_test.go"))
 }