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

docs/api/packages/fileutil.md

@@ -26,6 +26,7 @@ import (
 -   [CreateFile](#CreateFile)
 -   [CreateDir](#CreateDir)
 -   [CopyFile](#CopyFile)
+-   [CopyDir](#CopyDir)
 -   [CurrentPath](#CurrentPath)
 -   [FileMode](#FileMode)
 -   [MiMeType](#MiMeType)
@@ -162,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>

docs/api/packages/function.md

@@ -37,6 +37,8 @@ import (
 -   [Or](#Or)
 -   [Negate](#Negate)
 -   [Nor](#Nor)
+-   [Xnor](#Xnor)
+-   [Nand](#Nand)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -563,3 +565,77 @@ func main() {
     // 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/en/api/packages/fileutil.md

@@ -26,6 +26,7 @@ import (
 -   [CreateFile](#CreateFile)
 -   [CreateDir](#CreateDir)
 -   [CopyFile](#CopyFile)
+-   [CopyDir](#CopyDir)
 -   [CurrentPath](#CurrentPath)
 -   [FileMode](#FileMode)
 -   [MiMeType](#MiMeType)
@@ -162,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>

docs/en/api/packages/function.md

@@ -37,6 +37,8 @@ import (
 -   [Or](#Or)
 -   [Negate](#Negate)
 -   [Nor](#Nor)
+-   [Xnor](#Xnor)
+-   [Nand](#Nand)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -562,4 +564,78 @@ func main() {
     // 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
+}
 ```

fileutil/file.go

@@ -113,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 {
@@ -377,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

fileutil/file_test.go

@@ -3,6 +3,8 @@ package fileutil
 import (
 	"io"
 	"os"
+	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/duke-git/lancet/v2/internal"
@@ -544,3 +546,23 @@ func TestReadlineFile(t *testing.T) {
 		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

function/predicate.go

@@ -16,6 +16,22 @@ func And[T any](predicates ...func(T) bool) func(T) bool {
 	}
 }
 
+// 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 {

function/predicate_example_test.go

@@ -53,6 +53,22 @@ func ExampleAnd() {
 	// 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") },

function/predicate_test.go

@@ -54,6 +54,21 @@ func TestPredicatesAndPure(t *testing.T) {
 	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()
 
@@ -108,9 +123,12 @@ func TestPredicatesMix(t *testing.T) {
 
 	assert.ShouldBeFalse(c("hello!"))
 
-	c = Nor(a, b)
-	assert.ShouldBeFalse(c("hello!"))
+	k := Nor(a, b)
+	assert.ShouldBeFalse(k("hello!"))
 
-	c = Xnor(a, b)
-	assert.ShouldBeTrue(c("hello!"))
+	o := Xnor(a, b)
+	assert.ShouldBeTrue(o("hello!"))
+
+	p := Nand(c, k)
+	assert.ShouldBeTrue(p("hello!"))
 }