release v1.4.3

.github/FUNDING.yml

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

.github/workflows/codecov.yml

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

.gitignore

@@ -5,11 +5,9 @@ cryptor/*.txt
 fileutil/*.txt
 fileutil/*.zip
 fileutil/*.link
+fileutil/tempdir
 fileutil/unzip/*
-fileutil/tempdir/*
 slice/testdata/*
-# cryptor/*.pem
-test
+cryptor/*.pem
 docs/node_modules
-docs/.vitepress/cache
-docs/.vitepress/dist
+docs/.vitepress

CONTRIBUTION.md

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

CONTRIBUTION.zh-CN.md

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

SECURITY.md

@@ -1,15 +0,0 @@
-# Security Policy
-
-## Supported Versions
-Here is the lancet version and compatibility with go language version.
-
-| Version | Supported         |
-| ------- | ------------------|
-| 2.x.x   | +go v1.18         |
-| 1.x.x   | +go v1.12         |
-
-
-## Reporting a Vulnerability
-
-For now, there is no public website to report a vulnerability, If you find security issue in lancet, you can send it to me via my email `lanliddd.2007@163.com`.
-we can discuss it. I am appreciate if someone can create a public page for reporting vulnerability.

algorithm/lrucache.go

@@ -1,121 +0,0 @@
-package algorithm
-
-type lruNode[K comparable, V any] struct {
-	key   K
-	value V
-	pre   *lruNode[K, V]
-	next  *lruNode[K, V]
-}
-
-// newLruNode return a lruNode pointer
-func newLruNode[K comparable, V any](key K, value V) *lruNode[K, V] {
-	return &lruNode[K, V]{
-		key:   key,
-		value: value,
-		pre:   nil,
-		next:  nil,
-	}
-}
-
-// LRUCache lru cache (thread unsafe)
-type LRUCache[K comparable, V any] struct {
-	cache    map[K]*lruNode[K, V]
-	head     *lruNode[K, V]
-	tail     *lruNode[K, V]
-	capacity int
-	length   int
-}
-
-// NewLRUCache creates a LRUCache pointer instance.
-func NewLRUCache[K comparable, V any](capacity int) *LRUCache[K, V] {
-	return &LRUCache[K, V]{
-		cache:    make(map[K]*lruNode[K, V], capacity),
-		head:     nil,
-		tail:     nil,
-		capacity: capacity,
-		length:   0,
-	}
-}
-
-// Get value of key from lru cache.
-// Play: https://go.dev/play/p/iUynEfOP8G0
-func (l *LRUCache[K, V]) Get(key K) (V, bool) {
-	var value V
-
-	node, ok := l.cache[key]
-	if ok {
-		l.moveToTail(node)
-		return node.value, true
-	}
-
-	return value, false
-}
-
-// Put value of key into lru cache.
-// Play: https://go.dev/play/p/iUynEfOP8G0
-func (l *LRUCache[K, V]) Put(key K, value V) {
-	node, ok := l.cache[key]
-	if !ok {
-		newNode := newLruNode(key, value)
-		l.cache[key] = newNode
-		l.addNode(newNode)
-
-		if len(l.cache) > l.capacity {
-			oldKey := l.deleteNode(l.head)
-			delete(l.cache, oldKey)
-		}
-	} else {
-		node.value = value
-		l.moveToTail(node)
-	}
-	l.length = len(l.cache)
-}
-
-// Delete item from lru cache.
-func (l *LRUCache[K, V]) Delete(key K) bool {
-	node, ok := l.cache[key]
-	if ok {
-		key := l.deleteNode(node)
-		delete(l.cache, key)
-		return true
-	}
-	l.length = len(l.cache)
-	return false
-}
-
-// Len returns the number of items in the cache.
-func (l *LRUCache[K, V]) Len() int {
-	return l.length
-}
-
-func (l *LRUCache[K, V]) addNode(node *lruNode[K, V]) {
-	if l.tail != nil {
-		l.tail.next = node
-		node.pre = l.tail
-		node.next = nil
-	}
-	l.tail = node
-	if l.head == nil {
-		l.head = node
-	}
-}
-
-func (l *LRUCache[K, V]) deleteNode(node *lruNode[K, V]) K {
-	if node == l.tail {
-		l.tail = l.tail.pre
-	} else if node == l.head {
-		l.head = l.head.next
-	} else {
-		node.pre.next = node.next
-		node.next.pre = node.pre
-	}
-	return node.key
-}
-
-func (l *LRUCache[K, V]) moveToTail(node *lruNode[K, V]) {
-	if l.tail == node {
-		return
-	}
-	l.deleteNode(node)
-	l.addNode(node)
-}

algorithm/lrucache_example_test.go

@@ -1,79 +0,0 @@
-package algorithm
-
-import "fmt"
-
-func ExampleLRUCache_Put() {
-	cache := NewLRUCache[int, int](2)
-
-	cache.Put(1, 1)
-	cache.Put(2, 2)
-
-	result1, ok1 := cache.Get(1)
-	result2, ok2 := cache.Get(2)
-	result3, ok3 := cache.Get(3)
-
-	fmt.Println(result1, ok1)
-	fmt.Println(result2, ok2)
-	fmt.Println(result3, ok3)
-
-	// Output:
-	// 1 true
-	// 2 true
-	// 0 false
-}
-
-func ExampleLRUCache_Get() {
-	cache := NewLRUCache[int, int](2)
-
-	cache.Put(1, 1)
-	cache.Put(2, 2)
-
-	result1, ok1 := cache.Get(1)
-	result2, ok2 := cache.Get(2)
-	result3, ok3 := cache.Get(3)
-
-	fmt.Println(result1, ok1)
-	fmt.Println(result2, ok2)
-	fmt.Println(result3, ok3)
-
-	// Output:
-	// 1 true
-	// 2 true
-	// 0 false
-}
-
-func ExampleLRUCache_Delete() {
-	cache := NewLRUCache[int, int](2)
-
-	cache.Put(1, 1)
-	cache.Put(2, 2)
-
-	result1, ok1 := cache.Get(1)
-
-	ok2 := cache.Delete(2)
-
-	_, ok3 := cache.Get(2)
-
-	fmt.Println(result1, ok1)
-	fmt.Println(ok2)
-	fmt.Println(ok3)
-
-	// Output:
-	// 1 true
-	// true
-	// false
-}
-
-func ExampleLRUCache_Len() {
-	cache := NewLRUCache[int, int](2)
-
-	cache.Put(1, 1)
-	cache.Put(2, 2)
-
-	result := cache.Len()
-
-	fmt.Println(result)
-
-	// Output:
-	// 2
-}

algorithm/lrucache_test.go

@@ -1,34 +0,0 @@
-package algorithm
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestLRUCache(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestLRUCache")
-
-	cache := NewLRUCache[int, int](3)
-
-	cache.Put(1, 1)
-	cache.Put(2, 2)
-	cache.Put(3, 3)
-
-	assert.Equal(3, cache.Len())
-
-	v, ok := cache.Get(1)
-	assert.Equal(true, ok)
-	assert.Equal(1, v)
-
-	v, ok = cache.Get(2)
-	assert.Equal(true, ok)
-	assert.Equal(2, v)
-
-	ok = cache.Delete(2)
-	assert.Equal(true, ok)
-
-	_, ok = cache.Get(2)
-	assert.Equal(false, ok)
-}

algorithm/search.go

@@ -1,66 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package algorithm contain some basic algorithm functions. eg. sort, search, list, linklist, stack, queue, tree, graph.
-package algorithm
-
-import "github.com/duke-git/lancet/v2/constraints"
-
-// Search algorithms see https://github.com/TheAlgorithms/Go/tree/master/search
-
-// LinearSearch return the index of target in slice base on equal function.
-// If not found return -1
-// Play: https://go.dev/play/p/IsS7rgn5s3x
-func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int {
-	for i, v := range slice {
-		if equal(v, target) {
-			return i
-		}
-	}
-	return -1
-}
-
-// 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 constraints.Comparator) int {
-	if highIndex < lowIndex || len(sortedSlice) == 0 {
-		return -1
-	}
-
-	midIndex := int(lowIndex + (highIndex-lowIndex)/2)
-	isMidValGreatTarget := comparator.Compare(sortedSlice[midIndex], target) == 1
-	isMidValLessTarget := comparator.Compare(sortedSlice[midIndex], target) == -1
-
-	if isMidValGreatTarget {
-		return BinarySearch(sortedSlice, target, lowIndex, midIndex-1, comparator)
-	} else if isMidValLessTarget {
-		return BinarySearch(sortedSlice, target, midIndex+1, highIndex, comparator)
-	}
-
-	return midIndex
-}
-
-// BinaryIterativeSearch 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 constraints.Comparator) int {
-	startIndex := lowIndex
-	endIndex := highIndex
-
-	var midIndex int
-	for startIndex <= endIndex {
-		midIndex = int(startIndex + (endIndex-startIndex)/2)
-		isMidValGreatTarget := comparator.Compare(sortedSlice[midIndex], target) == 1
-		isMidValLessTarget := comparator.Compare(sortedSlice[midIndex], target) == -1
-
-		if isMidValGreatTarget {
-			endIndex = midIndex - 1
-		} else if isMidValLessTarget {
-			startIndex = midIndex + 1
-		} else {
-			return midIndex
-		}
-	}
-	return -1
-}

algorithm/search_example_test.go

@@ -1,51 +0,0 @@
-package algorithm
-
-import "fmt"
-
-func ExampleLinearSearch() {
-	numbers := []int{3, 4, 5, 3, 2, 1}
-
-	equalFunc := func(a, b int) bool {
-		return a == b
-	}
-
-	result1 := LinearSearch(numbers, 3, equalFunc)
-	result2 := LinearSearch(numbers, 6, equalFunc)
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-
-	// Output:
-	// 0
-	// -1
-}
-
-func ExampleBinarySearch() {
-	numbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
-	comparator := &intComparator{}
-
-	result1 := BinarySearch(numbers, 5, 0, len(numbers)-1, comparator)
-	result2 := BinarySearch(numbers, 9, 0, len(numbers)-1, comparator)
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-
-	// Output:
-	// 4
-	// -1
-}
-
-func ExampleBinaryIterativeSearch() {
-	numbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
-	comparator := &intComparator{}
-
-	result1 := BinaryIterativeSearch(numbers, 5, 0, len(numbers)-1, comparator)
-	result2 := BinaryIterativeSearch(numbers, 9, 0, len(numbers)-1, comparator)
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-
-	// Output:
-	// 4
-	// -1
-}

algorithm/search_test.go

@@ -1,41 +0,0 @@
-package algorithm
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestLinearSearch(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestLinearSearch")
-
-	numbers := []int{3, 4, 5, 3, 2, 1}
-	equalFunc := func(a, b int) bool {
-		return a == b
-	}
-
-	assert.Equal(0, LinearSearch(numbers, 3, equalFunc))
-	assert.Equal(-1, LinearSearch(numbers, 6, equalFunc))
-}
-
-func TestBinarySearch(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestBinarySearch")
-
-	sortedNumbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
-	comparator := &intComparator{}
-
-	assert.Equal(4, BinarySearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator))
-	assert.Equal(-1, BinarySearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator))
-}
-
-func TestBinaryIterativeSearch(t *testing.T) {
-	assert := internal.NewAssert(t, "TestBinaryIterativeSearch")
-
-	sortedNumbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
-	comparator := &intComparator{}
-
-	assert.Equal(4, BinaryIterativeSearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator))
-	assert.Equal(-1, BinaryIterativeSearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator))
-}

algorithm/sort.go

@@ -1,204 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-package algorithm
-
-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 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 constraints.Comparator) {
-	for i := 0; i < len(slice); i++ {
-		for j := i; j > 0; j-- {
-			isPreLessThanCurrent := comparator.Compare(slice[j], slice[j-1]) == -1
-			if isPreLessThanCurrent {
-				swap(slice, j, j-1)
-			} else {
-				break
-			}
-		}
-	}
-}
-
-// SelectionSort 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 constraints.Comparator) {
-	for i := 0; i < len(slice); i++ {
-		min := i
-		for j := i + 1; j < len(slice); j++ {
-			if comparator.Compare(slice[j], slice[min]) == -1 {
-				min = j
-			}
-		}
-		swap(slice, i, min)
-	}
-}
-
-// ShellSort 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 constraints.Comparator) {
-	size := len(slice)
-
-	gap := 1
-	for gap < size/3 {
-		gap = 3*gap + 1
-	}
-
-	for gap >= 1 {
-		for i := gap; i < size; i++ {
-			for j := i; j >= gap && comparator.Compare(slice[j], slice[j-gap]) == -1; j -= gap {
-				swap(slice, j, j-gap)
-			}
-		}
-		gap = gap / 3
-	}
-}
-
-// QuickSort quick sorting for slice, lowIndex is 0 and highIndex is len(slice)-1.
-// Play: https://go.dev/play/p/7Y7c1Elk3ax
-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 constraints.Comparator) {
-	if lowIndex < highIndex {
-		p := partition(slice, lowIndex, highIndex, comparator)
-		quickSort(slice, lowIndex, p-1, comparator)
-		quickSort(slice, p+1, highIndex, comparator)
-	}
-}
-
-// partition split slice into two parts
-func partition[T any](slice []T, lowIndex, highIndex int, comparator constraints.Comparator) int {
-	p := slice[highIndex]
-	i := lowIndex
-	for j := lowIndex; j < highIndex; j++ {
-		if comparator.Compare(slice[j], p) == -1 { //slice[j] < p
-			swap(slice, i, j)
-			i++
-		}
-	}
-
-	swap(slice, i, highIndex)
-
-	return i
-}
-
-// HeapSort 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 constraints.Comparator) {
-	size := len(slice)
-
-	for i := size/2 - 1; i >= 0; i-- {
-		sift(slice, i, size-1, comparator)
-	}
-	for j := size - 1; j > 0; j-- {
-		swap(slice, 0, j)
-		sift(slice, 0, j-1, comparator)
-	}
-}
-
-func sift[T any](slice []T, lowIndex, highIndex int, comparator constraints.Comparator) {
-	i := lowIndex
-	j := 2*i + 1
-
-	temp := slice[i]
-	for j <= highIndex {
-		if j < highIndex && comparator.Compare(slice[j], slice[j+1]) == -1 { //slice[j] < slice[j+1]
-			j++
-		}
-		if comparator.Compare(temp, slice[j]) == -1 { //tmp < slice[j]
-			slice[i] = slice[j]
-			i = j
-			j = 2*i + 1
-		} else {
-			break
-		}
-	}
-	slice[i] = temp
-}
-
-// MergeSort 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 constraints.Comparator) {
-	mergeSort(slice, 0, len(slice)-1, 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)
-		mergeSort(slice, mid+1, highIndex, comparator)
-		merge(slice, lowIndex, mid, highIndex, comparator)
-	}
-}
-
-func merge[T any](slice []T, lowIndex, midIndex, highIndex int, comparator constraints.Comparator) {
-	i := lowIndex
-	j := midIndex + 1
-	temp := []T{}
-
-	for i <= midIndex && j <= highIndex {
-		//slice[i] < slice[j]
-		if comparator.Compare(slice[i], slice[j]) == -1 {
-			temp = append(temp, slice[i])
-			i++
-		} else {
-			temp = append(temp, slice[j])
-			j++
-		}
-	}
-
-	if i <= midIndex {
-		temp = append(temp, slice[i:midIndex+1]...)
-	} else {
-		temp = append(temp, slice[j:highIndex+1]...)
-	}
-
-	for k := 0; k < len(temp); k++ {
-		slice[lowIndex+k] = temp[k]
-	}
-}
-
-// CountSort 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 constraints.Comparator) []T {
-	size := len(slice)
-	out := make([]T, size)
-
-	for i := 0; i < size; i++ {
-		count := 0
-		for j := 0; j < size; j++ {
-			//slice[i] > slice[j]
-			if comparator.Compare(slice[i], slice[j]) == 1 {
-				count++
-			}
-		}
-		out[count] = slice[i]
-	}
-
-	return out
-}
-
-// swap two slice value at index i and j
-func swap[T any](slice []T, i, j int) {
-	slice[i], slice[j] = slice[j], slice[i]
-}

algorithm/sort_example_test.go

@@ -1,93 +0,0 @@
-package algorithm
-
-import "fmt"
-
-func ExampleBubbleSort() {
-	numbers := []int{2, 1, 5, 3, 6, 4}
-	comparator := &intComparator{}
-
-	BubbleSort(numbers, comparator)
-
-	fmt.Println(numbers)
-	// Output:
-	// [1 2 3 4 5 6]
-}
-
-func ExampleCountSort() {
-	numbers := []int{2, 1, 5, 3, 6, 4}
-	comparator := &intComparator{}
-
-	sortedNumber := CountSort(numbers, comparator)
-
-	fmt.Println(numbers)
-	fmt.Println(sortedNumber)
-	// Output:
-	// [2 1 5 3 6 4]
-	// [1 2 3 4 5 6]
-}
-
-func ExampleHeapSort() {
-	numbers := []int{2, 1, 5, 3, 6, 4}
-	comparator := &intComparator{}
-
-	HeapSort(numbers, comparator)
-
-	fmt.Println(numbers)
-	// Output:
-	// [1 2 3 4 5 6]
-}
-
-func ExampleMergeSort() {
-	numbers := []int{2, 1, 5, 3, 6, 4}
-	comparator := &intComparator{}
-
-	MergeSort(numbers, comparator)
-
-	fmt.Println(numbers)
-	// Output:
-	// [1 2 3 4 5 6]
-}
-
-func ExampleInsertionSort() {
-	numbers := []int{2, 1, 5, 3, 6, 4}
-	comparator := &intComparator{}
-
-	InsertionSort(numbers, comparator)
-
-	fmt.Println(numbers)
-	// Output:
-	// [1 2 3 4 5 6]
-}
-
-func ExampleSelectionSort() {
-	numbers := []int{2, 1, 5, 3, 6, 4}
-	comparator := &intComparator{}
-
-	SelectionSort(numbers, comparator)
-
-	fmt.Println(numbers)
-	// Output:
-	// [1 2 3 4 5 6]
-}
-
-func ExampleShellSort() {
-	numbers := []int{2, 1, 5, 3, 6, 4}
-	comparator := &intComparator{}
-
-	ShellSort(numbers, comparator)
-
-	fmt.Println(numbers)
-	// Output:
-	// [1 2 3 4 5 6]
-}
-
-func ExampleQuickSort() {
-	numbers := []int{2, 1, 5, 3, 6, 4}
-	comparator := &intComparator{}
-
-	QuickSort(numbers, comparator)
-
-	fmt.Println(numbers)
-	// Output:
-	// [1 2 3 4 5 6]
-}

algorithm/sort_test.go

@@ -1,217 +0,0 @@
-package algorithm
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-// People test mock data
-type people struct {
-	Name string
-	Age  int
-}
-
-// PeopleAageComparator sort people slice by age field
-type peopleAgeComparator struct{}
-
-// Compare implements github.com/duke-git/lancet/v2/constraints/constraints.go/Comparator
-func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
-	p1, _ := v1.(people)
-	p2, _ := v2.(people)
-
-	//ascending order
-	if p1.Age < p2.Age {
-		return -1
-	} else if p1.Age > p2.Age {
-		return 1
-	}
-	return 0
-}
-
-type intComparator struct{}
-
-func (c *intComparator) Compare(v1 any, v2 any) int {
-	val1, _ := v1.(int)
-	val2, _ := v2.(int)
-
-	//ascending order
-	if val1 < val2 {
-		return -1
-	} else if val1 > val2 {
-		return 1
-	}
-	return 0
-}
-
-func TestBubbleSortForStructSlice(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestBubbleSortForStructSlice")
-
-	peoples := []people{
-		{Name: "a", Age: 20},
-		{Name: "b", Age: 10},
-		{Name: "c", Age: 17},
-		{Name: "d", Age: 8},
-		{Name: "e", Age: 28},
-	}
-	comparator := &peopleAgeComparator{}
-	BubbleSort(peoples, comparator)
-
-	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
-	actual := fmt.Sprintf("%v", peoples)
-
-	assert.Equal(expected, actual)
-}
-
-func TestBubbleSortForIntSlice(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestBubbleSortForIntSlice")
-
-	numbers := []int{2, 1, 5, 3, 6, 4}
-	comparator := &intComparator{}
-	BubbleSort(numbers, comparator)
-
-	assert.Equal([]int{1, 2, 3, 4, 5, 6}, numbers)
-}
-
-func TestInsertionSort(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestInsertionSort")
-
-	peoples := []people{
-		{Name: "a", Age: 20},
-		{Name: "b", Age: 10},
-		{Name: "c", Age: 17},
-		{Name: "d", Age: 8},
-		{Name: "e", Age: 28},
-	}
-	comparator := &peopleAgeComparator{}
-	InsertionSort(peoples, comparator)
-
-	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
-	actual := fmt.Sprintf("%v", peoples)
-
-	assert.Equal(expected, actual)
-}
-
-func TestSelectionSort(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestSelectionSort")
-
-	peoples := []people{
-		{Name: "a", Age: 20},
-		{Name: "b", Age: 10},
-		{Name: "c", Age: 17},
-		{Name: "d", Age: 8},
-		{Name: "e", Age: 28},
-	}
-	comparator := &peopleAgeComparator{}
-	SelectionSort(peoples, comparator)
-
-	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
-	actual := fmt.Sprintf("%v", peoples)
-
-	assert.Equal(expected, actual)
-}
-
-func TestShellSort(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestShellSort")
-
-	peoples := []people{
-		{Name: "a", Age: 20},
-		{Name: "b", Age: 10},
-		{Name: "c", Age: 17},
-		{Name: "d", Age: 8},
-		{Name: "e", Age: 28},
-	}
-	comparator := &peopleAgeComparator{}
-	ShellSort(peoples, comparator)
-
-	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
-	actual := fmt.Sprintf("%v", peoples)
-
-	assert.Equal(expected, actual)
-}
-
-func TestQuickSort(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestQuickSort")
-
-	peoples := []people{
-		{Name: "a", Age: 20},
-		{Name: "b", Age: 10},
-		{Name: "c", Age: 17},
-		{Name: "d", Age: 8},
-		{Name: "e", Age: 28},
-	}
-	comparator := &peopleAgeComparator{}
-	QuickSort(peoples, comparator)
-
-	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
-	actual := fmt.Sprintf("%v", peoples)
-
-	assert.Equal(expected, actual)
-}
-
-func TestHeapSort(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestHeapSort")
-
-	peoples := []people{
-		{Name: "a", Age: 20},
-		{Name: "b", Age: 10},
-		{Name: "c", Age: 17},
-		{Name: "d", Age: 8},
-		{Name: "e", Age: 28},
-	}
-	comparator := &peopleAgeComparator{}
-	HeapSort(peoples, comparator)
-
-	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
-	actual := fmt.Sprintf("%v", peoples)
-
-	assert.Equal(expected, actual)
-}
-
-func TestMergeSort(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestMergeSort")
-
-	peoples := []people{
-		{Name: "a", Age: 20},
-		{Name: "b", Age: 10},
-		{Name: "c", Age: 17},
-		{Name: "d", Age: 8},
-		{Name: "e", Age: 28},
-	}
-	comparator := &peopleAgeComparator{}
-	MergeSort(peoples, comparator)
-
-	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
-	actual := fmt.Sprintf("%v", peoples)
-
-	assert.Equal(expected, actual)
-}
-
-func TestCountSort(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestCountSort")
-
-	peoples := []people{
-		{Name: "a", Age: 20},
-		{Name: "b", Age: 10},
-		{Name: "c", Age: 17},
-		{Name: "d", Age: 8},
-		{Name: "e", Age: 28},
-	}
-	comparator := &peopleAgeComparator{}
-	sortedPeopleByAge := CountSort(peoples, comparator)
-
-	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
-	actual := fmt.Sprintf("%v", sortedPeopleByAge)
-
-	assert.Equal(expected, actual)
-}

compare/compare.go

@@ -1,7 +1,7 @@
 // Copyright 2023 dudaodong@gmail.com. All rights resulterved.
 // Use of this source code is governed by MIT license
 
-// Package compare provides a lightweight comparison function on any type.
+// Package compare provides a lightweight comparison function on interface{} type.
 // reference: https://github.com/stretchr/testify
 package compare
 
@@ -9,9 +9,7 @@ import (
 	"reflect"
 	"time"
 
-	"github.com/duke-git/lancet/v2/convertor"
-	"github.com/duke-git/lancet/v2/mathutil"
-	"golang.org/x/exp/constraints"
+	"github.com/duke-git/lancet/convertor"
 )
 
 // operator type
@@ -29,44 +27,32 @@ var (
 )
 
 // Equal checks if two values are equal or not. (check both type and value)
-// Play: https://go.dev/play/p/wmVxR-to4lz
-func Equal(left, right any) bool {
+func Equal(left, right interface{}) bool {
 	return compareValue(equal, left, right)
 }
 
 // EqualValue checks if two values are equal or not. (check value only)
-// Play: https://go.dev/play/p/fxnna_LLD9u
-func EqualValue(left, right any) bool {
+func EqualValue(left, right interface{}) bool {
 	ls, rs := convertor.ToString(left), convertor.ToString(right)
 	return ls == rs
 }
 
 // LessThan checks if value `left` less than value `right`.
-// Play: https://go.dev/play/p/cYh7FQQj0ne
-func LessThan(left, right any) bool {
+func LessThan(left, right interface{}) bool {
 	return compareValue(lessThan, left, right)
 }
 
 // GreaterThan checks if value `left` greater than value `right`.
-// Play: https://go.dev/play/p/9-NYDFZmIMp
-func GreaterThan(left, right any) bool {
+func GreaterThan(left, right interface{}) bool {
 	return compareValue(greaterThan, left, right)
 }
 
 // LessOrEqual checks if value `left` less than or equal to value `right`.
-// Play: https://go.dev/play/p/e4T_scwoQzp
-func LessOrEqual(left, right any) bool {
+func LessOrEqual(left, right interface{}) bool {
 	return compareValue(lessOrEqual, left, right)
 }
 
 // GreaterOrEqual checks if value `left` greater than or equal to value `right`.
-// Play: https://go.dev/play/p/vx8mP0U8DFk
-func GreaterOrEqual(left, right any) bool {
+func GreaterOrEqual(left, right interface{}) bool {
 	return compareValue(greaterOrEqual, left, right)
 }
-
-// InDelta checks if two values are equal or not within a delta.
-// Play: https://go.dev/play/p/TuDdcNtMkjo
-func InDelta[T constraints.Integer | constraints.Float](left, right T, delta float64) bool {
-	return float64(mathutil.Abs(left-right)) <= delta
-}

compare/compare_example_test.go

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

compare/compare_internal.go

@@ -3,14 +3,13 @@ package compare
 import (
 	"bytes"
 	"encoding/json"
-	"math/big"
 	"reflect"
 	"time"
 
-	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/duke-git/lancet/convertor"
 )
 
-func compareValue(operator string, left, right any) bool {
+func compareValue(operator string, left, right interface{}) bool {
 	leftType, rightType := reflect.TypeOf(left), reflect.TypeOf(right)
 
 	if leftType.Kind() != rightType.Kind() {
@@ -25,19 +24,12 @@ func compareValue(operator string, left, right any) bool {
 
 	case reflect.Struct, reflect.Slice, reflect.Map:
 		return compareRefValue(operator, left, right, leftType.Kind())
-
-	case reflect.Ptr:
-		if leftVal, ok := left.(*big.Int); ok {
-			if rightVal, ok := right.(*big.Int); ok {
-				return compareBigInt(operator, leftVal, rightVal)
-			}
-		}
 	}
 
 	return false
 }
 
-func compareRefValue(operator string, leftObj, rightObj any, kind reflect.Kind) bool {
+func compareRefValue(operator string, leftObj, rightObj interface{}, kind reflect.Kind) bool {
 	leftVal, rightVal := reflect.ValueOf(leftObj), reflect.ValueOf(rightObj)
 
 	switch kind {
@@ -78,7 +70,7 @@ func compareRefValue(operator string, leftObj, rightObj any, kind reflect.Kind)
 
 			switch operator {
 			case equal:
-				if bytes.Equal(bytesObj1, bytesObj2) {
+				if bytes.Compare(bytesObj1, bytesObj2) == 0 {
 					return true
 				}
 			case lessThan:
@@ -157,135 +149,175 @@ func objectsAreEqual(expected, actual interface{}) bool {
 }
 
 // compareBasic compare basic value: integer, float, string, bool
-func compareBasicValue(operator string, leftValue, rightValue any) bool {
+func compareBasicValue(operator string, leftValue, rightValue interface{}) bool {
 	if leftValue == nil && rightValue == nil && operator == equal {
 		return true
 	}
 
 	switch leftVal := leftValue.(type) {
-	case int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
-		left, err := convertor.ToBigInt(leftValue)
-		if err != nil {
-			return false
+	case json.Number:
+		if left, err := leftVal.Float64(); err == nil {
+			switch rightVal := rightValue.(type) {
+			case json.Number:
+				if right, err := rightVal.Float64(); err == nil {
+					switch operator {
+					case equal:
+						if left == right {
+							return true
+						}
+					case lessThan:
+						if left < right {
+							return true
+						}
+					case greaterThan:
+						if left > right {
+							return true
+						}
+					case lessOrEqual:
+						if left <= right {
+							return true
+						}
+					case greaterOrEqual:
+						if left >= right {
+							return true
+						}
+					}
+
+				}
+
+			case float32, float64, int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
+				right, err := convertor.ToFloat(rightValue)
+				if err != nil {
+					return false
+				}
+				switch operator {
+				case equal:
+					if left == right {
+						return true
+					}
+				case lessThan:
+					if left < right {
+						return true
+					}
+				case greaterThan:
+					if left > right {
+						return true
+					}
+				case lessOrEqual:
+					if left <= right {
+						return true
+					}
+				case greaterOrEqual:
+					if left >= right {
+						return true
+					}
+				}
+			}
+
 		}
 
-		right, err := convertor.ToBigInt(rightValue)
-		if err != nil {
-			return false
-		}
-
-		return compareBigInt(operator, left, right)
-
-	case float32, float64:
+	case float32, float64, int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
 		left, err := convertor.ToFloat(leftValue)
 		if err != nil {
 			return false
 		}
-		right, err := convertor.ToFloat(rightValue)
-		if err != nil {
-			return false
-		}
+		switch rightVal := rightValue.(type) {
+		case json.Number:
+			if right, err := rightVal.Float64(); err == nil {
+				switch operator {
+				case equal:
+					if left == right {
+						return true
+					}
+				case lessThan:
+					if left < right {
+						return true
+					}
+				case greaterThan:
+					if left > right {
+						return true
+					}
+				case lessOrEqual:
+					if left <= right {
+						return true
+					}
+				case greaterOrEqual:
+					if left >= right {
+						return true
+					}
+				}
+			}
+		case float32, float64, int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
+			right, err := convertor.ToFloat(rightValue)
+			if err != nil {
+				return false
+			}
 
-		return compareFloats(operator, left, right)
+			switch operator {
+			case equal:
+				if left == right {
+					return true
+				}
+			case lessThan:
+				if left < right {
+					return true
+				}
+			case greaterThan:
+				if left > right {
+					return true
+				}
+			case lessOrEqual:
+				if left <= right {
+					return true
+				}
+			case greaterOrEqual:
+				if left >= right {
+					return true
+				}
+			}
+		}
 
 	case string:
 		left := leftVal
 		switch right := rightValue.(type) {
 		case string:
-			return compareStrings(operator, left, right)
+			switch operator {
+			case equal:
+				if left == right {
+					return true
+				}
+			case lessThan:
+				if left < right {
+					return true
+				}
+			case greaterThan:
+				if left > right {
+					return true
+				}
+			case lessOrEqual:
+				if left <= right {
+					return true
+				}
+			case greaterOrEqual:
+				if left >= right {
+					return true
+				}
+			}
 		}
 
 	case bool:
 		left := leftVal
 		switch right := rightValue.(type) {
 		case bool:
-			return compareBools(operator, left, right)
-		}
-
-	case json.Number:
-		if left, err := leftVal.Float64(); err == nil {
-			switch rightVal := rightValue.(type) {
-			case json.Number:
-				if right, err := rightVal.Float64(); err == nil {
-					return compareFloats(operator, left, right)
+			switch operator {
+			case equal:
+				if left == right {
+					return true
 				}
-			case float32, float64:
-				right, err := convertor.ToFloat(rightValue)
-				if err != nil {
-					return false
-				}
-				return compareFloats(operator, left, right)
-
-			case int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
-				right, err := convertor.ToBigInt(rightValue)
-				if err != nil {
-					return false
-				}
-				left, err := convertor.ToBigInt(left)
-				return compareBigInt(operator, left, right)
 			}
 		}
+
 	}
 
 	return false
 }
-
-// compareBigInt compares two big.Int values based on the operator
-func compareBigInt(operator string, left, right *big.Int) bool {
-	switch operator {
-	case equal:
-		return left.Cmp(right) == 0
-	case lessThan:
-		return left.Cmp(right) < 0
-	case greaterThan:
-		return left.Cmp(right) > 0
-	case lessOrEqual:
-		return left.Cmp(right) <= 0
-	case greaterOrEqual:
-		return left.Cmp(right) >= 0
-	}
-	return false
-}
-
-// compareFloats compares two float64 values based on the operator
-func compareFloats(operator string, left, right float64) bool {
-	switch operator {
-	case equal:
-		return left == right
-	case lessThan:
-		return left < right
-	case greaterThan:
-		return left > right
-	case lessOrEqual:
-		return left <= right
-	case greaterOrEqual:
-		return left >= right
-	}
-	return false
-}
-
-// compareStrings compares two string values based on the operator
-func compareStrings(operator string, left, right string) bool {
-	switch operator {
-	case equal:
-		return left == right
-	case lessThan:
-		return left < right
-	case greaterThan:
-		return left > right
-	case lessOrEqual:
-		return left <= right
-	case greaterOrEqual:
-		return left >= right
-	}
-	return false
-}
-
-// compareBools compares two boolean values based on the operator
-func compareBools(operator string, left, right bool) bool {
-	switch operator {
-	case equal:
-		return left == right
-	}
-	return false
-}

compare/compare_test.go

@@ -1,203 +1,134 @@
 package compare
 
 import (
-	"encoding/json"
-	"math/big"
 	"testing"
 	"time"
 
-	"github.com/duke-git/lancet/v2/internal"
+	"github.com/duke-git/lancet/internal"
 )
 
 func TestEqual(t *testing.T) {
-	t.Parallel()
 	assert := internal.NewAssert(t, "TestEqual")
 
-	tests := []struct {
-		left  any
-		right any
-		want  bool
+	assert.Equal(true, Equal(1, 1))
+	assert.Equal(true, Equal(int64(1), int64(1)))
+	assert.Equal(true, Equal("a", "a"))
+	assert.Equal(true, Equal(true, true))
+	assert.Equal(true, Equal([]int{1, 2, 3}, []int{1, 2, 3}))
+	assert.Equal(true, Equal(map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "b"}))
+
+	assert.Equal(false, Equal(1, 2))
+	assert.Equal(false, Equal(1, int64(1)))
+	assert.Equal(false, Equal("a", "b"))
+	assert.Equal(false, Equal(true, false))
+	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"}))
+
+	time1 := time.Now()
+	time2 := time1.Add(time.Second)
+	time3 := time1.Add(time.Second)
+
+	assert.Equal(false, Equal(time1, time2))
+	assert.Equal(true, Equal(time2, time3))
+
+	st1 := struct {
+		A string
+		B string
 	}{
-		{1, 1, true},
-		{int64(1), int64(1), true},
-		{"a", "a", true},
-		{true, true, true},
-		{[]int{1, 2, 3}, []int{1, 2, 3}, true},
-		{map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "b"}, true},
-		{1, 2, false},
-		{1, int64(1), false},
-		{"a", "b", false},
-		{true, false, false},
-		{[]int{1, 2}, []int{1, 2, 3}, false},
-		{map[int]string{1: "a", 2: "b"}, map[int]string{1: "a"}, false},
-		// {time.Now(), time.Now(), true},
-		// {time.Now(), time.Now().Add(time.Second), false},
-		{[]byte("hello"), []byte("hello"), true},
-		{[]byte("hello"), []byte("world"), false},
-		{json.Number("123"), json.Number("123"), true},
-		{json.Number("123"), json.Number("124"), false},
-
-		{big.NewInt(123), big.NewInt(123), true},
+		A: "a",
+		B: "b",
 	}
 
-	for _, tt := range tests {
-		assert.Equal(tt.want, Equal(tt.left, tt.right))
+	st2 := struct {
+		A string
+		B string
+	}{
+		A: "a",
+		B: "b",
 	}
 
+	st3 := struct {
+		A string
+		B string
+	}{
+		A: "a1",
+		B: "b",
+	}
+
+	assert.Equal(true, Equal(st1, st2))
+	assert.Equal(false, Equal(st1, st3))
 }
 
 func TestEqualValue(t *testing.T) {
-	t.Parallel()
 	assert := internal.NewAssert(t, "TestEqualValue")
 
-	tests := []struct {
-		left  any
-		right any
-		want  bool
-	}{
-		{1, 1, true},
-		{int64(1), int64(1), true},
-		{"a", "a", true},
-		{true, true, true},
-		{[]int{1, 2, 3}, []int{1, 2, 3}, true},
-		{map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "b"}, true},
-		{1, 2, false},
-		{1, int64(1), true},
-		{"a", "b", false},
-		{true, false, false},
-		{[]int{1, 2}, []int{1, 2, 3}, false},
-	}
+	assert.Equal(true, EqualValue(1, 1))
+	assert.Equal(true, EqualValue(int(1), int64(1)))
+	assert.Equal(true, EqualValue(1, "1"))
 
-	for _, tt := range tests {
-		assert.Equal(tt.want, EqualValue(tt.left, tt.right))
-	}
+	assert.Equal(false, EqualValue(1, "2"))
 }
 
 func TestLessThan(t *testing.T) {
-	t.Parallel()
 	assert := internal.NewAssert(t, "TestLessThan")
 
-	tests := []struct {
-		left  any
-		right any
-		want  bool
-	}{
-		{1, 2, true},
-		{1.1, 2.2, true},
-		{"a", "b", true},
-		{time.Now(), time.Now().Add(time.Second), true},
-		{[]byte("hello1"), []byte("hello2"), true},
-		{json.Number("123"), json.Number("124"), true},
-		{645680099112988673, 645680099112988675, true},
-		{1, 1, false},
-		{1, int64(1), false},
-	}
+	assert.Equal(true, LessThan(1, 2))
+	assert.Equal(true, LessThan(1.1, 2.2))
+	assert.Equal(true, LessThan("a", "b"))
 
-	for _, tt := range tests {
-		assert.Equal(tt.want, LessThan(tt.left, tt.right))
-	}
+	time1 := time.Now()
+	time2 := time1.Add(time.Second)
+	assert.Equal(true, LessThan(time1, time2))
+
+	assert.Equal(false, LessThan(1, 1))
+	assert.Equal(false, LessThan(1, int64(1)))
 }
 
 func TestGreaterThan(t *testing.T) {
-	t.Parallel()
 	assert := internal.NewAssert(t, "TestGreaterThan")
 
-	tests := []struct {
-		left  any
-		right any
-		want  bool
-	}{
-		{2, 1, true},
-		{2.2, 1.1, true},
-		{"b", "a", true},
-		{time.Now().Add(time.Second), time.Now(), true},
-		{[]byte("hello2"), []byte("hello1"), true},
-		{json.Number("124"), json.Number("123"), true},
-		{645680099112988675, 645680099112988673, true},
-		{1, 1, false},
-		{1, int64(1), false},
-	}
+	assert.Equal(true, GreaterThan(2, 1))
+	assert.Equal(true, GreaterThan(2.2, 1.1))
+	assert.Equal(true, GreaterThan("b", "a"))
 
-	for _, tt := range tests {
-		assert.Equal(tt.want, GreaterThan(tt.left, tt.right))
-	}
+	time1 := time.Now()
+	time2 := time1.Add(time.Second)
+	assert.Equal(true, GreaterThan(time2, time1))
 
+	assert.Equal(false, GreaterThan(1, 2))
+	assert.Equal(false, GreaterThan(int64(2), 1))
+	assert.Equal(false, GreaterThan("b", "c"))
 }
 
 func TestLessOrEqual(t *testing.T) {
-	t.Parallel()
 	assert := internal.NewAssert(t, "TestLessOrEqual")
 
-	tests := []struct {
-		left  any
-		right any
-		want  bool
-	}{
-		{1, 2, true},
-		{1, 1, true},
-		{1.1, 2.2, true},
-		{"a", "b", true},
-		{time.Now(), time.Now().Add(time.Second), true},
-		{[]byte("hello1"), []byte("hello2"), true},
-		{json.Number("123"), json.Number("124"), true},
-		{645680099112988673, 645680099112988675, true},
-		{2, 1, false},
-		{1, int64(2), false},
-	}
+	assert.Equal(true, LessOrEqual(1, 2))
+	assert.Equal(true, LessOrEqual(1, 1))
+	assert.Equal(true, LessOrEqual(1.1, 2.2))
+	assert.Equal(true, LessOrEqual("a", "b"))
 
-	for _, tt := range tests {
-		assert.Equal(tt.want, LessOrEqual(tt.left, tt.right))
-	}
+	time1 := time.Now()
+	time2 := time1.Add(time.Second)
+	assert.Equal(true, LessOrEqual(time1, time2))
+
+	assert.Equal(false, LessOrEqual(2, 1))
+	assert.Equal(false, LessOrEqual(1, int64(2)))
 }
 
 func TestGreaterOrEqual(t *testing.T) {
-	t.Parallel()
 	assert := internal.NewAssert(t, "TestGreaterThan")
 
-	tests := []struct {
-		left  any
-		right any
-		want  bool
-	}{
-		{2, 1, true},
-		{1, 1, true},
-		{2.2, 1.1, true},
-		{"b", "b", true},
-		{time.Now().Add(time.Second), time.Now(), true},
-		{[]byte("hello2"), []byte("hello1"), true},
-		{json.Number("124"), json.Number("123"), true},
-		{645680099112988675, 645680099112988673, true},
-		{1, 2, false},
-		{int64(2), 1, false},
-		{"b", "c", false},
-	}
+	assert.Equal(true, GreaterOrEqual(2, 1))
+	assert.Equal(true, GreaterOrEqual(1, 1))
+	assert.Equal(true, GreaterOrEqual(2.2, 1.1))
+	assert.Equal(true, GreaterOrEqual("b", "b"))
 
-	for _, tt := range tests {
-		assert.Equal(tt.want, GreaterOrEqual(tt.left, tt.right))
-	}
-}
-
-func TestInDelta(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestInDelta")
-
-	tests := []struct {
-		left  float64
-		right float64
-		delta float64
-		want  bool
-	}{
-		{1, 1, 0, true},
-		{1, 2, 0, false},
-		{2.0 / 3.0, 0.66667, 0.001, true},
-		{2.0 / 3.0, 0.0, 0.001, false},
-		{float64(74.96) - float64(20.48), 54.48, 0, false},
-		{float64(74.96) - float64(20.48), 54.48, 1e-14, true},
-		{float64(float32(80.45)), float64(80.45), 0, false},
-		{float64(float32(80.45)), float64(80.45), 1e-5, true},
-	}
-
-	for _, tt := range tests {
-		assert.Equal(tt.want, InDelta(tt.left, tt.right, tt.delta))
-	}
+	time1 := time.Now()
+	time2 := time1.Add(time.Second)
+	assert.Equal(true, GreaterOrEqual(time2, time1))
+
+	assert.Equal(false, GreaterOrEqual(1, 2))
+	assert.Equal(false, GreaterOrEqual(int64(2), 1))
+	assert.Equal(false, GreaterOrEqual("b", "c"))
 }

concurrency/channel.go

@@ -1,250 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package concurrency contain some functions to support concurrent programming. eg, goroutine, channel.
-package concurrency
-
-import (
-	"context"
-	"sync"
-)
-
-// Channel is a logic object which can generate or manipulate go channel
-// all methods of Channel are in the book tilted《Concurrency in Go》
-type Channel[T any] struct {
-}
-
-// NewChannel return a Channel instance
-func NewChannel[T any]() *Channel[T] {
-	return &Channel[T]{}
-}
-
-// Generate creates channel, then put values into the channel.
-// Play: https://go.dev/play/p/7aB4KyMMp9A
-func (c *Channel[T]) Generate(ctx context.Context, values ...T) <-chan T {
-	dataStream := make(chan T)
-
-	go func() {
-		defer close(dataStream)
-
-		for _, v := range values {
-			select {
-			case <-ctx.Done():
-				return
-			case dataStream <- v:
-			}
-		}
-	}()
-
-	return dataStream
-}
-
-// Repeat create channel, put values into the channel repeatly until cancel the context.
-// Play: https://go.dev/play/p/k5N_ALVmYjE
-func (c *Channel[T]) Repeat(ctx context.Context, values ...T) <-chan T {
-	dataStream := make(chan T)
-
-	go func() {
-		defer close(dataStream)
-		for {
-			for _, v := range values {
-				select {
-				case <-ctx.Done():
-					return
-				case dataStream <- v:
-				}
-			}
-		}
-	}()
-	return dataStream
-}
-
-// RepeatFn create a channel, excutes fn repeatly, and put the result into the channel
-// until close context.
-// Play: https://go.dev/play/p/4J1zAWttP85
-func (c *Channel[T]) RepeatFn(ctx context.Context, fn func() T) <-chan T {
-	dataStream := make(chan T)
-
-	go func() {
-		defer close(dataStream)
-		for {
-			select {
-			case <-ctx.Done():
-				return
-			case dataStream <- fn():
-			}
-		}
-	}()
-	return dataStream
-}
-
-// Take create a channel whose values are taken from another channel with limit number.
-// Play: https://go.dev/play/p/9Utt-1pDr2J
-func (c *Channel[T]) Take(ctx context.Context, valueStream <-chan T, number int) <-chan T {
-	takeStream := make(chan T)
-
-	go func() {
-		defer close(takeStream)
-
-		for i := 0; i < number; i++ {
-			select {
-			case <-ctx.Done():
-				return
-			case takeStream <- <-valueStream:
-			}
-		}
-	}()
-
-	return takeStream
-}
-
-// FanIn merge multiple channels into one channel.
-// Play: https://go.dev/play/p/2VYFMexEvTm
-func (c *Channel[T]) FanIn(ctx context.Context, channels ...<-chan T) <-chan T {
-	out := make(chan T)
-
-	go func() {
-		var wg sync.WaitGroup
-		wg.Add(len(channels))
-
-		for _, c := range channels {
-			go func(c <-chan T) {
-				defer wg.Done()
-				for v := range c {
-					select {
-					case <-ctx.Done():
-						return
-					case out <- v:
-					}
-				}
-			}(c)
-		}
-		wg.Wait()
-		close(out)
-	}()
-
-	return out
-}
-
-// Tee split one chanel into two channels, until cancel the context.
-// Play: https://go.dev/play/p/3TQPKnCirrP
-func (c *Channel[T]) Tee(ctx context.Context, in <-chan T) (<-chan T, <-chan T) {
-	out1 := make(chan T)
-	out2 := make(chan T)
-
-	go func() {
-		defer close(out1)
-		defer close(out2)
-
-		for val := range c.OrDone(ctx, in) {
-			var out1, out2 = out1, out2
-			for i := 0; i < 2; i++ {
-				select {
-				case <-ctx.Done():
-				case out1 <- val:
-					out1 = nil
-				case out2 <- val:
-					out2 = nil
-				}
-			}
-		}
-	}()
-
-	return out1, out2
-}
-
-// Bridge link multiply channels into one channel.
-// Play: https://go.dev/play/p/qmWSy1NVF-Y
-func (c *Channel[T]) Bridge(ctx context.Context, chanStream <-chan <-chan T) <-chan T {
-	valStream := make(chan T)
-	go func() {
-		defer close(valStream)
-		wg := sync.WaitGroup{}
-		defer wg.Wait()
-		for {
-			var stream <-chan T
-			select {
-			case maybeStream, ok := <-chanStream:
-				if !ok {
-					return
-				}
-				stream = maybeStream
-				wg.Add(1)
-			case <-ctx.Done():
-				return
-			}
-
-			go func() {
-				defer wg.Done()
-				for val := range c.OrDone(ctx, stream) {
-					select {
-					case valStream <- val:
-					case <-ctx.Done():
-					}
-				}
-			}()
-		}
-	}()
-	return valStream
-}
-
-// Or read one or more channels into one channel, will close when any readin channel is closed.
-// Play: https://go.dev/play/p/Wqz9rwioPww
-func (c *Channel[T]) Or(channels ...<-chan T) <-chan T {
-	switch len(channels) {
-	case 0:
-		return nil
-	case 1:
-		return channels[0]
-	}
-
-	orDone := make(chan T)
-
-	go func() {
-		defer close(orDone)
-
-		switch len(channels) {
-		case 2:
-			select {
-			case <-channels[0]:
-			case <-channels[1]:
-			}
-		default:
-			select {
-			case <-channels[0]:
-			case <-channels[1]:
-			case <-channels[2]:
-			case <-c.Or(append(channels[3:], orDone)...):
-			}
-		}
-	}()
-
-	return orDone
-}
-
-// OrDone read a channel into another channel, will close until cancel context.
-// Play: https://go.dev/play/p/lm_GoS6aDjo
-func (c *Channel[T]) OrDone(ctx context.Context, channel <-chan T) <-chan T {
-	valStream := make(chan T)
-
-	go func() {
-		defer close(valStream)
-		for {
-			select {
-			case <-ctx.Done():
-				return
-			case v, ok := <-channel:
-				if !ok {
-					return
-				}
-				select {
-				case valStream <- v:
-				case <-ctx.Done():
-				}
-			}
-		}
-
-	}()
-
-	return valStream
-}

concurrency/channel_example_test.go

@@ -1,358 +0,0 @@
-package concurrency
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"time"
-)
-
-func ExampleChannel_Generate() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	c := NewChannel[int]()
-	intStream := c.Generate(ctx, 1, 2, 3)
-
-	fmt.Println(<-intStream)
-	fmt.Println(<-intStream)
-	fmt.Println(<-intStream)
-
-	// Output:
-	// 1
-	// 2
-	// 3
-}
-
-func ExampleChannel_Repeat() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	c := NewChannel[int]()
-	intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 4)
-
-	for v := range intStream {
-		fmt.Println(v)
-	}
-	// Output:
-	// 1
-	// 2
-	// 1
-	// 2
-}
-
-func ExampleChannel_RepeatFn() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	fn := func() string {
-		return "hello"
-	}
-
-	c := NewChannel[string]()
-	intStream := c.Take(ctx, c.RepeatFn(ctx, fn), 3)
-
-	for v := range intStream {
-		fmt.Println(v)
-	}
-	// Output:
-	// hello
-	// hello
-	// hello
-}
-
-func ExampleChannel_Take() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	numbers := make(chan int, 5)
-	numbers <- 1
-	numbers <- 2
-	numbers <- 3
-	numbers <- 4
-	numbers <- 5
-	defer close(numbers)
-
-	c := NewChannel[int]()
-	intStream := c.Take(ctx, numbers, 3)
-
-	for v := range intStream {
-		fmt.Println(v)
-	}
-	// Output:
-	// 1
-	// 2
-	// 3
-}
-
-func ExampleChannel_FanIn() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	c := NewChannel[int]()
-	channels := make([]<-chan int, 2)
-
-	for i := 0; i < 2; i++ {
-		channels[i] = c.Take(ctx, c.Repeat(ctx, i), 2)
-	}
-
-	chs := c.FanIn(ctx, channels...)
-
-	for v := range chs {
-		fmt.Println(v) //1 1 0 0 or 0 0 1 1
-	}
-
-}
-
-func ExampleChannel_Or() {
-	sig := func(after time.Duration) <-chan any {
-		c := make(chan any)
-		go func() {
-			defer close(c)
-			time.Sleep(after)
-		}()
-		return c
-	}
-
-	start := time.Now()
-
-	c := NewChannel[any]()
-	<-c.Or(
-		sig(1*time.Second),
-		sig(2*time.Second),
-		sig(3*time.Second),
-	)
-
-	if time.Since(start).Seconds() < 2 {
-		fmt.Println("ok")
-	}
-	// Output:
-	// ok
-}
-
-func ExampleChannel_OrDone() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	c := NewChannel[int]()
-	intStream := c.Take(ctx, c.Repeat(ctx, 1), 3)
-
-	for v := range c.OrDone(ctx, intStream) {
-		fmt.Println(v)
-	}
-	// Output:
-	// 1
-	// 1
-	// 1
-}
-
-func ExampleChannel_Tee() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	c := NewChannel[int]()
-	intStream := c.Take(ctx, c.Repeat(ctx, 1), 2)
-
-	ch1, ch2 := c.Tee(ctx, intStream)
-
-	for v := range ch1 {
-		fmt.Println(v)
-		fmt.Println(<-ch2)
-	}
-	// Output:
-	// 1
-	// 1
-	// 1
-	// 1
-}
-
-func ExampleChannel_Bridge() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	m1 := make(map[int]int)
-	m2 := make(map[int]int)
-	c := NewChannel[int]()
-	genVals := func() <-chan <-chan int {
-		out := make(chan (<-chan int))
-		go func() {
-			defer close(out)
-			for i := 1; i <= 5; i++ {
-				stream := make(chan int, 1)
-				stream <- i
-				m1[i]++
-				close(stream)
-				out <- stream
-			}
-		}()
-		return out
-	}
-
-	for v := range c.Bridge(ctx, genVals()) {
-		m2[v]++
-	}
-	for k, v := range m1 {
-		fmt.Println(m2[k] == v)
-	}
-	// Output:
-	// true
-	// true
-	// true
-	// true
-	// true
-}
-
-func ExampleKeyedLocker_Do() {
-	locker := NewKeyedLocker[string](2 * time.Second)
-
-	task := func() {
-		fmt.Println("Executing task...")
-		time.Sleep(1 * time.Second)
-		fmt.Println("Task completed.")
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
-	defer cancel()
-
-	if err := locker.Do(ctx, "mykey", task); err != nil {
-		log.Fatalf("Error executing task: %v\n", err)
-	} else {
-		fmt.Println("Task successfully executed.")
-	}
-
-	ctx2, cancel2 := context.WithTimeout(context.Background(), 3*time.Second)
-	defer cancel2()
-
-	if err := locker.Do(ctx2, "mykey", task); err != nil {
-		log.Fatalf("Error executing task: %v\n", err)
-	} else {
-		fmt.Println("Task successfully executed.")
-	}
-
-	// Output:
-	// Executing task...
-	// Task completed.
-	// Task successfully executed.
-	// Executing task...
-	// Task completed.
-	// Task successfully executed.
-}
-
-func ExampleRWKeyedLocker_Lock() {
-	locker := NewRWKeyedLocker[string](2 * time.Second)
-
-	// Simulate a key
-	key := "resource_key"
-
-	fn := func() {
-		fmt.Println("Starting write operation...")
-		// Simulate write operation, assuming it takes 2 seconds
-		time.Sleep(200 * time.Millisecond)
-		fmt.Println("Write operation completed!")
-	}
-
-	// Acquire the write lock and execute the operation
-	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-	defer cancel()
-
-	// Execute the lock operation with a 3-second timeout
-	err := locker.Lock(ctx, key, fn)
-	if err != nil {
-		return
-	}
-
-	//output:
-	//Starting write operation...
-	//Write operation completed!
-}
-
-func ExampleRWKeyedLocker_RLock() {
-	locker := NewRWKeyedLocker[string](2 * time.Second)
-
-	// Simulate a key
-	key := "resource_key"
-
-	fn := func() {
-		fmt.Println("Starting write operation...")
-		// Simulate write operation, assuming it takes 2 seconds
-		time.Sleep(200 * time.Millisecond)
-		fmt.Println("Write operation completed!")
-	}
-
-	// Acquire the write lock and execute the operation
-	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-	defer cancel()
-
-	// Execute the lock operation with a 3-second timeout
-	err := locker.RLock(ctx, key, fn)
-	if err != nil {
-		return
-	}
-
-	//output:
-	//Starting write operation...
-	//Write operation completed!
-}
-
-func ExampleTryKeyedLocker() {
-	locker := NewTryKeyedLocker[string]()
-
-	key := "resource_key"
-
-	if locker.TryLock(key) {
-		fmt.Println("Lock acquired")
-		time.Sleep(1 * time.Second)
-		// Unlock after work is done
-		locker.Unlock(key)
-		fmt.Println("Lock released")
-	} else {
-		fmt.Println("Lock failed")
-	}
-
-	//output:
-	//Lock acquired
-	//Lock released
-}
-
-func ExampleTryKeyedLocker_TryLock() {
-	locker := NewTryKeyedLocker[string]()
-
-	key := "resource_key"
-
-	done := make(chan struct{})
-	go func() {
-		if locker.TryLock(key) {
-			time.Sleep(2 * time.Second)
-			locker.Unlock(key)
-		}
-		close(done)
-	}()
-
-	time.Sleep(100 * time.Millisecond)
-
-	if locker.TryLock(key) {
-		fmt.Println("Lock acquired")
-		locker.Unlock(key)
-	} else {
-		fmt.Println("Lock failed")
-	}
-
-	// wait for the goroutine to finish
-	<-done
-
-	fmt.Println("Retrying...")
-	time.Sleep(100 * time.Millisecond)
-
-	if locker.TryLock(key) {
-		fmt.Println("Lock acquired")
-		locker.Unlock(key)
-		fmt.Println("Lock released")
-	} else {
-		fmt.Println("Lock failed")
-	}
-
-	// Output:
-	// Lock failed
-	// Retrying...
-	// Lock acquired
-	// Lock released
-}

concurrency/channel_test.go

@@ -1,200 +0,0 @@
-package concurrency
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestGenerate(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestGenerate")
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	c := NewChannel[int]()
-	intStream := c.Generate(ctx, 1, 2, 3)
-
-	assert.Equal(1, <-intStream)
-	assert.Equal(2, <-intStream)
-	assert.Equal(3, <-intStream)
-}
-
-func TestRepeat(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestRepeat")
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	c := NewChannel[int]()
-	intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 5)
-
-	assert.Equal(1, <-intStream)
-	assert.Equal(2, <-intStream)
-	assert.Equal(1, <-intStream)
-	assert.Equal(2, <-intStream)
-	assert.Equal(1, <-intStream)
-}
-
-func TestRepeatFn(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestRepeatFn")
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	fn := func() string {
-		s := "a"
-		return s
-	}
-	c := NewChannel[string]()
-	dataStream := c.Take(ctx, c.RepeatFn(ctx, fn), 3)
-
-	assert.Equal("a", <-dataStream)
-	assert.Equal("a", <-dataStream)
-	assert.Equal("a", <-dataStream)
-}
-
-func TestTake(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestTake")
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	numbers := make(chan int, 5)
-	numbers <- 1
-	numbers <- 2
-	numbers <- 3
-	numbers <- 4
-	numbers <- 5
-	defer close(numbers)
-
-	c := NewChannel[int]()
-	intStream := c.Take(ctx, numbers, 3)
-
-	assert.Equal(1, <-intStream)
-	assert.Equal(2, <-intStream)
-	assert.Equal(3, <-intStream)
-}
-
-func TestFanIn(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestFanIn")
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	c := NewChannel[int]()
-	channels := make([]<-chan int, 3)
-
-	for i := 0; i < 3; i++ {
-		channels[i] = c.Take(ctx, c.Repeat(ctx, i), 3)
-	}
-
-	mergedChannel := c.FanIn(ctx, channels...)
-
-	for val := range mergedChannel {
-		t.Logf("\t%d\n", val)
-	}
-
-	assert.Equal(1, 1)
-}
-
-func TestOr(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestOr")
-
-	sig := func(after time.Duration) <-chan any {
-		c := make(chan interface{})
-		go func() {
-			defer close(c)
-			time.Sleep(after)
-		}()
-		return c
-	}
-
-	start := time.Now()
-
-	c := NewChannel[any]()
-	<-c.Or(
-		sig(1*time.Second),
-		sig(2*time.Second),
-		sig(3*time.Second),
-		sig(4*time.Second),
-		sig(5*time.Second),
-	)
-
-	assert.Equal(true, time.Since(start).Seconds() < 2)
-}
-
-func TestOrDone(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestOrDone")
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	c := NewChannel[int]()
-	intStream := c.Take(ctx, c.Repeat(ctx, 1), 3)
-
-	for val := range c.OrDone(ctx, intStream) {
-		assert.Equal(1, val)
-	}
-}
-
-func TestTee(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestTee")
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	c := NewChannel[int]()
-	inStream := c.Take(ctx, c.Repeat(ctx, 1), 4)
-
-	out1, out2 := c.Tee(ctx, inStream)
-	for val := range out1 {
-		val1 := val
-		val2 := <-out2
-		assert.Equal(1, val1)
-		assert.Equal(1, val2)
-	}
-}
-
-func TestBridge(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestBridge")
-	m1 := make(map[int]int)
-	m2 := make(map[int]int)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	c := NewChannel[int]()
-	genVals := func() <-chan <-chan int {
-		chanStream := make(chan (<-chan int))
-		go func() {
-			defer close(chanStream)
-			for i := 0; i < 10; i++ {
-				stream := make(chan int, 1)
-				stream <- i
-				m1[i]++
-				close(stream)
-				chanStream <- stream
-			}
-		}()
-		return chanStream
-	}
-
-	for val := range c.Bridge(ctx, genVals()) {
-		m2[val]++
-	}
-
-	for k, v := range m1 {
-		assert.Equal(m2[k], v)
-	}
-}

concurrency/keyed_locker.go

@@ -1,257 +0,0 @@
-// Copyright 2025 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package concurrency contain some functions to support concurrent programming. eg, goroutine, channel, locker.
-package concurrency
-
-import (
-	"context"
-	"sync"
-	"sync/atomic"
-	"time"
-)
-
-// KeyedLocker is a simple implementation of a keyed locker that allows for non-blocking lock acquisition.
-type KeyedLocker[K comparable] struct {
-	locks sync.Map
-	ttl   time.Duration
-}
-
-type lockEntry struct {
-	mu    sync.Mutex
-	ref   int32
-	timer atomic.Pointer[time.Timer]
-}
-
-// NewKeyedLocker creates a new KeyedLocker with the specified TTL for lock expiration.
-// The TTL is used to automatically release locks that are no longer held.
-// Play: https://go.dev/play/p/GzeyC33T5rw
-func NewKeyedLocker[K comparable](ttl time.Duration) *KeyedLocker[K] {
-	return &KeyedLocker[K]{ttl: ttl}
-}
-
-// Do acquires a lock for the specified key and executes the provided function.
-// It returns an error if the context is canceled before the function completes.
-// Play: https://go.dev/play/p/GzeyC33T5rw
-func (l *KeyedLocker[K]) Do(ctx context.Context, key K, fn func()) error {
-	entry := l.acquire(key)
-	defer l.release(key, entry, key)
-
-	done := make(chan struct{})
-
-	go func() {
-		entry.mu.Lock()
-		defer entry.mu.Unlock()
-
-		select {
-		case <-ctx.Done():
-		default:
-			fn()
-		}
-		close(done)
-	}()
-
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	case <-done:
-		return nil
-	}
-}
-
-// acquire tries to acquire a lock for the specified key.
-func (l *KeyedLocker[K]) acquire(key K) *lockEntry {
-	lock, _ := l.locks.LoadOrStore(key, &lockEntry{})
-	entry := lock.(*lockEntry)
-
-	atomic.AddInt32(&entry.ref, 1)
-	if t := entry.timer.Swap(nil); t != nil {
-		t.Stop()
-	}
-
-	return entry
-}
-
-// release releases the lock for the specified key.
-func (l *KeyedLocker[K]) release(key K, entry *lockEntry, rawKey K) {
-	if atomic.AddInt32(&entry.ref, -1) == 0 {
-		entry.mu.Lock()
-		defer entry.mu.Unlock()
-
-		if entry.ref == 0 {
-			if t := entry.timer.Swap(nil); t != nil {
-				t.Stop()
-			}
-
-			l.locks.Delete(rawKey)
-		} else {
-			if entry.timer.Load() == nil {
-				t := time.AfterFunc(l.ttl, func() {
-					l.release(key, entry, rawKey)
-				})
-				entry.timer.Store(t)
-			}
-		}
-	}
-}
-
-// RWKeyedLocker is a read-write version of KeyedLocker.
-type RWKeyedLocker[K comparable] struct {
-	locks sync.Map
-	ttl   time.Duration
-}
-
-type rwLockEntry struct {
-	mu    sync.RWMutex
-	ref   int32
-	timer atomic.Pointer[time.Timer]
-}
-
-// NewRWKeyedLocker creates a new RWKeyedLocker with the specified TTL for lock expiration.
-// The TTL is used to automatically release locks that are no longer held.
-// Play: https://go.dev/play/p/CkaJWWwZm9
-func NewRWKeyedLocker[K comparable](ttl time.Duration) *RWKeyedLocker[K] {
-	return &RWKeyedLocker[K]{ttl: ttl}
-}
-
-// RLock acquires a read lock for the specified key and executes the provided function.
-// It returns an error if the context is canceled before the function completes.
-// Play: https://go.dev/play/p/ZrCr8sMo77T
-func (l *RWKeyedLocker[K]) RLock(ctx context.Context, key K, fn func()) error {
-	entry := l.acquire(key)
-	defer l.release(entry, key)
-
-	done := make(chan struct{})
-
-	go func() {
-		entry.mu.RLock()
-		defer entry.mu.RUnlock()
-
-		select {
-		case <-ctx.Done():
-		default:
-			fn()
-		}
-		close(done)
-	}()
-
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	case <-done:
-		return nil
-	}
-}
-
-// Lock acquires a write lock for the specified key and executes the provided function.
-// It returns an error if the context is canceled before the function completes.
-// Play: https://go.dev/play/p/WgAcXbOPKGk
-func (l *RWKeyedLocker[K]) Lock(ctx context.Context, key K, fn func()) error {
-	entry := l.acquire(key)
-	defer l.release(entry, key)
-
-	done := make(chan struct{})
-
-	go func() {
-		entry.mu.Lock()
-		defer entry.mu.Unlock()
-
-		select {
-		case <-ctx.Done():
-		default:
-			fn()
-		}
-		close(done)
-	}()
-
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	case <-done:
-		return nil
-	}
-}
-
-// acquire tries to acquire a read lock for the specified key.
-func (l *RWKeyedLocker[K]) acquire(key K) *rwLockEntry {
-	actual, _ := l.locks.LoadOrStore(key, &rwLockEntry{})
-	entry := actual.(*rwLockEntry)
-	atomic.AddInt32(&entry.ref, 1)
-
-	if t := entry.timer.Swap(nil); t != nil {
-		t.Stop()
-	}
-	return entry
-}
-
-// release releases the lock for the specified key.
-func (l *RWKeyedLocker[K]) release(entry *rwLockEntry, rawKey K) {
-	if atomic.AddInt32(&entry.ref, -1) == 0 {
-		timer := time.AfterFunc(l.ttl, func() {
-			if atomic.LoadInt32(&entry.ref) == 0 {
-				l.locks.Delete(rawKey)
-			}
-		})
-		entry.timer.Store(timer)
-	}
-}
-
-// TryKeyedLocker is a non-blocking version of KeyedLocker.
-// It allows for trying to acquire a lock without blocking if the lock is already held.
-type TryKeyedLocker[K comparable] struct {
-	mu    sync.Mutex
-	locks map[K]*casMutex
-}
-
-// NewTryKeyedLocker creates a new TryKeyedLocker.
-// Play: https://go.dev/play/p/VG9qLvyetE2
-func NewTryKeyedLocker[K comparable]() *TryKeyedLocker[K] {
-	return &TryKeyedLocker[K]{locks: make(map[K]*casMutex)}
-}
-
-// TryLock tries to acquire a lock for the specified key.
-// It returns true if the lock was acquired, false otherwise.
-// Play: https://go.dev/play/p/VG9qLvyetE2
-func (l *TryKeyedLocker[K]) TryLock(key K) bool {
-	l.mu.Lock()
-
-	lock, ok := l.locks[key]
-	if !ok {
-		lock = &casMutex{}
-		l.locks[key] = lock
-	}
-	l.mu.Unlock()
-
-	return lock.TryLock()
-}
-
-// Unlock releases the lock for the specified key.
-// Play: https://go.dev/play/p/VG9qLvyetE2
-func (l *TryKeyedLocker[K]) Unlock(key K) {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-
-	lock, ok := l.locks[key]
-	if ok {
-		lock.Unlock()
-		if lock.lock == 0 {
-			delete(l.locks, key)
-		}
-	}
-}
-
-// casMutex is a simple mutex that uses atomic operations to provide a non-blocking lock.
-type casMutex struct {
-	lock int32
-}
-
-// TryLock tries to acquire the lock without blocking.
-// It returns true if the lock was acquired, false otherwise.
-func (m *casMutex) TryLock() bool {
-	return atomic.CompareAndSwapInt32(&m.lock, 0, 1)
-}
-
-// Unlock releases the lock.
-func (m *casMutex) Unlock() {
-	atomic.StoreInt32(&m.lock, 0)
-}

concurrency/keyed_locker_test.go

@@ -1,230 +0,0 @@
-package concurrency
-
-import (
-	"context"
-	"strconv"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestKeyedLocker_SerialExecutionSameKey(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestKeyedLocker_SerialExecutionSameKey")
-
-	locker := NewKeyedLocker[string](100 * time.Millisecond)
-
-	var result []int
-	var mu sync.Mutex
-
-	wg := sync.WaitGroup{}
-	for i := 0; i < 5; i++ {
-		wg.Add(1)
-		go func(i int) {
-			defer wg.Done()
-			err := locker.Do(context.Background(), "key1", func() {
-				time.Sleep(10 * time.Millisecond)
-				mu.Lock()
-				defer mu.Unlock()
-				result = append(result, i)
-			})
-
-			assert.IsNil(err)
-		}(i)
-	}
-	wg.Wait()
-
-	assert.Equal(5, len(result))
-}
-
-func TestKeyedLocker_ParallelExecutionDifferentKeys(t *testing.T) {
-	locker := NewKeyedLocker[string](100 * time.Millisecond)
-
-	start := time.Now()
-	wg := sync.WaitGroup{}
-	for i := 0; i < 5; i++ {
-		wg.Add(1)
-		go func(i int) {
-			defer wg.Done()
-			key := "key" + strconv.Itoa(i)
-			locker.Do(context.Background(), key, func() {
-				time.Sleep(50 * time.Millisecond)
-			})
-		}(i)
-	}
-	wg.Wait()
-	elapsed := time.Since(start)
-
-	if elapsed > 100*time.Millisecond {
-		t.Errorf("parallel execution took too long: %s", elapsed)
-	}
-}
-
-func TestKeyedLocker_ContextTimeout(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestKeyedLocker_ContextTimeout")
-
-	locker := NewKeyedLocker[string](100 * time.Millisecond)
-
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
-	defer cancel()
-
-	// Lock key before calling
-	go func() {
-		_ = locker.Do(context.Background(), "key-timeout", func() {
-			time.Sleep(50 * time.Millisecond)
-		})
-	}()
-
-	time.Sleep(1 * time.Millisecond) // ensure lock is acquired first
-
-	err := locker.Do(ctx, "key-timeout", func() {
-		t.Error("should not execute")
-	})
-
-	assert.IsNotNil(err)
-}
-
-func TestKeyedLocker_LockReleaseAfterTTL(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestKeyedLocker_LockReleaseAfterTTL")
-
-	locker := NewKeyedLocker[string](50 * time.Millisecond)
-
-	err := locker.Do(context.Background(), "ttl-key", func() {})
-	if err != nil {
-		t.Errorf("unexpected error: %v", err)
-	}
-
-	// Wait for TTL to pass
-	time.Sleep(100 * time.Millisecond)
-
-	err = locker.Do(context.Background(), "ttl-key", func() {})
-	assert.IsNil(err)
-}
-
-func TestRWKeyedLocker_LockAndUnlock(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestKeyedLocker_LockReleaseAfterTTL")
-
-	locker := NewRWKeyedLocker[string](500 * time.Millisecond)
-
-	var locked bool
-	err := locker.Lock(context.Background(), "key1", func() {
-		locked = true
-	})
-
-	assert.IsNil(err)
-	assert.Equal(true, locked)
-}
-
-func TestRWKeyedLocker_RLockParallel(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestKeyedLocker_LockReleaseAfterTTL")
-
-	locker := NewRWKeyedLocker[string](1 * time.Second)
-
-	var mu sync.Mutex
-	var count int
-	wg := sync.WaitGroup{}
-
-	for i := 0; i < 5; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			err := locker.RLock(context.Background(), "shared-key", func() {
-				time.Sleep(10 * time.Millisecond)
-				mu.Lock()
-				count++
-				mu.Unlock()
-			})
-
-			assert.IsNil(err)
-		}()
-	}
-
-	wg.Wait()
-
-	assert.Equal(5, count)
-}
-
-func TestRWKeyedLocker_LockTimeout(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestRWKeyedLocker_LockTimeout")
-
-	locker := NewRWKeyedLocker[string](1 * time.Second)
-
-	start := make(chan struct{})
-
-	go func() {
-		locker.Lock(context.Background(), "key-timeout", func() {
-			close(start)
-			time.Sleep(200 * time.Millisecond)
-		})
-	}()
-
-	<-start
-	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
-	defer cancel()
-
-	err := locker.Lock(ctx, "key-timeout", func() {
-		t.Error("should not reach here")
-	})
-
-	assert.IsNotNil(err)
-}
-
-func TestTryKeyedLocker_SimpleLockUnlock(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestTryKeyedLocker_SimpleLockUnlock")
-
-	locker := NewTryKeyedLocker[string]()
-
-	ok := locker.TryLock("key1")
-	assert.Equal(true, ok)
-
-	ok = locker.TryLock("key1")
-	assert.Equal(false, ok)
-
-	locker.Unlock("key1")
-
-	ok = locker.TryLock("key1")
-	assert.Equal(true, ok)
-
-	locker.Unlock("key1")
-}
-
-func TestTryKeyedLocker_ParallelTry(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestTryKeyedLocker_ParallelTry")
-
-	locker := NewTryKeyedLocker[string]()
-
-	var wg sync.WaitGroup
-	var mu sync.Mutex
-	var count int
-
-	for i := 0; i < 5; i++ {
-		wg.Add(1)
-		go func(i int) {
-			defer wg.Done()
-			ok := locker.TryLock("key" + strconv.Itoa(i))
-			mu.Lock()
-			if ok {
-				count++
-			}
-			mu.Unlock()
-			time.Sleep(10 * time.Millisecond)
-			if ok {
-				locker.Unlock("key" + strconv.Itoa(i))
-			}
-		}(i)
-	}
-
-	wg.Wait()
-
-	assert.Equal(5, count)
-	assert.Equal(0, len(locker.locks))
-}

condition/condition.go

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

condition/condition_example_test.go

@@ -1,163 +0,0 @@
-package condition
-
-import "fmt"
-
-func ExampleBool() {
-	// bool
-	result1 := Bool(false)
-	result2 := Bool(true)
-	fmt.Println(result1)
-	fmt.Println(result2)
-
-	// integer
-	result3 := Bool(0)
-	result4 := Bool(1)
-	fmt.Println(result3)
-	fmt.Println(result4)
-
-	// string
-	result5 := Bool("")
-	result6 := Bool(" ")
-	fmt.Println(result5)
-	fmt.Println(result6)
-
-	// slice
-	var nums = []int{}
-	result7 := Bool(nums)
-	nums = append(nums, 1, 2)
-	result8 := Bool(nums)
-	fmt.Println(result7)
-	fmt.Println(result8)
-
-	// Output:
-	// false
-	// true
-	// false
-	// true
-	// false
-	// true
-	// false
-	// true
-}
-
-func ExampleAnd() {
-	result1 := And(0, 1)
-	result2 := And(0, "")
-	result3 := And(0, "0")
-	result4 := And(1, "0")
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
-
-	// Output:
-	// false
-	// false
-	// false
-	// true
-}
-
-func ExampleOr() {
-	result1 := Or(0, "")
-	result2 := Or(0, 1)
-	result3 := Or(0, "0")
-	result4 := Or(1, "0")
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
-
-	// Output:
-	// false
-	// true
-	// true
-	// true
-}
-
-func ExampleXor() {
-	result1 := Xor(0, 0)
-	result2 := Xor(1, 1)
-	result3 := Xor(0, 1)
-	result4 := Xor(1, 0)
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
-
-	// Output:
-	// false
-	// false
-	// true
-	// true
-}
-
-func ExampleNor() {
-	result1 := Nor(0, 0)
-	result2 := Nor(1, 1)
-	result3 := Nor(0, 1)
-	result4 := Nor(1, 0)
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
-
-	// Output:
-	// true
-	// false
-	// false
-	// false
-}
-
-func ExampleXnor() {
-	result1 := Xnor(0, 0)
-	result2 := Xnor(1, 1)
-	result3 := Xnor(0, 1)
-	result4 := Xnor(1, 0)
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
-
-	// Output:
-	// true
-	// true
-	// false
-	// false
-}
-
-func ExampleNand() {
-	result1 := Nand(0, 0)
-	result2 := Nand(1, 0)
-	result3 := Nand(0, 1)
-	result4 := Nand(1, 1)
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
-
-	// Output:
-	// true
-	// true
-	// true
-	// false
-}
-
-func ExampleTernary() {
-	conditionTrue := 2 > 1
-	result1 := Ternary(conditionTrue, 0, 1)
-	fmt.Println(result1)
-
-	conditionFalse := 2 > 3
-	result2 := Ternary(conditionFalse, 0, 1)
-	fmt.Println(result2)
-
-	// Output:
-	// 0
-	// 1
-}

condition/condition_test.go

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

constraints/constraints.go

@@ -1,13 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package constraints contain some custom interface.
-package constraints
-
-// Comparator is for comparing two values
-type Comparator interface {
-	// Compare v1 and v2
-	// Ascending order: should return 1 -> v1 > v2, 0 -> v1 = v2, -1 -> v1 < v2
-	// Descending order: should return 1 -> v1 < v2, 0 -> v1 = v2, -1 -> v1 > v2
-	Compare(v1, v2 any) int
-}

convertor/convertor.go

@@ -14,25 +14,22 @@ import (
 	"fmt"
 	"io"
 	"math"
-	"math/big"
 	"reflect"
+	"regexp"
 	"strconv"
 	"strings"
 
-	"github.com/duke-git/lancet/v2/structs"
 	"golang.org/x/text/encoding/simplifiedchinese"
 	"golang.org/x/text/transform"
 )
 
-// ToBool convert string to boolean.
-// Play: https://go.dev/play/p/ARht2WnGdIN
+// ToBool convert string to a boolean
 func ToBool(s string) (bool, error) {
 	return strconv.ParseBool(s)
 }
 
-// ToBytes convert value to byte slice.
-// Play: https://go.dev/play/p/fAMXYFDvOvr
-func ToBytes(value any) ([]byte, error) {
+// ToBytes convert interface to bytes
+func ToBytes(value interface{}) ([]byte, error) {
 	v := reflect.ValueOf(value)
 
 	switch value.(type) {
@@ -72,10 +69,9 @@ func ToBytes(value any) ([]byte, error) {
 	}
 }
 
-// ToChar convert string to char slice.
-// Play: https://go.dev/play/p/JJ1SvbFkVdM
+// ToChar convert string to char slice
 func ToChar(s string) []string {
-	c := make([]string, 0, len(s))
+	c := make([]string, 0)
 	if len(s) == 0 {
 		c = append(c, "")
 	}
@@ -85,36 +81,11 @@ func ToChar(s string) []string {
 	return c
 }
 
-// ToChannel convert a slice of elements to a read-only channel.
-// Play: https://go.dev/play/p/hOx_oYZbAnL
-func ToChannel[T any](array []T) <-chan T {
-	ch := make(chan T)
-
-	go func() {
-		for _, item := range array {
-			ch <- item
-		}
-		close(ch)
-	}()
-
-	return ch
-}
-
 // ToString convert value to string
-// for number, string, []byte, will convert to string
-// for other type (slice, map, array, struct) will call json.Marshal.
-// Play: https://go.dev/play/p/nF1zOOslpQq
-func ToString(value any) string {
+func ToString(value interface{}) string {
 	if value == nil {
 		return ""
 	}
-	rv := reflect.ValueOf(value)
-	if rv.Kind() == reflect.Ptr {
-		if rv.IsNil() {
-			return ""
-		}
-		return ToString(rv.Elem().Interface())
-	}
 
 	switch val := value.(type) {
 	case float32:
@@ -150,153 +121,105 @@ func ToString(value any) string {
 		if err != nil {
 			return ""
 		}
-
 		return string(b)
 	}
 }
 
-// ToJson convert value to a json string.
-// Play: https://go.dev/play/p/2rLIkMmXWvR
-func ToJson(value any) (string, error) {
-	result, err := json.Marshal(value)
+// ToJson convert value to a valid json string
+func ToJson(value interface{}) (string, error) {
+	res, err := json.Marshal(value)
 	if err != nil {
 		return "", err
 	}
 
-	return string(result), nil
+	return string(res), nil
 }
 
-// ToFloat convert value to float64, if input is not a float return 0.0 and error.
-// Play: https://go.dev/play/p/4YTmPCibqHJ
-func ToFloat(value any) (float64, error) {
+// ToFloat convert value to a float64, if input is not a float return 0.0 and error
+func ToFloat(value interface{}) (float64, error) {
 	v := reflect.ValueOf(value)
 
-	result := 0.0
+	res := 0.0
 	err := fmt.Errorf("ToInt: unvalid interface type %T", value)
 	switch value.(type) {
 	case int, int8, int16, int32, int64:
-		result = float64(v.Int())
-		return result, nil
+		res = float64(v.Int())
+		return res, nil
 	case uint, uint8, uint16, uint32, uint64:
-		result = float64(v.Uint())
-		return result, nil
+		res = float64(v.Uint())
+		return res, nil
 	case float32, float64:
-		result = v.Float()
-		return result, nil
+		res = v.Float()
+		return res, nil
 	case string:
-		result, err = strconv.ParseFloat(v.String(), 64)
+		res, err = strconv.ParseFloat(v.String(), 64)
 		if err != nil {
-			result = 0.0
+			res = 0.0
 		}
-		return result, err
+		return res, err
 	default:
-		return result, err
+		return res, err
 	}
 }
 
-// ToInt convert value to int64 value, if input is not numerical, return 0 and error.
-// Play: https://go.dev/play/p/9_h9vIt-QZ_b
-func ToInt(value any) (int64, error) {
+// ToInt convert value to a int64, if input is not a numeric format return 0 and error
+func ToInt(value interface{}) (int64, error) {
 	v := reflect.ValueOf(value)
 
-	var result int64
-	err := fmt.Errorf("ToInt: invalid value type %T", value)
+	var res int64
+	err := fmt.Errorf("ToInt: invalid interface type %T", value)
 	switch value.(type) {
 	case int, int8, int16, int32, int64:
-		result = v.Int()
-		return result, nil
+		res = v.Int()
+		return res, nil
 	case uint, uint8, uint16, uint32, uint64:
-		result = int64(v.Uint())
-		return result, nil
+		res = int64(v.Uint())
+		return res, nil
 	case float32, float64:
-		result = int64(v.Float())
-		return result, nil
+		res = int64(v.Float())
+		return res, nil
 	case string:
-		result, err = strconv.ParseInt(v.String(), 0, 64)
+		res, err = strconv.ParseInt(v.String(), 0, 64)
 		if err != nil {
-			result = 0
+			res = 0
 		}
-		return result, err
+		return res, err
 	default:
-		return result, err
+		return res, err
 	}
 }
 
-// ToPointer returns a pointer to passed value.
-// Play: https://go.dev/play/p/ASf_etHNlw1
-func ToPointer[T any](value T) *T {
-	return &value
-}
-
-// ToPointers convert a slice of values to a slice of pointers.
-// Play: https://go.dev/play/p/ZUoXd2i5ZkV
-func ToPointers[T any](values []T) []*T {
-	result := make([]*T, len(values))
-	for i := range values {
-		result[i] = &values[i]
-	}
-	return result
-}
-
-// FromPointer returns the value pointed to by the pointer.
-// Play: https://go.dev/play/p/wAp90V7Zu6g
-func FromPointer[T any](ptr *T) T {
-	if ptr == nil {
-		var zeroValue T
-		return zeroValue
-	}
-
-	return *ptr
-}
-
-// FromPointers convert a slice of pointers to a slice of values.
-// Play: https://go.dev/play/p/qIPsyYtNy3Q
-func FromPointers[T any](pointers []*T) []T {
-	result := make([]T, len(pointers))
-	for i, ptr := range pointers {
-		if ptr == nil {
-			var zeroValue T
-			result[i] = zeroValue
-		} else {
-			result[i] = *ptr
-		}
-	}
-	return result
-}
-
-// ToMap convert a slice of structs to a map based on iteratee function.
-// Play: https://go.dev/play/p/tVFy7E-t24l
-func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K]V {
-	result := make(map[K]V, len(array))
-	for _, item := range array {
-		k, v := iteratee(item)
-		result[k] = v
-	}
-
-	return result
-}
-
 // StructToMap convert struct to map, only convert exported struct field
-// map key is specified same as struct field tag `json` value.
-// Play: https://go.dev/play/p/KYGYJqNUBOI
-func StructToMap(value any) (map[string]any, error) {
-	return structs.ToMap(value)
-}
+// map key is specified same as struct field tag `json` value
+func StructToMap(value interface{}) (map[string]interface{}, error) {
+	v := reflect.ValueOf(value)
+	t := reflect.TypeOf(value)
 
-// MapToSlice convert map to slice based on iteratee function.
-// Play: https://go.dev/play/p/dmX4Ix5V6Wl
-func MapToSlice[T any, K comparable, V any](aMap map[K]V, iteratee func(K, V) T) []T {
-	result := make([]T, 0, len(aMap))
-
-	for k, v := range aMap {
-		result = append(result, iteratee(k, v))
+	if t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	if t.Kind() != reflect.Struct {
+		return nil, fmt.Errorf("data type %T not support, shuld be struct or pointer to struct", value)
 	}
 
-	return result
+	res := make(map[string]interface{})
+
+	fieldNum := t.NumField()
+	pattern := `^[A-Z]`
+	regex := regexp.MustCompile(pattern)
+	for i := 0; i < fieldNum; i++ {
+		name := t.Field(i).Name
+		tag := t.Field(i).Tag.Get("json")
+		if regex.MatchString(name) && tag != "" {
+			//res[name] = v.Field(i).Interface()
+			res[tag] = v.Field(i).Interface()
+		}
+	}
+
+	return res, nil
 }
 
-// ColorHexToRGB convert hex color to rgb color.
-// Play: https://go.dev/play/p/o7_ft-JCJBV
+// ColorHexToRGB convert hex color to rgb color
 func ColorHexToRGB(colorHex string) (red, green, blue int) {
 	colorHex = strings.TrimPrefix(colorHex, "#")
 	color64, err := strconv.ParseInt(colorHex, 16, 32)
@@ -307,8 +230,7 @@ func ColorHexToRGB(colorHex string) (red, green, blue int) {
 	return color >> 16, (color & 0x00FF00) >> 8, color & 0x0000FF
 }
 
-// ColorRGBToHex convert rgb color to hex color.
-// Play: https://go.dev/play/p/nzKS2Ro87J1
+// ColorRGBToHex convert rgb color to hex color
 func ColorRGBToHex(red, green, blue int) string {
 	r := strconv.FormatInt(int64(red), 16)
 	g := strconv.FormatInt(int64(green), 16)
@@ -327,9 +249,22 @@ func ColorRGBToHex(red, green, blue int) string {
 	return "#" + r + g + b
 }
 
-// EncodeByte encode data to byte slice.
-// Play: https://go.dev/play/p/DVmM1G5JfuP
-func EncodeByte(data any) ([]byte, error) {
+// ToChannel convert a array of elements to a read-only channels
+func ToChannel(array []interface{}) <-chan interface{} {
+	ch := make(chan interface{})
+
+	go func() {
+		for _, item := range array {
+			ch <- item
+		}
+		close(ch)
+	}()
+
+	return ch
+}
+
+// EncodeByte encode data to byte
+func EncodeByte(data interface{}) ([]byte, error) {
 	buffer := bytes.NewBuffer(nil)
 	encoder := gob.NewEncoder(buffer)
 	err := encoder.Encode(data)
@@ -339,9 +274,8 @@ func EncodeByte(data any) ([]byte, error) {
 	return buffer.Bytes(), nil
 }
 
-// DecodeByte decode byte slice data to target object.
-// Play: https://go.dev/play/p/zI6xsmuQRbn
-func DecodeByte(data []byte, target any) error {
+// DecodeByte decode byte data to target object
+func DecodeByte(data []byte, target interface{}) error {
 	buffer := bytes.NewBuffer(data)
 	decoder := gob.NewDecoder(buffer)
 	return decoder.Decode(target)
@@ -349,24 +283,21 @@ func DecodeByte(data []byte, target any) error {
 
 // DeepClone creates a deep copy of passed item.
 // can't clone unexported field of struct
-// Play: https://go.dev/play/p/j4DP5dquxnk
-func DeepClone[T any](src T) T {
+func DeepClone(src interface{}) interface{} {
 	c := cloner{
 		ptrs: map[reflect.Type]map[uintptr]reflect.Value{},
 	}
 	result := c.clone(reflect.ValueOf(src))
 	if result.Kind() == reflect.Invalid {
-		var zeroValue T
-		return zeroValue
+		return nil
 	}
 
-	return result.Interface().(T)
+	return result.Interface()
 }
 
 // CopyProperties copies each field from the source into the destination. It recursively copies struct pointers and interfaces that contain struct pointers.
 // use json.Marshal/Unmarshal, so json tag should be set for fields of dst and src struct.
-// Play: https://go.dev/play/p/oZujoB5Sgg5
-func CopyProperties[T, U any](dst T, src U) error {
+func CopyProperties(dst, src interface{}) error {
 	dstType, srcType := reflect.TypeOf(dst), reflect.TypeOf(src)
 
 	if dstType.Kind() != reflect.Ptr || dstType.Elem().Kind() != reflect.Struct {
@@ -393,7 +324,6 @@ func CopyProperties[T, U any](dst T, src U) error {
 }
 
 // ToInterface converts reflect value to its interface type.
-// Play: https://go.dev/play/p/syqw0-WG7Xd
 func ToInterface(v reflect.Value) (value interface{}, ok bool) {
 	if v.IsValid() && v.CanInterface() {
 		return v.Interface(), true
@@ -421,7 +351,6 @@ func ToInterface(v reflect.Value) (value interface{}, ok bool) {
 }
 
 // Utf8ToGbk convert utf8 encoding data to GBK encoding data.
-// Play: https://go.dev/play/p/9FlIaFLArIL
 func Utf8ToGbk(bs []byte) ([]byte, error) {
 	r := transform.NewReader(bytes.NewReader(bs), simplifiedchinese.GBK.NewEncoder())
 	b, err := io.ReadAll(r)
@@ -429,28 +358,38 @@ func Utf8ToGbk(bs []byte) ([]byte, error) {
 }
 
 // GbkToUtf8 convert GBK encoding data to utf8 encoding data.
-// Play: https://go.dev/play/p/OphmHCN_9u8
 func GbkToUtf8(bs []byte) ([]byte, error) {
 	r := transform.NewReader(bytes.NewReader(bs), simplifiedchinese.GBK.NewDecoder())
 	b, err := io.ReadAll(r)
 	return b, err
 }
 
+// MapToStruct converts map to struct
+func MapToStruct(m map[string]interface{}, structObj interface{}) error {
+	for k, v := range m {
+		err := setStructField(structObj, k, v)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 // ToStdBase64 convert data to standard base64 encoding.
-// Play: https://go.dev/play/p/_fLJqJD3NMo
-func ToStdBase64(value any) string {
+func ToStdBase64(value interface{}) string {
 	if value == nil || (reflect.ValueOf(value).Kind() == reflect.Ptr && reflect.ValueOf(value).IsNil()) {
 		return ""
 	}
-	switch v := value.(type) {
+	switch value.(type) {
 	case []byte:
-		return base64.StdEncoding.EncodeToString(v)
+		return base64.StdEncoding.EncodeToString(value.([]byte))
 	case string:
-		return base64.StdEncoding.EncodeToString([]byte(v))
+		return base64.StdEncoding.EncodeToString([]byte(value.(string)))
 	case error:
-		return base64.StdEncoding.EncodeToString([]byte(v.Error()))
+		return base64.StdEncoding.EncodeToString([]byte(value.(error).Error()))
 	default:
-		marshal, err := json.Marshal(v)
+		marshal, err := json.Marshal(value)
 		if err != nil {
 			return ""
 		}
@@ -459,20 +398,19 @@ func ToStdBase64(value any) string {
 }
 
 // ToUrlBase64 convert data to URL base64 encoding.
-// Play: https://go.dev/play/p/C_d0GlvEeUR
-func ToUrlBase64(value any) string {
+func ToUrlBase64(value interface{}) string {
 	if value == nil || (reflect.ValueOf(value).Kind() == reflect.Ptr && reflect.ValueOf(value).IsNil()) {
 		return ""
 	}
-	switch v := value.(type) {
+	switch value.(type) {
 	case []byte:
-		return base64.URLEncoding.EncodeToString(v)
+		return base64.URLEncoding.EncodeToString(value.([]byte))
 	case string:
-		return base64.URLEncoding.EncodeToString([]byte(v))
+		return base64.URLEncoding.EncodeToString([]byte(value.(string)))
 	case error:
-		return base64.URLEncoding.EncodeToString([]byte(v.Error()))
+		return base64.URLEncoding.EncodeToString([]byte(value.(error).Error()))
 	default:
-		marshal, err := json.Marshal(v)
+		marshal, err := json.Marshal(value)
 		if err != nil {
 			return ""
 		}
@@ -481,12 +419,11 @@ func ToUrlBase64(value any) string {
 }
 
 // ToRawStdBase64 convert data to raw standard base64 encoding.
-// Play: https://go.dev/play/p/wSAr3sfkDcv
-func ToRawStdBase64(value any) string {
+func ToRawStdBase64(value interface{}) string {
 	if value == nil || (reflect.ValueOf(value).Kind() == reflect.Ptr && reflect.ValueOf(value).IsNil()) {
 		return ""
 	}
-	switch v := value.(type) {
+	switch value.(type) {
 	case []byte:
 		return base64.RawStdEncoding.EncodeToString(value.([]byte))
 	case string:
@@ -494,7 +431,7 @@ func ToRawStdBase64(value any) string {
 	case error:
 		return base64.RawStdEncoding.EncodeToString([]byte(value.(error).Error()))
 	default:
-		marshal, err := json.Marshal(v)
+		marshal, err := json.Marshal(value)
 		if err != nil {
 			return ""
 		}
@@ -503,12 +440,11 @@ func ToRawStdBase64(value any) string {
 }
 
 // ToRawUrlBase64 convert data to raw URL base64 encoding.
-// Play: https://go.dev/play/p/HwdDPFcza1O
-func ToRawUrlBase64(value any) string {
+func ToRawUrlBase64(value interface{}) string {
 	if value == nil || (reflect.ValueOf(value).Kind() == reflect.Ptr && reflect.ValueOf(value).IsNil()) {
 		return ""
 	}
-	switch v := value.(type) {
+	switch value.(type) {
 	case []byte:
 		return base64.RawURLEncoding.EncodeToString(value.([]byte))
 	case string:
@@ -516,43 +452,10 @@ func ToRawUrlBase64(value any) string {
 	case error:
 		return base64.RawURLEncoding.EncodeToString([]byte(value.(error).Error()))
 	default:
-		marshal, err := json.Marshal(v)
+		marshal, err := json.Marshal(value)
 		if err != nil {
 			return ""
 		}
 		return base64.RawURLEncoding.EncodeToString(marshal)
 	}
 }
-
-// ToBigInt converts an integer of any supported type (int, int64, uint64, etc.) to *big.Int
-// Play: https://go.dev/play/p/X3itkCxwB_x
-func ToBigInt[T any](v T) (*big.Int, error) {
-	result := new(big.Int)
-
-	switch v := any(v).(type) {
-	case int:
-		result.SetInt64(int64(v)) // Convert to int64 for big.Int
-	case int8:
-		result.SetInt64(int64(v))
-	case int16:
-		result.SetInt64(int64(v))
-	case int32:
-		result.SetInt64(int64(v))
-	case int64:
-		result.SetInt64(v)
-	case uint:
-		result.SetUint64(uint64(v)) // Convert to uint64 for big.Int
-	case uint8:
-		result.SetUint64(uint64(v))
-	case uint16:
-		result.SetUint64(uint64(v))
-	case uint32:
-		result.SetUint64(uint64(v))
-	case uint64:
-		result.SetUint64(v)
-	default:
-		return nil, fmt.Errorf("unsupported type: %T", v)
-	}
-
-	return result, nil
-}

convertor/convertor_example_test.go

@@ -1,621 +0,0 @@
-package convertor
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"strconv"
-	"unicode/utf8"
-
-	"github.com/duke-git/lancet/v2/validator"
-)
-
-func ExampleToBool() {
-	cases := []string{"1", "true", "True", "false", "False", "0", "123", "0.0", "abc"}
-
-	for i := 0; i < len(cases); i++ {
-		result, _ := ToBool(cases[i])
-		fmt.Println(result)
-	}
-
-	// Output:
-	// true
-	// true
-	// true
-	// false
-	// false
-	// false
-	// false
-	// false
-	// false
-}
-
-func ExampleToBytes() {
-	result1, _ := ToBytes(1)
-	result2, _ := ToBytes("abc")
-	result3, _ := ToBytes(true)
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-
-	// Output:
-	// [0 0 0 0 0 0 0 1]
-	// [97 98 99]
-	// [116 114 117 101]
-}
-
-func ExampleToChar() {
-	result1 := ToChar("")
-	result2 := ToChar("abc")
-	result3 := ToChar("1 2#3")
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-
-	// Output:
-	// []
-	// [a b c]
-	// [1   2 # 3]
-}
-
-func ExampleToChannel() {
-	ch := ToChannel([]int{1, 2, 3})
-	result1 := <-ch
-	result2 := <-ch
-	result3 := <-ch
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-
-	// Output:
-	// 1
-	// 2
-	// 3
-}
-
-func ExampleToString() {
-	result1 := ToString("")
-	result2 := ToString(nil)
-	result3 := ToString(0)
-	result4 := ToString(1.23)
-	result5 := ToString(true)
-	result6 := ToString(false)
-	result7 := ToString([]int{1, 2, 3})
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
-	fmt.Println(result5)
-	fmt.Println(result6)
-	fmt.Println(result7)
-
-	// Output:
-	//
-	//
-	// 0
-	// 1.23
-	// true
-	// false
-	// [1,2,3]
-}
-
-func ExampleToJson() {
-
-	aMap := map[string]int{"a": 1, "b": 2, "c": 3}
-	result1, err := ToJson(aMap)
-	if err != nil {
-		fmt.Printf("%v", err)
-	}
-	fmt.Println(result1)
-
-	// Output:
-	// {"a":1,"b":2,"c":3}
-}
-
-func ExampleToFloat() {
-	result1, _ := ToFloat("")
-	result2, _ := ToFloat("abc")
-	result3, _ := ToFloat("-1")
-	result4, _ := ToFloat("-.11")
-	result5, _ := ToFloat("1.23e3")
-	result6, _ := ToFloat(true)
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
-	fmt.Println(result5)
-	fmt.Println(result6)
-
-	// Output:
-	// 0
-	// 0
-	// -1
-	// -0.11
-	// 1230
-	// 0
-}
-
-func ExampleToInt() {
-	result1, _ := ToInt("123")
-	result2, _ := ToInt("-123")
-	result3, _ := ToInt(float64(12.3))
-	result4, _ := ToInt("abc")
-	result5, _ := ToInt(true)
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
-	fmt.Println(result5)
-
-	// Output:
-	// 123
-	// -123
-	// 12
-	// 0
-	// 0
-}
-
-func ExampleToPointer() {
-	result := ToPointer(123)
-	fmt.Println(*result)
-
-	// Output:
-	// 123
-}
-
-func ExampleToPointers() {
-	strs := []string{"a", "b", "c"}
-	pointerStrs := ToPointers(strs)
-	fmt.Println(*pointerStrs[0])
-	fmt.Println(*pointerStrs[1])
-	fmt.Println(*pointerStrs[2])
-
-	// Output:
-	// a
-	// b
-	// c
-}
-
-func ExampleFromPointer() {
-	str := "abc"
-	strPtr := &str
-	result := FromPointer(strPtr)
-	fmt.Println(result)
-
-	// Output:
-	// abc
-}
-
-func ExampleFromPointers() {
-	strs := []string{"a", "b", "c"}
-	strPtr := []*string{&strs[0], &strs[1], &strs[2]}
-
-	result := FromPointers(strPtr)
-
-	fmt.Println(result[0])
-	fmt.Println(result[1])
-	fmt.Println(result[2])
-
-	// Output:
-	// a
-	// b
-	// c
-}
-
-func ExampleToMap() {
-	type Message struct {
-		name string
-		code int
-	}
-	messages := []Message{
-		{name: "Hello", code: 100},
-		{name: "Hi", code: 101},
-	}
-	result := ToMap(messages, func(msg Message) (int, string) {
-		return msg.code, msg.name
-	})
-
-	fmt.Println(result)
-
-	// Output:
-	// map[100:Hello 101:Hi]
-}
-
-func ExampleStructToMap() {
-	type People struct {
-		Name string `json:"name"`
-		age  int
-	}
-	p := People{
-		"test",
-		100,
-	}
-	pm, _ := StructToMap(p)
-
-	fmt.Println(pm)
-
-	// Output:
-	// map[name:test]
-}
-
-func ExampleMapToSlice() {
-	aMap := map[string]int{"a": 1, "b": 2, "c": 3}
-	result := MapToSlice(aMap, func(key string, value int) string {
-		return key + ":" + strconv.Itoa(value)
-	})
-
-	fmt.Println(result) //[]string{"a:1", "c:3", "b:2"} (random order)
-}
-
-func ExampleColorHexToRGB() {
-	colorHex := "#003366"
-	r, g, b := ColorHexToRGB(colorHex)
-
-	fmt.Println(r, g, b)
-
-	// Output:
-	// 0 51 102
-}
-
-func ExampleColorRGBToHex() {
-	r := 0
-	g := 51
-	b := 102
-	colorHex := ColorRGBToHex(r, g, b)
-
-	fmt.Println(colorHex)
-
-	// Output:
-	// #003366
-}
-
-func ExampleEncodeByte() {
-	byteData, _ := EncodeByte("abc")
-	fmt.Println(byteData)
-
-	// Output:
-	// [6 12 0 3 97 98 99]
-}
-
-func ExampleDecodeByte() {
-	var obj string
-	byteData := []byte{6, 12, 0, 3, 97, 98, 99}
-	err := DecodeByte(byteData, &obj)
-	if err != nil {
-		return
-	}
-
-	fmt.Println(obj)
-
-	// Output:
-	// abc
-}
-
-func ExampleDeepClone() {
-	type Struct struct {
-		Str   string
-		Int   int
-		Float float64
-		Bool  bool
-		Nil   interface{}
-		// unexported string
-	}
-
-	cases := []interface{}{
-		true,
-		1,
-		0.1,
-		map[string]int{
-			"a": 1,
-			"b": 2,
-		},
-		&Struct{
-			Str:   "test",
-			Int:   1,
-			Float: 0.1,
-			Bool:  true,
-			Nil:   nil,
-			// unexported: "can't be cloned",
-		},
-	}
-
-	for _, item := range cases {
-		cloned := DeepClone(item)
-
-		isPointerEqual := &cloned == &item
-		fmt.Println(cloned, isPointerEqual)
-	}
-
-	// Output:
-	// true false
-	// 1 false
-	// 0.1 false
-	// map[a:1 b:2] false
-	// &{test 1 0.1 true <nil>} false
-}
-
-func ExampleCopyProperties() {
-	type Disk struct {
-		Name    string  `json:"name"`
-		Total   string  `json:"total"`
-		Used    string  `json:"used"`
-		Percent float64 `json:"percent"`
-	}
-
-	type DiskVO struct {
-		Name    string  `json:"name"`
-		Total   string  `json:"total"`
-		Used    string  `json:"used"`
-		Percent float64 `json:"percent"`
-	}
-
-	type Indicator struct {
-		Id      string    `json:"id"`
-		Ip      string    `json:"ip"`
-		UpTime  string    `json:"upTime"`
-		LoadAvg string    `json:"loadAvg"`
-		Cpu     int       `json:"cpu"`
-		Disk    []Disk    `json:"disk"`
-		Stop    chan bool `json:"-"`
-	}
-
-	type IndicatorVO struct {
-		Id      string   `json:"id"`
-		Ip      string   `json:"ip"`
-		UpTime  string   `json:"upTime"`
-		LoadAvg string   `json:"loadAvg"`
-		Cpu     int64    `json:"cpu"`
-		Disk    []DiskVO `json:"disk"`
-	}
-
-	indicator := &Indicator{Id: "001", Ip: "127.0.0.1", Cpu: 1, Disk: []Disk{
-		{Name: "disk-001", Total: "100", Used: "1", Percent: 10},
-		{Name: "disk-002", Total: "200", Used: "1", Percent: 20},
-		{Name: "disk-003", Total: "300", Used: "1", Percent: 30},
-	}}
-
-	indicatorVO := IndicatorVO{}
-
-	CopyProperties(&indicatorVO, indicator)
-
-	fmt.Println(indicatorVO.Id)
-	fmt.Println(indicatorVO.Ip)
-	fmt.Println(len(indicatorVO.Disk))
-
-	// Output:
-	// 001
-	// 127.0.0.1
-	// 3
-}
-
-func ExampleToInterface() {
-	val := reflect.ValueOf("abc")
-	iVal, ok := ToInterface(val)
-
-	fmt.Printf("%T\n", iVal)
-	fmt.Printf("%v\n", iVal)
-	fmt.Println(ok)
-
-	// Output:
-	// string
-	// abc
-	// true
-}
-
-func ExampleUtf8ToGbk() {
-	utf8Data := []byte("hello")
-	gbkData, _ := Utf8ToGbk(utf8Data)
-
-	fmt.Println(utf8.Valid(utf8Data))
-	fmt.Println(validator.IsGBK(gbkData))
-
-	// Output:
-	// true
-	// true
-}
-
-func ExampleGbkToUtf8() {
-	gbkData, _ := Utf8ToGbk([]byte("hello"))
-	utf8Data, _ := GbkToUtf8(gbkData)
-
-	fmt.Println(utf8.Valid(utf8Data))
-	fmt.Println(string(utf8Data))
-
-	// Output:
-	// true
-	// hello
-}
-
-func ExampleToStdBase64() {
-	// if you want to see the result, please use 'base64.StdEncoding.DecodeString()' to decode the result
-
-	afterEncode := ToStdBase64(nil)
-	fmt.Println(afterEncode)
-
-	stringVal := "hello"
-	afterEncode = ToStdBase64(stringVal)
-	fmt.Println(afterEncode)
-
-	byteSliceVal := []byte("hello")
-	afterEncode = ToStdBase64(byteSliceVal)
-	fmt.Println(afterEncode)
-
-	intVal := 123
-	afterEncode = ToStdBase64(intVal)
-	fmt.Println(afterEncode)
-
-	mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
-		A string
-		B int
-	}{"hello", 3}}
-	afterEncode = ToStdBase64(mapVal)
-	fmt.Println(afterEncode)
-
-	floatVal := 123.456
-	afterEncode = ToStdBase64(floatVal)
-	fmt.Println(afterEncode)
-
-	boolVal := true
-	afterEncode = ToStdBase64(boolVal)
-	fmt.Println(afterEncode)
-
-	errVal := errors.New("err")
-	afterEncode = ToStdBase64(errVal)
-	fmt.Println(afterEncode)
-
-	// Output:
-	//
-	// aGVsbG8=
-	// aGVsbG8=
-	// MTIz
-	// eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ==
-	// MTIzLjQ1Ng==
-	// dHJ1ZQ==
-	// ZXJy
-}
-
-func ExampleToUrlBase64() {
-	// if you want to see the result, please use 'base64.URLEncoding.DecodeString()' to decode the result
-
-	stringVal := "hello"
-	afterEncode := ToUrlBase64(stringVal)
-	fmt.Println(afterEncode)
-
-	byteSliceVal := []byte("hello")
-	afterEncode = ToUrlBase64(byteSliceVal)
-	fmt.Println(afterEncode)
-
-	intVal := 123
-	afterEncode = ToUrlBase64(intVal)
-	fmt.Println(afterEncode)
-
-	mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
-		A string
-		B int
-	}{"hello", 3}}
-	afterEncode = ToUrlBase64(mapVal)
-	fmt.Println(afterEncode)
-
-	floatVal := 123.456
-	afterEncode = ToUrlBase64(floatVal)
-	fmt.Println(afterEncode)
-
-	boolVal := true
-	afterEncode = ToUrlBase64(boolVal)
-	fmt.Println(afterEncode)
-
-	errVal := errors.New("err")
-	afterEncode = ToUrlBase64(errVal)
-	fmt.Println(afterEncode)
-
-	// Output:
-	// aGVsbG8=
-	// aGVsbG8=
-	// MTIz
-	// eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ==
-	// MTIzLjQ1Ng==
-	// dHJ1ZQ==
-	// ZXJy
-}
-
-func ExampleToRawStdBase64() {
-	// if you want to see the result, please use 'base64.RawStdEncoding.DecodeString()' to decode the result
-	stringVal := "hello"
-	afterEncode := ToRawStdBase64(stringVal)
-	fmt.Println(afterEncode)
-
-	byteSliceVal := []byte("hello")
-	afterEncode = ToRawStdBase64(byteSliceVal)
-	fmt.Println(afterEncode)
-
-	intVal := 123
-	afterEncode = ToRawStdBase64(intVal)
-	fmt.Println(afterEncode)
-
-	mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
-		A string
-		B int
-	}{"hello", 3}}
-	afterEncode = ToRawStdBase64(mapVal)
-	fmt.Println(afterEncode)
-
-	floatVal := 123.456
-	afterEncode = ToRawStdBase64(floatVal)
-	fmt.Println(afterEncode)
-
-	boolVal := true
-	afterEncode = ToRawStdBase64(boolVal)
-	fmt.Println(afterEncode)
-
-	errVal := errors.New("err")
-	afterEncode = ToRawStdBase64(errVal)
-	fmt.Println(afterEncode)
-
-	// Output:
-	// aGVsbG8
-	// aGVsbG8
-	// MTIz
-	// eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ
-	// MTIzLjQ1Ng
-	// dHJ1ZQ
-	// ZXJy
-}
-
-func ExampleToRawUrlBase64() {
-	// if you want to see the result, please use 'base64.RawURLEncoding.DecodeString()' to decode the result
-
-	stringVal := "hello"
-	afterEncode := ToRawUrlBase64(stringVal)
-	fmt.Println(afterEncode)
-
-	byteSliceVal := []byte("hello")
-	afterEncode = ToRawUrlBase64(byteSliceVal)
-	fmt.Println(afterEncode)
-
-	intVal := 123
-	afterEncode = ToRawUrlBase64(intVal)
-	fmt.Println(afterEncode)
-
-	mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
-		A string
-		B int
-	}{"hello", 3}}
-	afterEncode = ToRawUrlBase64(mapVal)
-	fmt.Println(afterEncode)
-
-	floatVal := 123.456
-	afterEncode = ToRawUrlBase64(floatVal)
-	fmt.Println(afterEncode)
-
-	boolVal := true
-	afterEncode = ToRawUrlBase64(boolVal)
-	fmt.Println(afterEncode)
-
-	errVal := errors.New("err")
-	afterEncode = ToRawUrlBase64(errVal)
-	fmt.Println(afterEncode)
-
-	// Output:
-	// aGVsbG8
-	// aGVsbG8
-	// MTIz
-	// eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ
-	// MTIzLjQ1Ng
-	// dHJ1ZQ
-	// ZXJy
-}
-
-func ExampleToBigInt() {
-	n := 9876543210
-	bigInt, _ := ToBigInt(n)
-
-	fmt.Println(bigInt)
-	// Output:
-	// 9876543210
-}

convertor/convertor_internal.go

@@ -4,7 +4,10 @@
 // Package convertor implements some functions to convert data.
 package convertor
 
-import "reflect"
+import (
+	"fmt"
+	"reflect"
+)
 
 type cloner struct {
 	ptrs map[reflect.Type]map[uintptr]reflect.Value
@@ -99,7 +102,7 @@ func (c *cloner) cloneArray(v reflect.Value) reflect.Value {
 	for i := 0; i < v.Len(); i++ {
 		val := c.clone(v.Index(i))
 
-		if !val.IsValid() {
+		if val.IsValid() {
 			continue
 		}
 
@@ -214,3 +217,70 @@ func (c *cloner) cloneStruct(v reflect.Value) reflect.Value {
 
 	return clonedStruct
 }
+
+func setStructField(structObj interface{}, fieldName string, fieldValue interface{}) 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]interface{}); 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 interface{}, 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 ""
+}

convertor/convertor_test.go

@@ -5,21 +5,16 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"math/big"
 	"reflect"
-	"strconv"
 	"testing"
 	"unicode/utf8"
 	"unsafe"
 
-	"github.com/duke-git/lancet/v2/internal"
-	"github.com/duke-git/lancet/v2/slice"
-	"github.com/duke-git/lancet/v2/validator"
+	"github.com/duke-git/lancet/internal"
+	"github.com/duke-git/lancet/validator"
 )
 
 func TestToChar(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestToChar")
 
 	cases := []string{"", "abc", "1 2#3"}
@@ -33,23 +28,7 @@ func TestToChar(t *testing.T) {
 	}
 }
 
-func TestToChannel(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestToChannel")
-
-	ch := ToChannel([]int{1, 2, 3})
-	assert.Equal(1, <-ch)
-	assert.Equal(2, <-ch)
-	assert.Equal(3, <-ch)
-
-	_, ok := <-ch
-	assert.Equal(false, ok)
-}
-
 func TestToBool(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestToBool")
 
 	cases := []string{"1", "true", "True", "false", "False", "0", "123", "0.0", "abc"}
@@ -62,11 +41,9 @@ func TestToBool(t *testing.T) {
 }
 
 func TestToBytes(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestToBytes")
 
-	cases := []any{
+	cases := []interface{}{
 		0,
 		false,
 		"1",
@@ -90,11 +67,9 @@ func TestToBytes(t *testing.T) {
 }
 
 func TestToInt(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestToInt")
 
-	cases := []any{"123", "-123", 123,
+	cases := []interface{}{"123", "-123", 123,
 		uint(123), uint8(123), uint16(123), uint32(123), uint64(123),
 		float32(12.3), float64(12.3),
 		"abc", false, "111111111111111111111111111111111111111"}
@@ -108,11 +83,9 @@ func TestToInt(t *testing.T) {
 }
 
 func TestToFloat(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestToFloat")
 
-	cases := []any{
+	cases := []interface{}{
 		"", "-1", "-.11", "1.23e3", ".123e10", "abc",
 		int(0), int8(1), int16(-1), int32(123), int64(123),
 		uint(123), uint8(123), uint16(123), uint32(123), uint64(123),
@@ -128,8 +101,6 @@ func TestToFloat(t *testing.T) {
 }
 
 func TestToString(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestToString")
 
 	aMap := make(map[string]int)
@@ -142,24 +113,13 @@ func TestToString(t *testing.T) {
 	}
 	aStruct := TestStruct{Name: "TestStruct"}
 
-	i32Val := int32(123)
-	i64Val := int64(123)
-	iZeroVal := 0
-	fVal := 12.3
-	sVal := "abc"
-	var iNilPointer *int
-	var sNilPointer *string
-
-	cases := []any{
+	cases := []interface{}{
 		"", nil,
 		int(0), int8(1), int16(-1), int32(123), int64(123),
 		uint(123), uint8(123), uint16(123), uint32(123), uint64(123),
 		float64(12.3), float32(12.3),
 		true, false,
-		[]int{1, 2, 3}, aMap, aStruct, []byte{104, 101, 108, 108, 111},
-		&i32Val, &i64Val, &fVal, &sVal, &aStruct, iNilPointer, sNilPointer,
-		&iZeroVal,
-	}
+		[]int{1, 2, 3}, aMap, aStruct, []byte{104, 101, 108, 108, 111}}
 
 	expected := []string{
 		"", "",
@@ -167,10 +127,7 @@ func TestToString(t *testing.T) {
 		"123", "123", "123", "123", "123", "123", "123",
 		"12.3", "12.3",
 		"true", "false",
-		"[1,2,3]", "{\"a\":1,\"b\":2,\"c\":3}", "{\"Name\":\"TestStruct\"}", "hello",
-		"123", "123", "12.3", "abc", "{\"Name\":\"TestStruct\"}", "", "",
-		"0",
-	}
+		"[1,2,3]", "{\"a\":1,\"b\":2,\"c\":3}", "{\"Name\":\"TestStruct\"}", "hello"}
 
 	for i := 0; i < len(cases); i++ {
 		actual := ToString(cases[i])
@@ -178,8 +135,6 @@ func TestToString(t *testing.T) {
 	}
 }
 func TestToJson(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestToJson")
 
 	var aMap = map[string]int{"a": 1, "b": 2, "c": 3}
@@ -194,83 +149,23 @@ func TestToJson(t *testing.T) {
 	assert.Equal("{\"Name\":\"TestStruct\"}", structJsonStr)
 }
 
-func TestToMap(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestToMap")
-
-	type Message struct {
-		name string
-		code int
-	}
-	messages := []Message{
-		{name: "Hello", code: 100},
-		{name: "Hi", code: 101},
-	}
-	result := ToMap(messages, func(msg Message) (int, string) {
-		return msg.code, msg.name
-	})
-	expected := map[int]string{100: "Hello", 101: "Hi"}
-
-	assert.Equal(expected, result)
-}
-
 func TestStructToMap(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestStructToMap")
 
-	t.Run("StructToMap", func(_ *testing.T) {
-		type People struct {
-			Name string `json:"name"`
-			age  int
-		}
-		p := People{
-			"test",
-			100,
-		}
-		pm, _ := StructToMap(p)
-		var expected = map[string]any{"name": "test"}
-		assert.Equal(expected, pm)
-	})
-
-	t.Run("StructToMapWithJsonAttr", func(_ *testing.T) {
-		type People struct {
-			Name  string `json:"name,omitempty"` // json tag with attribute
-			Phone string `json:"phone"`          // json tag without attribute
-			Sex   string `json:"-"`              // ignore
-			age   int    // no tag
-		}
-		p := People{
-			Phone: "1111",
-			Sex:   "male",
-			age:   100,
-		}
-		pm, _ := StructToMap(p)
-		var expected = map[string]any{"phone": "1111"}
-		assert.Equal(expected, pm)
-	})
-}
-
-func TestMapToSlice(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestMapToSlice")
-
-	aMap := map[string]int{"a": 1, "b": 2, "c": 3}
-	result := MapToSlice(aMap, func(key string, value int) string {
-		return key + ":" + strconv.Itoa(value)
-	})
-
-	assert.Equal(3, len(result))
-	assert.Equal(true, slice.Contain(result, "a:1"))
-	assert.Equal(true, slice.Contain(result, "b:2"))
-	assert.Equal(true, slice.Contain(result, "c:3"))
+	type People struct {
+		Name string `json:"name"`
+		age  int
+	}
+	p := People{
+		"test",
+		100,
+	}
+	pm, _ := StructToMap(p)
+	var expected = map[string]interface{}{"name": "test"}
+	assert.Equal(expected, pm)
 }
 
 func TestColorHexToRGB(t *testing.T) {
-	t.Parallel()
-
 	colorHex := "#003366"
 	r, g, b := ColorHexToRGB(colorHex)
 	colorRGB := fmt.Sprintf("%d,%d,%d", r, g, b)
@@ -281,8 +176,6 @@ func TestColorHexToRGB(t *testing.T) {
 }
 
 func TestColorRGBToHex(t *testing.T) {
-	t.Parallel()
-
 	r := 0
 	g := 51
 	b := 102
@@ -293,87 +186,24 @@ func TestColorRGBToHex(t *testing.T) {
 	assert.Equal(expected, colorHex)
 }
 
-func TestToPointer(t *testing.T) {
-	t.Parallel()
+func TestToChannel(t *testing.T) {
+	assert := internal.NewAssert(t, "TestToChannel")
 
-	assert := internal.NewAssert(t, "TestToPointer")
-	result := ToPointer(123)
+	ch := ToChannel([]interface{}{1, 2, 3})
+	val1, _ := <-ch
+	assert.Equal(1, val1)
 
-	assert.Equal(*result, 123)
-}
+	val2, _ := <-ch
+	assert.Equal(2, val2)
 
-func TestToPointers(t *testing.T) {
-	t.Parallel()
+	val3, _ := <-ch
+	assert.Equal(3, val3)
 
-	assert := internal.NewAssert(t, "TestToPointers")
-
-	intVals := []int{1, 2, 3}
-	result := ToPointers(intVals)
-
-	assert.Equal(3, len(result))
-	assert.Equal(1, *result[0])
-	assert.Equal(2, *result[1])
-	assert.Equal(3, *result[2])
-
-	stringVals := []string{"a", "b", "c"}
-	resultStr := ToPointers(stringVals)
-	assert.Equal(3, len(resultStr))
-	assert.Equal("a", *resultStr[0])
-	assert.Equal("b", *resultStr[1])
-	assert.Equal("c", *resultStr[2])
-}
-
-func TestFromPointer(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestFromPointer")
-
-	intVal := 123
-	pointer := &intVal
-	result := FromPointer(pointer)
-
-	assert.Equal(123, result)
-
-	stringVal := "abc"
-	stringPointer := &stringVal
-	resultStr := FromPointer(stringPointer)
-
-	assert.Equal("abc", resultStr)
-}
-
-func TestFromPointers(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestFromPointers")
-
-	intPointers := []*int{new(int), new(int), new(int)}
-	*intPointers[0] = 1
-	*intPointers[1] = 2
-	*intPointers[2] = 3
-
-	result := FromPointers(intPointers)
-
-	assert.Equal(3, len(result))
-	assert.Equal(1, result[0])
-	assert.Equal(2, result[1])
-	assert.Equal(3, result[2])
-
-	stringPointers := []*string{new(string), new(string), new(string)}
-	*stringPointers[0] = "a"
-	*stringPointers[1] = "b"
-	*stringPointers[2] = "c"
-
-	resultStr := FromPointers(stringPointers)
-
-	assert.Equal(3, len(resultStr))
-	assert.Equal("a", resultStr[0])
-	assert.Equal("b", resultStr[1])
-	assert.Equal("c", resultStr[2])
+	_, ok := <-ch
+	assert.Equal(false, ok)
 }
 
 func TestEncodeByte(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestEncodeByte")
 
 	byteData, _ := EncodeByte("abc")
@@ -383,29 +213,24 @@ func TestEncodeByte(t *testing.T) {
 }
 
 func TestDecodeByte(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestDecodeByte")
 
 	var obj string
 	byteData := []byte{6, 12, 0, 3, 97, 98, 99}
-	err := DecodeByte(byteData, &obj)
-	assert.IsNil(err)
+	DecodeByte(byteData, &obj)
 	assert.Equal("abc", obj)
 }
 
 func TestDeepClone(t *testing.T) {
-	t.Parallel()
-
 	// assert := internal.NewAssert(t, "TestDeepClone")
 
 	type Struct struct {
-		Str   string
-		Int   int
-		Float float64
-		Bool  bool
-		Nil   interface{}
-		// unexported string
+		Str        string
+		Int        int
+		Float      float64
+		Bool       bool
+		Nil        interface{}
+		unexported string
 	}
 
 	cases := []interface{}{
@@ -424,12 +249,12 @@ func TestDeepClone(t *testing.T) {
 			Nil:   nil,
 			// unexported: "can't be cloned",
 		},
-		[]interface{}{1, &Struct{Str: "test"}, Struct{Str: "test2"}},
 	}
 
 	for i, item := range cases {
 		cloned := DeepClone(item)
 
+		t.Log(cloned)
 		if &cloned == &item {
 			t.Fatalf("[TestDeepClone case #%d failed]: equal pointer", i)
 		}
@@ -441,8 +266,6 @@ func TestDeepClone(t *testing.T) {
 }
 
 func TestCopyProperties(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestCopyProperties")
 
 	type Disk struct {
@@ -495,8 +318,6 @@ func TestCopyProperties(t *testing.T) {
 }
 
 func TestToInterface(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestToInterface")
 
 	cases := []reflect.Value{
@@ -526,7 +347,6 @@ func TestToInterface(t *testing.T) {
 }
 
 func TestUtf8ToGbk(t *testing.T) {
-	t.Parallel()
 	assert := internal.NewAssert(t, "TestUtf8ToGbk")
 
 	utf8Data := []byte("hello")
@@ -538,7 +358,6 @@ func TestUtf8ToGbk(t *testing.T) {
 }
 
 func TestGbkToUtf8(t *testing.T) {
-	t.Parallel()
 	assert := internal.NewAssert(t, "TestGbkToUtf8")
 
 	gbkData, err := Utf8ToGbk([]byte("hello"))
@@ -549,6 +368,43 @@ func TestGbkToUtf8(t *testing.T) {
 	assert.Equal("hello", string(utf8Data))
 }
 
+func TestMapToStruct(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestMapToStruct")
+
+	type Address struct {
+		Street string `json:"street"`
+		Number int    `json:"number"`
+	}
+
+	type Person struct {
+		Name  string   `json:"name"`
+		Age   int      `json:"age"`
+		Phone string   `json:"phone"`
+		Addr  *Address `json:"address"`
+	}
+
+	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)
+}
+
 func TestToStdBase64(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestToStdBase64")
@@ -569,7 +425,7 @@ func TestToStdBase64(t *testing.T) {
 	d4, _ := base64.StdEncoding.DecodeString(r4)
 	assert.Equal("11.11", string(d4))
 
-	r5 := ToStdBase64(map[string]any{"name": "duke", "quantity": 1})
+	r5 := ToStdBase64(map[string]interface{}{"name": "duke", "quantity": 1})
 	d5, _ := base64.StdEncoding.DecodeString(r5)
 	assert.Equal("{\"name\":\"duke\",\"quantity\":1}", string(d5))
 
@@ -636,7 +492,7 @@ func TestToUrlBase64(t *testing.T) {
 	d4, _ := base64.URLEncoding.DecodeString(r4)
 	assert.Equal("11.11", string(d4))
 
-	r5 := ToUrlBase64(map[string]any{"name": "duke", "quantity": 1})
+	r5 := ToUrlBase64(map[string]interface{}{"name": "duke", "quantity": 1})
 	d5, _ := base64.URLEncoding.DecodeString(r5)
 	assert.Equal("{\"name\":\"duke\",\"quantity\":1}", string(d5))
 
@@ -707,7 +563,7 @@ func TestToRawStdBase64(t *testing.T) {
 	d4, _ := base64.RawStdEncoding.DecodeString(r4)
 	assert.Equal("11.11", string(d4))
 
-	r5 := ToRawStdBase64(map[string]any{"name": "duke", "quantity": 1})
+	r5 := ToRawStdBase64(map[string]interface{}{"name": "duke", "quantity": 1})
 	d5, _ := base64.RawStdEncoding.DecodeString(r5)
 	assert.Equal("{\"name\":\"duke\",\"quantity\":1}", string(d5))
 
@@ -774,7 +630,7 @@ func TestToRawUrlBase64(t *testing.T) {
 	d4, _ := base64.RawURLEncoding.DecodeString(r4)
 	assert.Equal("11.11", string(d4))
 
-	r5 := ToRawUrlBase64(map[string]any{"name": "duke", "quantity": 1})
+	r5 := ToRawUrlBase64(map[string]interface{}{"name": "duke", "quantity": 1})
 	d5, _ := base64.RawURLEncoding.DecodeString(r5)
 	assert.Equal("{\"name\":\"duke\",\"quantity\":1}", string(d5))
 
@@ -824,83 +680,3 @@ func TestToRawUrlBase64(t *testing.T) {
 	d15, _ := base64.RawURLEncoding.DecodeString(r15)
 	assert.Equal("4+3/4?=", string(d15))
 }
-
-func TestToBigInt(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestToBigInt")
-
-	tests := []struct {
-		name   string
-		input  any
-		want   *big.Int
-		hasErr bool
-	}{
-		{
-			name:  "int",
-			input: 42,
-			want:  big.NewInt(42),
-		},
-		{
-			name:  "int8",
-			input: int8(127),
-			want:  big.NewInt(127),
-		},
-		{
-			name:  "int16",
-			input: int16(32000),
-			want:  big.NewInt(32000),
-		},
-		{
-			name:  "int32",
-			input: int32(123456),
-			want:  big.NewInt(123456),
-		},
-		{
-			name:  "int64",
-			input: int64(987654321),
-			want:  big.NewInt(987654321),
-		},
-		{
-			name:  "uint",
-			input: uint(987654321),
-			want:  big.NewInt(987654321),
-		},
-		{
-			name:  "uint8",
-			input: uint8(255),
-			want:  big.NewInt(255),
-		},
-		{
-			name:  "uint16",
-			input: uint16(65535),
-			want:  big.NewInt(65535),
-		},
-		{
-			name:  "uint32",
-			input: uint32(4294967295),
-			want:  big.NewInt(4294967295),
-		},
-		{
-			name:  "uint64",
-			input: uint64(18446744073709551615),
-			want:  new(big.Int).SetUint64(18446744073709551615),
-		},
-		{
-			name:   "unsupported type",
-			input:  3.14, // Unsupported type
-			hasErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := ToBigInt(tt.input)
-			if (err != nil) != tt.hasErr {
-				t.Errorf("ToBigInt() error = %v, hasErr %v", err, tt.hasErr)
-				return
-			}
-
-			assert.Equal(tt.want, got)
-		})
-	}
-}

cryptor/basic.go

@@ -6,6 +6,7 @@
 package cryptor
 
 import (
+	"bufio"
 	"crypto/hmac"
 	"crypto/md5"
 	"crypto/sha1"
@@ -18,21 +19,18 @@ import (
 	"os"
 )
 
-// Base64StdEncode encode string with base64 encoding.
-// Play: https://go.dev/play/p/VOaUyQUreoK
+// Base64StdEncode encode string with base64 encoding
 func Base64StdEncode(s string) string {
 	return base64.StdEncoding.EncodeToString([]byte(s))
 }
 
-// Base64StdDecode decode a base64 encoded string.
-// Play: https://go.dev/play/p/RWQylnJVgIe
+// Base64StdDecode decode a base64 encoded string
 func Base64StdDecode(s string) string {
 	b, _ := base64.StdEncoding.DecodeString(s)
 	return string(b)
 }
 
-// Md5String return the md5 value of string.
-// Play: https://go.dev/play/p/1bLcVetbTOI
+// Md5String return the md5 value of string
 func Md5String(s string) string {
 	h := md5.New()
 	h.Write([]byte(s))
@@ -40,7 +38,6 @@ func Md5String(s string) string {
 }
 
 // Md5StringWithBase64 return the md5 value of string with base64.
-// Play: https://go.dev/play/p/Lx4gH7Vdr5_y
 func Md5StringWithBase64(s string) string {
 	h := md5.New()
 	h.Write([]byte(s))
@@ -48,7 +45,6 @@ func Md5StringWithBase64(s string) string {
 }
 
 // Md5Byte return the md5 string of byte slice.
-// Play: https://go.dev/play/p/suraalH8lyC
 func Md5Byte(data []byte) string {
 	h := md5.New()
 	h.Write(data)
@@ -56,154 +52,136 @@ func Md5Byte(data []byte) string {
 }
 
 // Md5ByteWithBase64 return the md5 string of byte slice with base64.
-// Play: https://go.dev/play/p/Tcb-Z7LN2ax
 func Md5ByteWithBase64(data []byte) string {
 	h := md5.New()
 	h.Write(data)
 	return base64.StdEncoding.EncodeToString(h.Sum(nil))
 }
 
-// Md5File return the md5 value of file.
+// Md5File return the md5 value of file
 func Md5File(filename string) (string, error) {
+	if fileInfo, err := os.Stat(filename); err != nil {
+		return "", err
+	} else if fileInfo.IsDir() {
+		return "", nil
+	}
+
 	file, err := os.Open(filename)
 	if err != nil {
 		return "", err
 	}
 	defer file.Close()
 
-	stat, err := file.Stat()
-	if err != nil {
-		return "", err
-	}
-	if stat.IsDir() {
-		return "", nil
-	}
-
 	hash := md5.New()
-	buf := make([]byte, 65536) // 64KB
 
-	for {
-		n, err := file.Read(buf)
-		if err != nil && err != io.EOF {
+	chunkSize := 65536
+	for buf, reader := make([]byte, chunkSize), bufio.NewReader(file); ; {
+		n, err := reader.Read(buf)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
 			return "", err
 		}
-		if n > 0 {
-			hash.Write(buf[:n])
-		}
-		if err == io.EOF {
-			break
-		}
+		hash.Write(buf[:n])
 	}
 
-	return fmt.Sprintf("%x", hash.Sum(nil)), nil
+	checksum := fmt.Sprintf("%x", hash.Sum(nil))
+	return checksum, nil
 }
 
-// HmacMd5 return the hmac hash of string use md5.
-// Play: https://go.dev/play/p/uef0q1fz53I
-func HmacMd5(str, key string) string {
+// HmacMd5 return the hmac hash of string use md5
+func HmacMd5(data, key string) string {
 	h := hmac.New(md5.New, []byte(key))
-	h.Write([]byte(str))
+	h.Write([]byte(data))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
 // HmacMd5WithBase64 return the hmac hash of string use md5 with base64.
-// https://go.dev/play/p/UY0ng2AefFC
 func HmacMd5WithBase64(data, key string) string {
 	h := hmac.New(md5.New, []byte(key))
 	h.Write([]byte(data))
 	return base64.StdEncoding.EncodeToString(h.Sum([]byte("")))
 }
 
-// HmacSha1 return the hmac hash of string use sha1.
-// Play: https://go.dev/play/p/1UI4oQ4WXKM
-func HmacSha1(str, key string) string {
+// HmacSha1 return the hmac hash of string use sha1
+func HmacSha1(data, key string) string {
 	h := hmac.New(sha1.New, []byte(key))
-	h.Write([]byte(str))
+	h.Write([]byte(data))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
 // HmacSha1WithBase64 return the hmac hash of string use sha1 with base64.
-// Play: https://go.dev/play/p/47JmmGrnF7B
 func HmacSha1WithBase64(str, key string) string {
 	h := hmac.New(sha1.New, []byte(key))
 	h.Write([]byte(str))
 	return base64.StdEncoding.EncodeToString(h.Sum([]byte("")))
 }
 
-// HmacSha256 return the hmac hash of string use sha256.
-// Play: https://go.dev/play/p/HhpwXxFhhC0
-func HmacSha256(str, key string) string {
+// HmacSha256 return the hmac hash of string use sha256
+func HmacSha256(data, key string) string {
 	h := hmac.New(sha256.New, []byte(key))
-	h.Write([]byte(str))
+	h.Write([]byte(data))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
 // HmacSha256WithBase64 return the hmac hash of string use sha256 with base64.
-// Play: https://go.dev/play/p/EKbkUvPTLwO
 func HmacSha256WithBase64(str, key string) string {
 	h := hmac.New(sha256.New, []byte(key))
 	h.Write([]byte(str))
 	return base64.StdEncoding.EncodeToString(h.Sum([]byte("")))
 }
 
-// HmacSha512 return the hmac hash of string use sha512.
-// Play: https://go.dev/play/p/59Od6m4A0Ud
-func HmacSha512(str, key string) string {
+// HmacSha512 return the hmac hash of string use sha512
+func HmacSha512(data, key string) string {
 	h := hmac.New(sha512.New, []byte(key))
-	h.Write([]byte(str))
+	h.Write([]byte(data))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
 // HmacSha512WithBase64 return the hmac hash of string use sha512 with base64.
-// Play: https://go.dev/play/p/c6dSe3E2ydU
 func HmacSha512WithBase64(str, key string) string {
 	h := hmac.New(sha512.New, []byte(key))
 	h.Write([]byte(str))
 	return base64.StdEncoding.EncodeToString(h.Sum([]byte("")))
 }
 
-// Sha1 return the sha1 value (SHA-1 hash algorithm) of string.
-// Play: https://go.dev/play/p/_m_uoD1deMT
-func Sha1(str string) string {
+// Sha1 return the sha1 value (SHA-1 hash algorithm) of string
+func Sha1(data string) string {
 	sha1 := sha1.New()
-	sha1.Write([]byte(str))
+	sha1.Write([]byte(data))
 	return hex.EncodeToString(sha1.Sum([]byte("")))
 }
 
 // Sha1WithBase64 return the sha1 value (SHA-1 hash algorithm) of base64 string.
-// Play: https://go.dev/play/p/fSyx-Gl2l2-
 func Sha1WithBase64(str string) string {
 	sha1 := sha1.New()
 	sha1.Write([]byte(str))
 	return base64.StdEncoding.EncodeToString(sha1.Sum([]byte("")))
 }
 
-// Sha256 return the sha256 value (SHA256 hash algorithm) of string.
-// Play: https://go.dev/play/p/tU9tfBMIAr1
-func Sha256(str string) string {
+// Sha256 return the sha256 value (SHA256 hash algorithm) of string
+func Sha256(data string) string {
 	sha256 := sha256.New()
-	sha256.Write([]byte(str))
+	sha256.Write([]byte(data))
 	return hex.EncodeToString(sha256.Sum([]byte("")))
 }
 
 // Sha256WithBase64 return the sha256 value (SHA256 hash algorithm) of base64 string.
-// Play: https://go.dev/play/p/85IXJHIal1k
 func Sha256WithBase64(str string) string {
 	sha256 := sha256.New()
 	sha256.Write([]byte(str))
 	return base64.StdEncoding.EncodeToString(sha256.Sum([]byte("")))
 }
 
-// Sha512 return the sha512 value (SHA512 hash algorithm) of string.
-// Play: https://go.dev/play/p/3WsvLYZxsHa
-func Sha512(str string) string {
+// Sha512 return the sha512 value (SHA512 hash algorithm) of string
+func Sha512(data string) string {
 	sha512 := sha512.New()
-	sha512.Write([]byte(str))
+	sha512.Write([]byte(data))
 	return hex.EncodeToString(sha512.Sum([]byte("")))
 }
 
 // Sha512WithBase64 return the sha512 value (SHA512 hash algorithm) of base64 string.
-// Play: https://go.dev/play/p/q_fY2rA-k5I
 func Sha512WithBase64(str string) string {
 	sha512 := sha512.New()
 	sha512.Write([]byte(str))

cryptor/basic_test.go

@@ -3,55 +3,41 @@ package cryptor
 import (
 	"testing"
 
-	"github.com/duke-git/lancet/v2/internal"
+	"github.com/duke-git/lancet/internal"
 )
 
 func TestBase64StdEncode(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestBase64StdEncode")
 	assert.Equal("aGVsbG8gd29ybGQ=", Base64StdEncode("hello world"))
 }
 
 func TestBase64StdDecode(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestBase64StdDecode")
 	assert.Equal("hello world", Base64StdDecode("aGVsbG8gd29ybGQ="))
 }
 
 func TestMd5String(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestMd5String")
 	assert.Equal("5d41402abc4b2a76b9719d911017c592", Md5String("hello"))
 }
 
 func TestMd5StringWithBase64(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestMd5StringWithBase64")
 	assert.Equal("XUFAKrxLKna5cZ2REBfFkg==", Md5StringWithBase64("hello"))
 }
 
 func TestMd5Byte(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestMd5Byte")
 	data := []byte{'a'}
 	assert.Equal("0cc175b9c0f1b6a831c399e269772661", Md5Byte(data))
 }
 
 func TestMd5ByteWithBase64(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestMd5ByteWithBase64")
 	assert.Equal("XUFAKrxLKna5cZ2REBfFkg==", Md5ByteWithBase64([]byte("hello")))
 }
 
 func TestMd5File(t *testing.T) {
-	t.Parallel()
-
 	fileMd5, err := Md5File("./basic.go")
 	assert := internal.NewAssert(t, "TestMd5File")
 	assert.IsNotNil(fileMd5)
@@ -59,22 +45,16 @@ func TestMd5File(t *testing.T) {
 }
 
 func TestHmacMd5(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestHmacMd5")
 	assert.Equal("5f4c9faaff0a1ad3007d9ddc06abe36d", HmacMd5("hello world", "12345"))
 }
 
 func TestHmacMd5WithBase64(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestHmacMd5WithBase64")
 	assert.Equal("6DQwbquJLYclJdSRinpjmg==", HmacMd5WithBase64("hello", "12345"))
 }
 
 func TestHmacSha1(t *testing.T) {
-	t.Parallel()
-
 	s := "hello world"
 	key := "12345"
 	hmacSha1 := HmacSha1(s, key)
@@ -85,8 +65,6 @@ func TestHmacSha1(t *testing.T) {
 }
 
 func TestHmacSha1WithBase64(t *testing.T) {
-	t.Parallel()
-
 	s := "hello"
 	key := "12345"
 	hmacSha1 := HmacSha1WithBase64(s, key)
@@ -97,11 +75,9 @@ func TestHmacSha1WithBase64(t *testing.T) {
 }
 
 func TestHmacSha256(t *testing.T) {
-	t.Parallel()
-
-	str := "hello world"
+	s := "hello world"
 	key := "12345"
-	hmacSha256 := HmacSha256(str, key)
+	hmacSha256 := HmacSha256(s, key)
 	expected := "9dce2609f2d67d41f74c7f9efc8ccd44370d41ad2de52982627588dfe7289ab8"
 
 	assert := internal.NewAssert(t, "TestHmacSha256")
@@ -109,8 +85,6 @@ func TestHmacSha256(t *testing.T) {
 }
 
 func TestHmacSha256WithBase64(t *testing.T) {
-	t.Parallel()
-
 	str := "hello"
 	key := "12345"
 	hms := HmacSha256WithBase64(str, key)
@@ -121,8 +95,6 @@ func TestHmacSha256WithBase64(t *testing.T) {
 }
 
 func TestHmacSha512(t *testing.T) {
-	t.Parallel()
-
 	s := "hello world"
 	key := "12345"
 	hmacSha512 := HmacSha512(s, key)
@@ -133,8 +105,6 @@ func TestHmacSha512(t *testing.T) {
 }
 
 func TestHmacSha512WithBase64(t *testing.T) {
-	t.Parallel()
-
 	str := "hello"
 	key := "12345"
 	hms := HmacSha512WithBase64(str, key)
@@ -145,8 +115,6 @@ func TestHmacSha512WithBase64(t *testing.T) {
 }
 
 func TestSha1(t *testing.T) {
-	t.Parallel()
-
 	s := "hello world"
 	sha1 := Sha1(s)
 	expected := "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"
@@ -156,8 +124,6 @@ func TestSha1(t *testing.T) {
 }
 
 func TestSha1WithBase64(t *testing.T) {
-	t.Parallel()
-
 	str := Sha1WithBase64("hello")
 	expected := "qvTGHdzF6KLavt4PO0gs2a6pQ00="
 
@@ -166,8 +132,6 @@ func TestSha1WithBase64(t *testing.T) {
 }
 
 func TestSha256(t *testing.T) {
-	t.Parallel()
-
 	s := "hello world"
 	sha256 := Sha256(s)
 	expected := "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
@@ -177,8 +141,6 @@ func TestSha256(t *testing.T) {
 }
 
 func TestSha256WithBase64(t *testing.T) {
-	t.Parallel()
-
 	str := Sha256WithBase64("hello")
 	expected := "LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ="
 
@@ -187,8 +149,6 @@ func TestSha256WithBase64(t *testing.T) {
 }
 
 func TestSha512(t *testing.T) {
-	t.Parallel()
-
 	s := "hello world"
 	sha512 := Sha512(s)
 	expected := "309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f"
@@ -198,8 +158,6 @@ func TestSha512(t *testing.T) {
 }
 
 func TestSha512WithBase64(t *testing.T) {
-	t.Parallel()
-
 	str := Sha512WithBase64("hello")
 	expected := "m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw=="
 

cryptor/crypto.go

@@ -8,7 +8,6 @@ package cryptor
 
 import (
 	"bytes"
-	"crypto"
 	"crypto/aes"
 	"crypto/cipher"
 	"crypto/des"
@@ -22,145 +21,92 @@ import (
 )
 
 // AesEcbEncrypt encrypt data with key use AES ECB algorithm
-// len(key) should be 16, 24 or 32.
-// Play: https://go.dev/play/p/jT5irszHx-j
+// len(key) should be 16, 24 or 32
 func AesEcbEncrypt(data, key []byte) []byte {
-	if !isAesKeyLengthValid(len(key)) {
-		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
+	size := len(key)
+	if size != 16 && size != 24 && size != 32 {
+		panic("key length shoud be 16 or 24 or 32")
 	}
 
-	blockSize := aes.BlockSize
-	dataLen := len(data)
-	padding := blockSize - (dataLen % blockSize)
-	paddedLen := dataLen + padding
+	cipher, _ := aes.NewCipher(generateAesKey(key, size))
+	length := (len(data) + aes.BlockSize) / aes.BlockSize
 
-	paddedData := make([]byte, paddedLen)
-	copy(paddedData, data)
+	plain := make([]byte, length*aes.BlockSize)
 
-	for i := dataLen; i < paddedLen; i++ {
-		paddedData[i] = byte(padding)
+	copy(plain, data)
+
+	pad := byte(len(plain) - len(data))
+	for i := len(data); i < len(plain); i++ {
+		plain[i] = pad
 	}
 
-	cipher, err := aes.NewCipher(generateAesKey(key, len(key)))
-	if err != nil {
-		panic("aes: failed to create cipher: " + err.Error())
-	}
-
-	encrypted := make([]byte, paddedLen)
-	for bs := 0; bs < paddedLen; bs += blockSize {
-		cipher.Encrypt(encrypted[bs:], paddedData[bs:])
+	encrypted := make([]byte, len(plain))
+	for bs, be := 0, cipher.BlockSize(); bs <= len(data); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
+		cipher.Encrypt(encrypted[bs:be], plain[bs:be])
 	}
 
 	return encrypted
 }
 
 // AesEcbDecrypt decrypt data with key use AES ECB algorithm
-// len(key) should be 16, 24 or 32.
-// Play: https://go.dev/play/p/jT5irszHx-j
+// len(key) should be 16, 24 or 32
 func AesEcbDecrypt(encrypted, key []byte) []byte {
-	if !isAesKeyLengthValid(len(key)) {
-		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
-	}
-
-	blockSize := aes.BlockSize
-	if len(encrypted)%blockSize != 0 {
-		panic("aes: encrypted data length is not a multiple of block size")
-	}
-
-	cipher, err := aes.NewCipher(generateAesKey(key, len(key)))
-	if err != nil {
-		panic("aes: failed to create cipher: " + err.Error())
+	size := len(key)
+	if size != 16 && size != 24 && size != 32 {
+		panic("key length shoud be 16 or 24 or 32")
 	}
 
+	cipher, _ := aes.NewCipher(generateAesKey(key, size))
 	decrypted := make([]byte, len(encrypted))
-	for i := 0; i < len(encrypted); i += blockSize {
-		cipher.Decrypt(decrypted[i:], encrypted[i:])
+
+	for bs, be := 0, cipher.BlockSize(); bs < len(encrypted); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
+		cipher.Decrypt(decrypted[bs:be], encrypted[bs:be])
 	}
 
-	if len(decrypted) == 0 {
-		return nil
-	}
-	padding := int(decrypted[len(decrypted)-1])
-	if padding == 0 || padding > blockSize {
-		panic("aes: invalid PKCS#7 padding")
-	}
-	for i := len(decrypted) - padding; i < len(decrypted); i++ {
-		if decrypted[i] != byte(padding) {
-			panic("aes: invalid PKCS#7 padding content")
-		}
+	trim := 0
+	if len(decrypted) > 0 {
+		trim = len(decrypted) - int(decrypted[len(decrypted)-1])
 	}
 
-	return decrypted[:len(decrypted)-padding]
+	return decrypted[:trim]
 }
 
 // AesCbcEncrypt encrypt data with key use AES CBC algorithm
-// len(key) should be 16, 24 or 32.
-// Play: https://go.dev/play/p/IOq_g8_lKZD
+// len(key) should be 16, 24 or 32
 func AesCbcEncrypt(data, key []byte) []byte {
-	if !isAesKeyLengthValid(len(key)) {
-		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
-	}
+	block, _ := aes.NewCipher(key)
+	data = pkcs7Padding(data, block.BlockSize())
 
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		panic("aes: failed to create cipher: " + err.Error())
-	}
-
-	padding := aes.BlockSize - len(data)%aes.BlockSize
-	padded := append(data, bytes.Repeat([]byte{byte(padding)}, padding)...)
-
-	iv := make([]byte, aes.BlockSize)
+	encrypted := make([]byte, aes.BlockSize+len(data))
+	iv := encrypted[:aes.BlockSize]
 	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic("aes: failed to generate IV: " + err.Error())
+		panic(err)
 	}
 
-	encrypted := make([]byte, len(padded))
 	mode := cipher.NewCBCEncrypter(block, iv)
-	mode.CryptBlocks(encrypted, padded)
+	mode.CryptBlocks(encrypted[aes.BlockSize:], data)
 
-	return append(iv, encrypted...)
+	return encrypted
 }
 
 // AesCbcDecrypt decrypt data with key use AES CBC algorithm
-// len(key) should be 16, 24 or 32.
-// Play: https://go.dev/play/p/IOq_g8_lKZD
+// len(key) should be 16, 24 or 32
 func AesCbcDecrypt(encrypted, key []byte) []byte {
-	if !isAesKeyLengthValid(len(key)) {
-		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
-	}
-
-	if len(encrypted) < aes.BlockSize {
-		panic("aes: ciphertext too short")
-	}
-
-	if len(encrypted)%aes.BlockSize != 0 {
-		panic("aes: ciphertext is not a multiple of the block size")
-	}
+	block, _ := aes.NewCipher(key)
 
 	iv := encrypted[:aes.BlockSize]
-	ciphertext := encrypted[aes.BlockSize:]
+	encrypted = encrypted[aes.BlockSize:]
 
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		panic("aes: failed to create cipher: " + err.Error())
-	}
-
-	decrypted := make([]byte, len(ciphertext))
 	mode := cipher.NewCBCDecrypter(block, iv)
-	mode.CryptBlocks(decrypted, ciphertext)
+	mode.CryptBlocks(encrypted, encrypted)
 
-	return pkcs7UnPadding(decrypted)
+	decrypted := pkcs7UnPadding(encrypted)
+	return decrypted
 }
 
 // AesCtrCrypt encrypt data with key use AES CTR algorithm
-// len(key) should be 16, 24 or 32.
-// Play: https://go.dev/play/p/SpaZO0-5Nsp
-// deprecated: use AesCtrEncrypt and AesCtrDecrypt instead.
+// len(key) should be 16, 24 or 32
 func AesCtrCrypt(data, key []byte) []byte {
-	if !isAesKeyLengthValid(len(key)) {
-		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
-	}
-
 	block, _ := aes.NewCipher(key)
 
 	iv := bytes.Repeat([]byte("1"), block.BlockSize())
@@ -172,328 +118,156 @@ func AesCtrCrypt(data, key []byte) []byte {
 	return dst
 }
 
-// AesCtrEncrypt encrypt data with key use AES CTR algorithm
-// len(key) should be 16, 24 or 32.
-// Play: https://go.dev/play/p/x6pjPAvThRz
-func AesCtrEncrypt(data, key []byte) []byte {
-	if !isAesKeyLengthValid(len(key)) {
-		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
-	}
-
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		panic("aes: failed to create cipher: " + err.Error())
-	}
-
-	iv := make([]byte, aes.BlockSize)
-	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic("aes: failed to generate IV: " + err.Error())
-	}
-
-	stream := cipher.NewCTR(block, iv)
-	ciphertext := make([]byte, len(data))
-	stream.XORKeyStream(ciphertext, data)
-
-	return append(iv, ciphertext...)
-}
-
-// AesCtrDecrypt decrypt data with key use AES CTR algorithm
-// len(key) should be 16, 24 or 32.
-// Play: https://go.dev/play/p/x6pjPAvThRz
-func AesCtrDecrypt(encrypted, key []byte) []byte {
-	if !isAesKeyLengthValid(len(key)) {
-		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
-	}
-	if len(encrypted) < aes.BlockSize {
-		panic("aes: invalid ciphertext length")
-	}
-
-	iv := encrypted[:aes.BlockSize]
-	ciphertext := encrypted[aes.BlockSize:]
-
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		panic("aes: failed to create cipher: " + err.Error())
-	}
-
-	stream := cipher.NewCTR(block, iv)
-	plaintext := make([]byte, len(ciphertext))
-	stream.XORKeyStream(plaintext, ciphertext)
-
-	return plaintext
-}
-
 // AesCfbEncrypt encrypt data with key use AES CFB algorithm
-// len(key) should be 16, 24 or 32.
-// Play: https://go.dev/play/p/tfkF10B13kH
+// len(key) should be 16, 24 or 32
 func AesCfbEncrypt(data, key []byte) []byte {
-	if !isAesKeyLengthValid(len(key)) {
-		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
-	}
-
 	block, err := aes.NewCipher(key)
 	if err != nil {
-		panic("aes: failed to create cipher: " + err.Error())
+		panic(err)
 	}
 
-	iv := make([]byte, aes.BlockSize)
+	encrypted := make([]byte, aes.BlockSize+len(data))
+	iv := encrypted[:aes.BlockSize]
 	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic("aes: failed to generate IV: " + err.Error())
+		panic(err)
 	}
 
-	ciphertext := make([]byte, len(data))
 	stream := cipher.NewCFBEncrypter(block, iv)
-	stream.XORKeyStream(ciphertext, data)
-
-	return append(iv, ciphertext...)
+	stream.XORKeyStream(encrypted[aes.BlockSize:], data)
+	return encrypted
 }
 
 // AesCfbDecrypt decrypt data with key use AES CFB algorithm
-// len(encrypted) should be great than 16, len(key) should be 16, 24 or 32.
-// Play: https://go.dev/play/p/tfkF10B13kH
+// len(encrypted) should be great than 16, len(key) should be 16, 24 or 32
 func AesCfbDecrypt(encrypted, key []byte) []byte {
-	if !isAesKeyLengthValid(len(key)) {
-		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
-	}
-
+	block, _ := aes.NewCipher(key)
 	if len(encrypted) < aes.BlockSize {
-		panic("aes: encrypted data too short")
+		panic("encrypted data is too short")
 	}
-
 	iv := encrypted[:aes.BlockSize]
-	ciphertext := encrypted[aes.BlockSize:]
+	encrypted = encrypted[aes.BlockSize:]
 
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		panic("aes: failed to create cipher: " + err.Error())
-	}
-
-	plaintext := make([]byte, len(ciphertext))
 	stream := cipher.NewCFBDecrypter(block, iv)
-	stream.XORKeyStream(plaintext, ciphertext)
-
-	return plaintext
+	stream.XORKeyStream(encrypted, encrypted)
+	return encrypted
 }
 
 // AesOfbEncrypt encrypt data with key use AES OFB algorithm
-// len(key) should be 16, 24 or 32.
-// Play: https://go.dev/play/p/VtHxtkUj-3F
+// len(key) should be 16, 24 or 32
 func AesOfbEncrypt(data, key []byte) []byte {
-	if !isAesKeyLengthValid(len(key)) {
-		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
-	}
-
 	block, err := aes.NewCipher(key)
 	if err != nil {
-		panic("aes: failed to create cipher: " + err.Error())
+		panic(err)
 	}
-
-	iv := make([]byte, aes.BlockSize)
+	data = pkcs7Padding(data, aes.BlockSize)
+	encrypted := make([]byte, aes.BlockSize+len(data))
+	iv := encrypted[:aes.BlockSize]
 	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic("aes: failed to generate IV: " + err.Error())
+		panic(err)
 	}
 
-	ciphertext := make([]byte, len(data))
 	stream := cipher.NewOFB(block, iv)
-	stream.XORKeyStream(ciphertext, data)
-
-	return append(iv, ciphertext...)
+	stream.XORKeyStream(encrypted[aes.BlockSize:], data)
+	return encrypted
 }
 
 // AesOfbDecrypt decrypt data with key use AES OFB algorithm
-// len(key) should be 16, 24 or 32.
-// Play: https://go.dev/play/p/VtHxtkUj-3F
+// len(key) should be 16, 24 or 32
 func AesOfbDecrypt(data, key []byte) []byte {
-	if !isAesKeyLengthValid(len(key)) {
-		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
-	}
-
-	if len(data) < aes.BlockSize {
-		panic("aes: encrypted data too short")
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic(err)
 	}
 
 	iv := data[:aes.BlockSize]
-	ciphertext := data[aes.BlockSize:]
-
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		panic("aes: failed to create cipher: " + err.Error())
+	data = data[aes.BlockSize:]
+	if len(data)%aes.BlockSize != 0 {
+		return nil
 	}
 
-	plaintext := make([]byte, len(ciphertext))
-	stream := cipher.NewOFB(block, iv)
-	stream.XORKeyStream(plaintext, ciphertext)
+	decrypted := make([]byte, len(data))
+	mode := cipher.NewOFB(block, iv)
+	mode.XORKeyStream(decrypted, data)
 
-	return plaintext
-}
-
-// AesGcmEncrypt encrypt data with key use AES GCM algorithm
-// Play: https://go.dev/play/p/rUt0-DmsPCs
-func AesGcmEncrypt(data, key []byte) []byte {
-	if !isAesKeyLengthValid(len(key)) {
-		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
-	}
-
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		panic("aes: failed to create cipher: " + err.Error())
-	}
-
-	gcm, err := cipher.NewGCM(block)
-	if err != nil {
-		panic("aes: failed to create GCM: " + err.Error())
-	}
-
-	nonce := make([]byte, gcm.NonceSize())
-	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
-		panic("aes: failed to generate nonce: " + err.Error())
-	}
-
-	ciphertext := gcm.Seal(nil, nonce, data, nil)
-
-	return append(nonce, ciphertext...)
-}
-
-// AesGcmDecrypt decrypt data with key use AES GCM algorithm
-// Play: https://go.dev/play/p/rUt0-DmsPCs
-func AesGcmDecrypt(data, key []byte) []byte {
-	if !isAesKeyLengthValid(len(key)) {
-		panic("aes: invalid key length (must be 16, 24, or 32 bytes)")
-	}
-
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		panic("aes: failed to create cipher: " + err.Error())
-	}
-
-	gcm, err := cipher.NewGCM(block)
-	if err != nil {
-		panic("aes: failed to create GCM: " + err.Error())
-	}
-
-	nonceSize := gcm.NonceSize()
-	if len(data) < nonceSize {
-		panic("aes: ciphertext too short")
-	}
-
-	nonce, ciphertext := data[:nonceSize], data[nonceSize:]
-	plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
-	if err != nil {
-		panic("aes: decryption failed: " + err.Error())
-	}
-
-	return plaintext
+	decrypted = pkcs7UnPadding(decrypted)
+	return decrypted
 }
 
 // DesEcbEncrypt encrypt data with key use DES ECB algorithm
-// len(key) should be 8.
-// Play: https://go.dev/play/p/8qivmPeZy4P
+// len(key) should be 8
 func DesEcbEncrypt(data, key []byte) []byte {
-	cipher, err := des.NewCipher(generateDesKey(key))
-	if err != nil {
-		panic("des: failed to create cipher: " + err.Error())
+	cipher, _ := des.NewCipher(generateDesKey(key))
+	length := (len(data) + des.BlockSize) / des.BlockSize
+	plain := make([]byte, length*des.BlockSize)
+	copy(plain, data)
+
+	pad := byte(len(plain) - len(data))
+	for i := len(data); i < len(plain); i++ {
+		plain[i] = pad
 	}
 
-	blockSize := cipher.BlockSize()
-	padded := pkcs5Padding(data, blockSize)
-	encrypted := make([]byte, len(padded))
-
-	for i := 0; i < len(padded); i += blockSize {
-		cipher.Encrypt(encrypted[i:], padded[i:])
+	encrypted := make([]byte, len(plain))
+	for bs, be := 0, cipher.BlockSize(); bs <= len(data); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
+		cipher.Encrypt(encrypted[bs:be], plain[bs:be])
 	}
 
 	return encrypted
 }
 
 // DesEcbDecrypt decrypt data with key use DES ECB algorithm
-// len(key) should be 8.
-// Play: https://go.dev/play/p/8qivmPeZy4P
+// len(key) should be 8
 func DesEcbDecrypt(encrypted, key []byte) []byte {
-	cipher, err := des.NewCipher(generateDesKey(key))
-	if err != nil {
-		panic("des: failed to create cipher: " + err.Error())
-	}
-
-	blockSize := cipher.BlockSize()
-	if len(encrypted)%blockSize != 0 {
-		panic("des: invalid encrypted data length")
-	}
-
+	cipher, _ := des.NewCipher(generateDesKey(key))
 	decrypted := make([]byte, len(encrypted))
-	for i := 0; i < len(encrypted); i += blockSize {
-		cipher.Decrypt(decrypted[i:], encrypted[i:])
+
+	for bs, be := 0, cipher.BlockSize(); bs < len(encrypted); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
+		cipher.Decrypt(decrypted[bs:be], encrypted[bs:be])
 	}
 
-	// Remove padding
-	return pkcs5UnPadding(decrypted)
+	trim := 0
+	if len(decrypted) > 0 {
+		trim = len(decrypted) - int(decrypted[len(decrypted)-1])
+	}
+
+	return decrypted[:trim]
 }
 
 // DesCbcEncrypt encrypt data with key use DES CBC algorithm
-// len(key) should be 8.
-// Play: https://go.dev/play/p/4cC4QvWfe3_1
+// len(key) should be 8
 func DesCbcEncrypt(data, key []byte) []byte {
-	if len(key) != 8 {
-		panic("des: key length must be 8 bytes")
-	}
-
-	block, err := des.NewCipher(key)
-	if err != nil {
-		panic("des: failed to create cipher: " + err.Error())
-	}
-
-	blockSize := block.BlockSize()
-	data = pkcs7Padding(data, blockSize)
-
-	encrypted := make([]byte, blockSize+len(data))
-	iv := encrypted[:blockSize]
+	block, _ := des.NewCipher(key)
+	data = pkcs7Padding(data, block.BlockSize())
 
+	encrypted := make([]byte, des.BlockSize+len(data))
+	iv := encrypted[:des.BlockSize]
 	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic("des: failed to generate IV: " + err.Error())
+		panic(err)
 	}
 
 	mode := cipher.NewCBCEncrypter(block, iv)
-	mode.CryptBlocks(encrypted[blockSize:], data)
+	mode.CryptBlocks(encrypted[des.BlockSize:], data)
 
 	return encrypted
 }
 
 // DesCbcDecrypt decrypt data with key use DES CBC algorithm
-// len(key) should be 8.
-// Play: https://go.dev/play/p/4cC4QvWfe3_1
+// len(key) should be 8
 func DesCbcDecrypt(encrypted, key []byte) []byte {
-	if len(key) != 8 {
-		panic("des: key length must be 8 bytes")
-	}
+	block, _ := des.NewCipher(key)
 
-	block, err := des.NewCipher(key)
-	if err != nil {
-		panic("des: failed to create cipher: " + err.Error())
-	}
-
-	blockSize := block.BlockSize()
-	if len(encrypted) < blockSize || len(encrypted)%blockSize != 0 {
-		panic("des: invalid encrypted data length")
-	}
-
-	iv := encrypted[:blockSize]
-	ciphertext := encrypted[blockSize:]
+	iv := encrypted[:des.BlockSize]
+	encrypted = encrypted[des.BlockSize:]
 
 	mode := cipher.NewCBCDecrypter(block, iv)
-	mode.CryptBlocks(ciphertext, ciphertext)
+	mode.CryptBlocks(encrypted, encrypted)
 
-	return pkcs7UnPadding(ciphertext)
+	decrypted := pkcs7UnPadding(encrypted)
+	return decrypted
 }
 
 // DesCtrCrypt encrypt data with key use DES CTR algorithm
-// len(key) should be 8.
-// Play: https://go.dev/play/p/9-T6OjKpcdw
-// deprecated: use DesCtrEncrypt and DesCtrDecrypt instead.
+// len(key) should be 8
 func DesCtrCrypt(data, key []byte) []byte {
-	size := len(key)
-	if size != 8 {
-		panic("key length shoud be 8")
-	}
-
 	block, _ := des.NewCipher(key)
 
 	iv := bytes.Repeat([]byte("1"), block.BlockSize())
@@ -505,83 +279,19 @@ func DesCtrCrypt(data, key []byte) []byte {
 	return dst
 }
 
-// DesCtrEncrypt encrypt data with key use DES CTR algorithm
-// len(key) should be 8.
-// Play: https://go.dev/play/p/S6p_WHCgH1d
-func DesCtrEncrypt(data, key []byte) []byte {
-	if len(key) != 8 {
-		panic("des: key length must be 8 bytes")
-	}
-
-	block, err := des.NewCipher(key)
-	if err != nil {
-		panic("des: failed to create cipher: " + err.Error())
-	}
-
-	iv := make([]byte, block.BlockSize())
-	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic("des: failed to generate IV: " + err.Error())
-	}
-
-	stream := cipher.NewCTR(block, iv)
-
-	encrypted := make([]byte, len(data))
-	stream.XORKeyStream(encrypted, data)
-
-	// 返回前缀包含 IV，便于解密
-	return append(iv, encrypted...)
-}
-
-// DesCtrDecrypt decrypt data with key use DES CTR algorithm
-// len(key) should be 8.
-// Play: https://go.dev/play/p/S6p_WHCgH1d
-func DesCtrDecrypt(encrypted, key []byte) []byte {
-	if len(key) != 8 {
-		panic("des: key length must be 8 bytes")
-	}
-
-	block, err := des.NewCipher(key)
-	if err != nil {
-		panic("des: failed to create cipher: " + err.Error())
-	}
-
-	blockSize := block.BlockSize()
-	if len(encrypted) < blockSize {
-		panic("des: ciphertext too short")
-	}
-
-	iv := encrypted[:blockSize]
-	ciphertext := encrypted[blockSize:]
-
-	stream := cipher.NewCTR(block, iv)
-
-	decrypted := make([]byte, len(ciphertext))
-	stream.XORKeyStream(decrypted, ciphertext)
-
-	return decrypted
-}
-
 // DesCfbEncrypt encrypt data with key use DES CFB algorithm
-// len(key) should be 8.
-// Play: https://go.dev/play/p/y-eNxcFBlxL
+// len(key) should be 8
 func DesCfbEncrypt(data, key []byte) []byte {
-	if len(key) != 8 {
-		panic("des: key length must be 8 bytes")
-	}
-
 	block, err := des.NewCipher(key)
 	if err != nil {
-		panic("des: failed to create cipher: " + err.Error())
-	}
-
-	iv := make([]byte, des.BlockSize)
-	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic("des: failed to generate IV: " + err.Error())
+		panic(err)
 	}
 
 	encrypted := make([]byte, des.BlockSize+len(data))
-
-	copy(encrypted[:des.BlockSize], iv)
+	iv := encrypted[:des.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic(err)
+	}
 
 	stream := cipher.NewCFBEncrypter(block, iv)
 	stream.XORKeyStream(encrypted[des.BlockSize:], data)
@@ -590,53 +300,34 @@ func DesCfbEncrypt(data, key []byte) []byte {
 }
 
 // DesCfbDecrypt decrypt data with key use DES CFB algorithm
-// len(encrypted) should be great than 16, len(key) should be 8.
-// Play: https://go.dev/play/p/y-eNxcFBlxL
+// len(encrypted) should be great than 16, len(key) should be 8
 func DesCfbDecrypt(encrypted, key []byte) []byte {
-	if len(key) != 8 {
-		panic("des: key length must be 8 bytes")
-	}
-
-	block, err := des.NewCipher(key)
-	if err != nil {
-		panic("des: failed to create cipher: " + err.Error())
-	}
-
+	block, _ := des.NewCipher(key)
 	if len(encrypted) < des.BlockSize {
-		panic("des: encrypted data too short")
+		panic("encrypted data is too short")
 	}
-
 	iv := encrypted[:des.BlockSize]
-	ciphertext := encrypted[des.BlockSize:]
+	encrypted = encrypted[des.BlockSize:]
 
 	stream := cipher.NewCFBDecrypter(block, iv)
-	stream.XORKeyStream(ciphertext, ciphertext)
+	stream.XORKeyStream(encrypted, encrypted)
 
-	return ciphertext
+	return encrypted
 }
 
 // DesOfbEncrypt encrypt data with key use DES OFB algorithm
-// len(key) should be 8.
-// Play: https://go.dev/play/p/74KmNadjN1J
+// len(key) should be 16, 24 or 32
 func DesOfbEncrypt(data, key []byte) []byte {
-	if len(key) != 8 {
-		panic("des: key length must be 8 bytes")
-	}
-
 	block, err := des.NewCipher(key)
 	if err != nil {
-		panic("des: failed to create cipher: " + err.Error())
+		panic(err)
 	}
-
 	data = pkcs7Padding(data, des.BlockSize)
-
-	iv := make([]byte, des.BlockSize)
-	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic("des: failed to generate IV: " + err.Error())
-	}
-
 	encrypted := make([]byte, des.BlockSize+len(data))
-	copy(encrypted[:des.BlockSize], iv)
+	iv := encrypted[:des.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic(err)
+	}
 
 	stream := cipher.NewOFB(block, iv)
 	stream.XORKeyStream(encrypted[des.BlockSize:], data)
@@ -645,36 +336,30 @@ func DesOfbEncrypt(data, key []byte) []byte {
 }
 
 // DesOfbDecrypt decrypt data with key use DES OFB algorithm
-// len(key) should be 8.
-// Play: https://go.dev/play/p/74KmNadjN1J
+// len(key) should be 8
 func DesOfbDecrypt(data, key []byte) []byte {
-	if len(key) != 8 {
-		panic("des: key length must be 8 bytes")
-	}
-
 	block, err := des.NewCipher(key)
 	if err != nil {
-		panic("des: failed to create cipher: " + err.Error())
-	}
-
-	if len(data) < des.BlockSize {
-		panic("des: encrypted data too short")
+		panic(err)
 	}
 
 	iv := data[:des.BlockSize]
-	ciphertext := data[des.BlockSize:]
+	data = data[des.BlockSize:]
+	if len(data)%des.BlockSize != 0 {
+		return nil
+	}
 
-	stream := cipher.NewOFB(block, iv)
-	decrypted := make([]byte, len(ciphertext))
-	stream.XORKeyStream(decrypted, ciphertext)
+	decrypted := make([]byte, len(data))
+	mode := cipher.NewOFB(block, iv)
+	mode.XORKeyStream(decrypted, data)
 
 	decrypted = pkcs7UnPadding(decrypted)
 
 	return decrypted
 }
 
-// GenerateRsaKey create rsa private and public pemo file.
-// Play: https://go.dev/play/p/zutRHrDqs0X
+// GenerateRsaKey make  a rsa private key, and return key file name
+// Generated key file is `rsa_private.pem` and `rsa_public.pem` in current path
 func GenerateRsaKey(keySize int, priKeyFile, pubKeyFile string) error {
 	// private key
 	privateKey, err := rsa.GenerateKey(rand.Reader, keySize)
@@ -689,15 +374,12 @@ func GenerateRsaKey(keySize int, priKeyFile, pubKeyFile string) error {
 		Bytes: derText,
 	}
 
+	//file,err := os.Create("rsa_private.pem")
 	file, err := os.Create(priKeyFile)
 	if err != nil {
 		panic(err)
 	}
-	err = pem.Encode(file, &block)
-	if err != nil {
-		return err
-	}
-
+	pem.Encode(file, &block)
 	file.Close()
 
 	// public key
@@ -713,23 +395,18 @@ func GenerateRsaKey(keySize int, priKeyFile, pubKeyFile string) error {
 		Bytes: derpText,
 	}
 
+	//file,err = os.Create("rsa_public.pem")
 	file, err = os.Create(pubKeyFile)
 	if err != nil {
 		return err
 	}
-
-	err = pem.Encode(file, &block)
-	if err != nil {
-		return err
-	}
-
+	pem.Encode(file, &block)
 	file.Close()
 
 	return nil
 }
 
-// RsaEncrypt encrypt data with ras algorithm.
-// Play: https://go.dev/play/p/7_zo6mrx-eX
+// RsaEncrypt encrypt data with ras algorithm
 func RsaEncrypt(data []byte, pubKeyFileName string) []byte {
 	file, err := os.Open(pubKeyFileName)
 	if err != nil {
@@ -741,11 +418,7 @@ func RsaEncrypt(data []byte, pubKeyFileName string) []byte {
 	}
 	defer file.Close()
 	buf := make([]byte, fileInfo.Size())
-
-	_, err = file.Read(buf)
-	if err != nil {
-		panic(err)
-	}
+	file.Read(buf)
 
 	block, _ := pem.Decode(buf)
 
@@ -759,12 +432,10 @@ func RsaEncrypt(data []byte, pubKeyFileName string) []byte {
 	if err != nil {
 		panic(err)
 	}
-
 	return cipherText
 }
 
-// RsaDecrypt decrypt data with ras algorithm.
-// Play: https://go.dev/play/p/7_zo6mrx-eX
+// RsaDecrypt decrypt data with ras algorithm
 func RsaDecrypt(data []byte, privateKeyFileName string) []byte {
 	file, err := os.Open(privateKeyFileName)
 	if err != nil {
@@ -776,11 +447,7 @@ func RsaDecrypt(data []byte, privateKeyFileName string) []byte {
 	}
 	buf := make([]byte, fileInfo.Size())
 	defer file.Close()
-
-	_, err = file.Read(buf)
-	if err != nil {
-		panic(err)
-	}
+	file.Read(buf)
 
 	block, _ := pem.Decode(buf)
 
@@ -793,19 +460,16 @@ func RsaDecrypt(data []byte, privateKeyFileName string) []byte {
 	if err != nil {
 		panic(err)
 	}
-
 	return plainText
 }
 
 // GenerateRsaKeyPair create rsa private and public key.
-// Play: https://go.dev/play/p/sSVmkfENKMz
 func GenerateRsaKeyPair(keySize int) (*rsa.PrivateKey, *rsa.PublicKey) {
 	privateKey, _ := rsa.GenerateKey(rand.Reader, keySize)
 	return privateKey, &privateKey.PublicKey
 }
 
 // RsaEncryptOAEP encrypts the given data with RSA-OAEP.
-// Play: https://go.dev/play/p/sSVmkfENKMz
 func RsaEncryptOAEP(data []byte, label []byte, key rsa.PublicKey) ([]byte, error) {
 	encryptedBytes, err := rsa.EncryptOAEP(sha256.New(), rand.Reader, &key, data, label)
 	if err != nil {
@@ -816,7 +480,6 @@ func RsaEncryptOAEP(data []byte, label []byte, key rsa.PublicKey) ([]byte, error
 }
 
 // RsaDecryptOAEP decrypts the data with RSA-OAEP.
-// Play: https://go.dev/play/p/sSVmkfENKMz
 func RsaDecryptOAEP(ciphertext []byte, label []byte, key rsa.PrivateKey) ([]byte, error) {
 	decryptedBytes, err := rsa.DecryptOAEP(sha256.New(), rand.Reader, &key, ciphertext, label)
 	if err != nil {
@@ -825,35 +488,3 @@ func RsaDecryptOAEP(ciphertext []byte, label []byte, key rsa.PrivateKey) ([]byte
 
 	return decryptedBytes, nil
 }
-
-// RsaSign signs the data with RSA.
-// Play: https://go.dev/play/p/qhsbf8BJ6Mf
-func RsaSign(hash crypto.Hash, data []byte, privateKeyFileName string) ([]byte, error) {
-	privateKey, err := loadRasPrivateKey(privateKeyFileName)
-	if err != nil {
-		return nil, err
-	}
-
-	hashed, err := hashData(hash, data)
-	if err != nil {
-		return nil, err
-	}
-
-	return rsa.SignPKCS1v15(rand.Reader, privateKey, hash, hashed)
-}
-
-// RsaVerifySign verifies the signature of the data with RSA.
-// Play: https://go.dev/play/p/qhsbf8BJ6Mf
-func RsaVerifySign(hash crypto.Hash, data, signature []byte, pubKeyFileName string) error {
-	publicKey, err := loadRsaPublicKey(pubKeyFileName)
-	if err != nil {
-		return err
-	}
-
-	hashed, err := hashData(hash, data)
-	if err != nil {
-		return err
-	}
-
-	return rsa.VerifyPKCS1v15(publicKey, hash, hashed, signature)
-}

cryptor/crypto_example_test.go

@@ -1,624 +0,0 @@
-package cryptor
-
-import (
-	"crypto"
-	"fmt"
-)
-
-func ExampleAesEcbEncrypt() {
-	data := "hello"
-	key := "abcdefghijklmnop"
-
-	encrypted := AesEcbEncrypt([]byte(data), []byte(key))
-
-	decrypted := AesEcbDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleAesEcbDecrypt() {
-	data := "hello"
-	key := "abcdefghijklmnop"
-
-	encrypted := AesEcbEncrypt([]byte(data), []byte(key))
-
-	decrypted := AesEcbDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleAesCbcEncrypt() {
-	data := "hello"
-	key := "abcdefghijklmnop"
-
-	encrypted := AesCbcEncrypt([]byte(data), []byte(key))
-
-	decrypted := AesCbcDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleAesCbcDecrypt() {
-	data := "hello"
-	key := "abcdefghijklmnop"
-
-	encrypted := AesCbcEncrypt([]byte(data), []byte(key))
-
-	decrypted := AesCbcDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleAesCtrCrypt() {
-	data := "hello"
-	key := "abcdefghijklmnop"
-
-	encrypted := AesCtrCrypt([]byte(data), []byte(key))
-	decrypted := AesCtrCrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleAesCtrEncrypt() {
-	data := "hello"
-	key := "abcdefghijklmnop"
-
-	enCrypt := AesCtrEncrypt([]byte(data), []byte(key))
-	deCrypt := AesCtrDecrypt(enCrypt, []byte(key))
-
-	fmt.Println(string(deCrypt))
-
-	// Output:
-	// hello
-}
-
-func ExampleAesCtrDecrypt() {
-	data := "hello"
-	key := "abcdefghijklmnop"
-
-	enCrypt := AesCtrEncrypt([]byte(data), []byte(key))
-	deCrypt := AesCtrDecrypt(enCrypt, []byte(key))
-
-	fmt.Println(string(deCrypt))
-
-	// Output:
-	// hello
-}
-
-func ExampleAesCfbEncrypt() {
-	data := "hello"
-	key := "abcdefghijklmnop"
-
-	encrypted := AesCfbEncrypt([]byte(data), []byte(key))
-
-	decrypted := AesCfbDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleAesCfbDecrypt() {
-	data := "hello"
-	key := "abcdefghijklmnop"
-
-	encrypted := AesCfbEncrypt([]byte(data), []byte(key))
-
-	decrypted := AesCfbDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleAesOfbEncrypt() {
-	data := "hello"
-	key := "abcdefghijklmnop"
-
-	encrypted := AesOfbEncrypt([]byte(data), []byte(key))
-
-	decrypted := AesOfbDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleAesOfbDecrypt() {
-	data := "hello"
-	key := "abcdefghijklmnop"
-
-	encrypted := AesOfbEncrypt([]byte(data), []byte(key))
-
-	decrypted := AesOfbDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleAesGcmEncrypt() {
-	data := "hello"
-	key := "abcdefghijklmnop"
-
-	encrypted := AesGcmEncrypt([]byte(data), []byte(key))
-
-	decrypted := AesGcmDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleAesGcmDecrypt() {
-	data := "hello"
-	key := "abcdefghijklmnop"
-
-	encrypted := AesGcmEncrypt([]byte(data), []byte(key))
-
-	decrypted := AesGcmDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleDesEcbEncrypt() {
-	data := "hello"
-	key := "abcdefgh"
-
-	encrypted := DesEcbEncrypt([]byte(data), []byte(key))
-
-	decrypted := DesEcbDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleDesEcbDecrypt() {
-	data := "hello"
-	key := "abcdefgh"
-
-	encrypted := DesEcbEncrypt([]byte(data), []byte(key))
-
-	decrypted := DesEcbDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleDesCbcEncrypt() {
-	data := "hello"
-	key := "abcdefgh"
-
-	encrypted := DesCbcEncrypt([]byte(data), []byte(key))
-
-	decrypted := DesCbcDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleDesCbcDecrypt() {
-	data := "hello"
-	key := "abcdefgh"
-
-	encrypted := DesCbcEncrypt([]byte(data), []byte(key))
-
-	decrypted := DesCbcDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleDesCtrCrypt() {
-	data := "hello"
-	key := "abcdefgh"
-
-	encrypted := DesCtrCrypt([]byte(data), []byte(key))
-	decrypted := DesCtrCrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleDesCtrDecrypt() {
-	data := "hello"
-	key := "abcdefgh"
-
-	enCrypt := DesCtrEncrypt([]byte(data), []byte(key))
-	deCrypt := DesCtrDecrypt(enCrypt, []byte(key))
-
-	fmt.Println(string(deCrypt))
-
-	// Output:
-	// hello
-}
-
-func ExampleDesCfbEncrypt() {
-	data := "hello"
-	key := "abcdefgh"
-
-	encrypted := DesCfbEncrypt([]byte(data), []byte(key))
-
-	decrypted := DesCfbDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleDesCfbDecrypt() {
-	data := "hello"
-	key := "abcdefgh"
-
-	encrypted := DesCfbEncrypt([]byte(data), []byte(key))
-
-	decrypted := DesCfbDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleDesOfbEncrypt() {
-	data := "hello"
-	key := "abcdefgh"
-
-	encrypted := DesOfbEncrypt([]byte(data), []byte(key))
-
-	decrypted := DesOfbDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleDesOfbDecrypt() {
-	data := "hello"
-	key := "abcdefgh"
-
-	encrypted := DesOfbEncrypt([]byte(data), []byte(key))
-
-	decrypted := DesOfbDecrypt(encrypted, []byte(key))
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleGenerateRsaKey() {
-	// Create ras private and public pem file
-	err := GenerateRsaKey(4096, "rsa_private_example.pem", "rsa_public_example.pem")
-	if err != nil {
-		return
-	}
-
-	fmt.Println("foo")
-
-	// Output:
-	// foo
-}
-
-func ExampleRsaEncrypt() {
-	// Create ras private and public pem file
-	err := GenerateRsaKey(4096, "rsa_private_example.pem", "rsa_public_example.pem")
-	if err != nil {
-		return
-	}
-
-	data := []byte("hello")
-	encrypted := RsaEncrypt(data, "rsa_public_example.pem")
-	decrypted := RsaDecrypt(encrypted, "rsa_private_example.pem")
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleRsaDecrypt() {
-	// Create ras private and public pem file
-	err := GenerateRsaKey(4096, "rsa_private_example.pem", "rsa_public_example.pem")
-	if err != nil {
-		return
-	}
-
-	data := []byte("hello")
-	encrypted := RsaEncrypt(data, "rsa_public_example.pem")
-	decrypted := RsaDecrypt(encrypted, "rsa_private_example.pem")
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleBase64StdEncode() {
-	base64Str := Base64StdEncode("hello")
-
-	fmt.Println(base64Str)
-
-	// Output:
-	// aGVsbG8=
-}
-
-func ExampleBase64StdDecode() {
-	str := Base64StdDecode("aGVsbG8=")
-
-	fmt.Println(str)
-
-	// Output:
-	// hello
-}
-
-func ExampleHmacMd5() {
-	str := "hello"
-	key := "12345"
-
-	hms := HmacMd5(str, key)
-	fmt.Println(hms)
-
-	// Output:
-	// e834306eab892d872525d4918a7a639a
-}
-
-func ExampleHmacMd5WithBase64() {
-	str := "hello"
-	key := "12345"
-
-	hms := HmacMd5WithBase64(str, key)
-	fmt.Println(hms)
-
-	// Output:
-	// 6DQwbquJLYclJdSRinpjmg==
-}
-
-func ExampleHmacSha1() {
-	str := "hello"
-	key := "12345"
-
-	hms := HmacSha1(str, key)
-	fmt.Println(hms)
-
-	// Output:
-	// 5c6a9db0cccb92e36ed0323fd09b7f936de9ace0
-}
-
-func ExampleHmacSha1WithBase64() {
-	str := "hello"
-	key := "12345"
-
-	hms := HmacSha1WithBase64(str, key)
-	fmt.Println(hms)
-
-	// Output:
-	// XGqdsMzLkuNu0DI/0Jt/k23prOA=
-}
-
-func ExampleHmacSha256() {
-	str := "hello"
-	key := "12345"
-
-	hms := HmacSha256(str, key)
-	fmt.Println(hms)
-
-	// Output:
-	// 315bb93c4e989862ba09cb62e05d73a5f376cb36f0d786edab0c320d059fde75
-}
-
-func ExampleHmacSha256WithBase64() {
-	str := "hello"
-	key := "12345"
-
-	hms := HmacSha256WithBase64(str, key)
-	fmt.Println(hms)
-
-	// Output:
-	// MVu5PE6YmGK6Ccti4F1zpfN2yzbw14btqwwyDQWf3nU=
-}
-
-func ExampleHmacSha512() {
-	str := "hello"
-	key := "12345"
-
-	hms := HmacSha512(str, key)
-	fmt.Println(hms)
-
-	// Output:
-	// dd8f1290a9dd23d354e2526d9a2e9ce8cffffdd37cb320800d1c6c13d2efc363288376a196c5458daf53f8e1aa6b45a6d856303d5c0a2064bff9785861d48cfc
-}
-
-func ExampleHmacSha512WithBase64() {
-	str := "hello"
-	key := "12345"
-
-	hms := HmacSha512WithBase64(str, key)
-	fmt.Println(hms)
-
-	// Output:
-	// 3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A==
-}
-
-func ExampleMd5String() {
-	md5Str := Md5String("hello")
-	fmt.Println(md5Str)
-
-	// Output:
-	// 5d41402abc4b2a76b9719d911017c592
-}
-
-func ExampleMd5StringWithBase64() {
-	md5Str := Md5StringWithBase64("hello")
-	fmt.Println(md5Str)
-
-	// Output:
-	// XUFAKrxLKna5cZ2REBfFkg==
-}
-
-func ExampleMd5Byte() {
-	md5Str := Md5Byte([]byte{'a'})
-	fmt.Println(md5Str)
-
-	// Output:
-	// 0cc175b9c0f1b6a831c399e269772661
-}
-
-func ExampleMd5ByteWithBase64() {
-	md5Str := Md5ByteWithBase64([]byte("hello"))
-	fmt.Println(md5Str)
-
-	// Output:
-	// XUFAKrxLKna5cZ2REBfFkg==
-}
-
-func ExampleSha1() {
-	result := Sha1("hello")
-	fmt.Println(result)
-
-	// Output:
-	// aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
-}
-
-func ExampleSha1WithBase64() {
-	result := Sha1WithBase64("hello")
-	fmt.Println(result)
-
-	// Output:
-	// qvTGHdzF6KLavt4PO0gs2a6pQ00=
-}
-
-func ExampleSha256() {
-	result := Sha256("hello")
-	fmt.Println(result)
-
-	// Output:
-	// 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
-}
-
-func ExampleSha256WithBase64() {
-	result := Sha256WithBase64("hello")
-	fmt.Println(result)
-
-	// Output:
-	// LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=
-}
-
-func ExampleSha512() {
-	result := Sha512("hello")
-	fmt.Println(result)
-
-	// Output:
-	// 9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043
-}
-
-func ExampleSha512WithBase64() {
-	result := Sha512WithBase64("hello")
-	fmt.Println(result)
-
-	// Output:
-	// m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
-}
-
-func ExampleRsaEncryptOAEP() {
-	pri, pub := GenerateRsaKeyPair(1024)
-
-	data := []byte("hello world")
-	label := []byte("123456")
-
-	encrypted, err := RsaEncryptOAEP(data, label, *pub)
-	if err != nil {
-		return
-	}
-
-	decrypted, err := RsaDecryptOAEP([]byte(encrypted), label, *pri)
-	if err != nil {
-		return
-	}
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello world
-}
-
-func ExampleRsaSign() {
-	data := []byte("This is a test data for RSA signing")
-	hash := crypto.SHA256
-
-	privateKey := "./rsa_private_example.pem"
-	publicKey := "./rsa_public_example.pem"
-
-	signature, err := RsaSign(hash, data, privateKey)
-	if err != nil {
-		return
-	}
-
-	err = RsaVerifySign(hash, data, signature, publicKey)
-	if err != nil {
-		return
-	}
-
-	fmt.Println("ok")
-
-	// Output:
-	// ok
-}
-
-func ExampleRsaVerifySign() {
-	data := []byte("This is a test data for RSA signing")
-	hash := crypto.SHA256
-
-	privateKey := "./rsa_private_example.pem"
-	publicKey := "./rsa_public_example.pem"
-
-	signature, err := RsaSign(hash, data, privateKey)
-	if err != nil {
-		return
-	}
-
-	err = RsaVerifySign(hash, data, signature, publicKey)
-	if err != nil {
-		return
-	}
-
-	fmt.Println("ok")
-
-	// Output:
-	// ok
-}

cryptor/crypto_internal.go

@@ -1,27 +1,16 @@
 package cryptor
 
-import (
-	"bytes"
-	"crypto"
-	"crypto/rsa"
-	"crypto/sha256"
-	"crypto/sha512"
-	"crypto/x509"
-	"encoding/pem"
-	"errors"
-	"os"
-	"strings"
-)
+import "bytes"
 
 func generateAesKey(key []byte, size int) []byte {
-	genKey := make([]byte, size)
-	copy(genKey, key)
+	aesKey := make([]byte, size)
+	copy(aesKey, key)
 	for i := size; i < len(key); {
 		for j := 0; j < size && i < len(key); j, i = j+1, i+1 {
-			genKey[j] ^= key[i]
+			aesKey[j] ^= key[i]
 		}
 	}
-	return genKey
+	return aesKey
 }
 
 func generateDesKey(key []byte) []byte {
@@ -46,139 +35,3 @@ func pkcs7UnPadding(src []byte) []byte {
 	unPadding := int(src[length-1])
 	return src[:(length - unPadding)]
 }
-
-func pkcs5Padding(data []byte, blockSize int) []byte {
-	padding := blockSize - len(data)%blockSize
-	padText := bytes.Repeat([]byte{byte(padding)}, padding)
-	return append(data, padText...)
-}
-
-func pkcs5UnPadding(data []byte) []byte {
-	length := len(data)
-	if length == 0 {
-		return nil
-	}
-	padLen := int(data[length-1])
-	if padLen == 0 || padLen > length {
-		return nil
-	}
-	return data[:length-padLen]
-}
-
-func isAesKeyLengthValid(n int) bool {
-	return n == 16 || n == 24 || n == 32
-}
-
-// loadRsaPrivateKey loads and parses a PEM encoded private key file.
-func loadRsaPublicKey(filename string) (*rsa.PublicKey, error) {
-	pubKeyData, err := os.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-
-	block, _ := pem.Decode(pubKeyData)
-	if block == nil {
-		return nil, errors.New("failed to decode PEM block containing the public key")
-	}
-
-	var pubKey *rsa.PublicKey
-	blockType := strings.ToUpper(block.Type)
-
-	if blockType == "RSA PUBLIC KEY" {
-		pubKey, err = x509.ParsePKCS1PublicKey(block.Bytes)
-		if err != nil {
-			key, err := x509.ParsePKIXPublicKey(block.Bytes)
-			if err != nil {
-				return nil, err
-			}
-
-			var ok bool
-			pubKey, ok = key.(*rsa.PublicKey)
-			if !ok {
-				return nil, errors.New("failed to parse RSA private key")
-			}
-		}
-	} else if blockType == "PUBLIC KEY" {
-		key, err := x509.ParsePKIXPublicKey(block.Bytes)
-		if err != nil {
-			return nil, err
-		}
-
-		var ok bool
-		pubKey, ok = key.(*rsa.PublicKey)
-		if !ok {
-			return nil, errors.New("failed to parse RSA private key")
-		}
-
-	} else {
-		return nil, errors.New("unsupported key type")
-	}
-
-	return pubKey, nil
-}
-
-// loadRsaPrivateKey loads and parses a PEM encoded private key file.
-func loadRasPrivateKey(filename string) (*rsa.PrivateKey, error) {
-	priKeyData, err := os.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-
-	block, _ := pem.Decode(priKeyData)
-	if block == nil {
-		return nil, errors.New("failed to decode PEM block containing the private key")
-	}
-
-	var privateKey *rsa.PrivateKey
-	blockType := strings.ToUpper(block.Type)
-
-	// PKCS#1 format
-	if blockType == "RSA PRIVATE KEY" {
-		privateKey, err = x509.ParsePKCS1PrivateKey(block.Bytes)
-		if err != nil {
-			return nil, err
-		}
-	} else if blockType == "PRIVATE KEY" { // PKCS#8 format
-		priKey, err := x509.ParsePKCS8PrivateKey(block.Bytes)
-		if err != nil {
-			return nil, err
-		}
-		var ok bool
-		privateKey, ok = priKey.(*rsa.PrivateKey)
-		if !ok {
-			return nil, errors.New("failed to parse RSA private key")
-		}
-	} else {
-		return nil, errors.New("unsupported key type")
-	}
-
-	return privateKey, nil
-}
-
-// hashData returns the hash value of the data, using the specified hash function
-func hashData(hash crypto.Hash, data []byte) ([]byte, error) {
-	if !hash.Available() {
-		return nil, errors.New("unsupported hash algorithm")
-	}
-
-	var hashed []byte
-
-	switch hash {
-	case crypto.SHA224:
-		h := sha256.Sum224(data)
-		hashed = h[:]
-	case crypto.SHA256:
-		h := sha256.Sum256(data)
-		hashed = h[:]
-	case crypto.SHA384:
-		h := sha512.Sum384(data)
-		hashed = h[:]
-	case crypto.SHA512:
-		h := sha512.Sum512(data)
-		hashed = h[:]
-	default:
-		return nil, errors.New("unsupported hash algorithm")
-	}
-
-	return hashed, nil
-}

cryptor/crypto_test.go

@@ -1,67 +1,56 @@
 package cryptor
 
 import (
-	"crypto"
 	"testing"
 
-	"github.com/duke-git/lancet/v2/internal"
+	"github.com/duke-git/lancet/internal"
 )
 
-func TestAesEcbCrypt(t *testing.T) {
-	t.Parallel()
-
+func TestAesEcbEncrypt(t *testing.T) {
 	data := "hello world"
 	key := "abcdefghijklmnop"
 
 	aesEcbEncrypt := AesEcbEncrypt([]byte(data), []byte(key))
 	aesEcbDecrypt := AesEcbDecrypt(aesEcbEncrypt, []byte(key))
 
-	assert := internal.NewAssert(t, "TestAesEcbCrypt")
+	assert := internal.NewAssert(t, "TestAesEcbEncrypt")
 	assert.Equal(data, string(aesEcbDecrypt))
 }
 
-func TestAesCbcCrypt(t *testing.T) {
-	t.Parallel()
-
+func TestAesCbcEncrypt(t *testing.T) {
 	data := "hello world"
 	key := "abcdefghijklmnop"
 
 	aesCbcEncrypt := AesCbcEncrypt([]byte(data), []byte(key))
 	aesCbcDecrypt := AesCbcDecrypt(aesCbcEncrypt, []byte(key))
 
-	assert := internal.NewAssert(t, "TestAesCbcCrypt")
+	assert := internal.NewAssert(t, "TestAesCbcEncrypt")
 	assert.Equal(data, string(aesCbcDecrypt))
 }
 
 func TestAesCtrCrypt(t *testing.T) {
-	t.Parallel()
-
 	data := "hello world"
 	key := "abcdefghijklmnop"
 
-	aesCtrCrypt := AesCtrEncrypt([]byte(data), []byte(key))
-	aesCtrDeCrypt := AesCtrDecrypt(aesCtrCrypt, []byte(key))
+	aesCtrCrypt := AesCtrCrypt([]byte(data), []byte(key))
+	aesCtrDeCrypt := AesCtrCrypt(aesCtrCrypt, []byte(key))
 
 	assert := internal.NewAssert(t, "TestAesCtrCrypt")
 	assert.Equal(data, string(aesCtrDeCrypt))
 }
 
-func TestAesCfbCrypt(t *testing.T) {
-	t.Parallel()
-
+func TestAesCfbEncrypt(t *testing.T) {
 	data := "hello world"
 	key := "abcdefghijklmnop"
 
 	aesCfbEncrypt := AesCfbEncrypt([]byte(data), []byte(key))
 	aesCfbDecrypt := AesCfbDecrypt(aesCfbEncrypt, []byte(key))
 
-	assert := internal.NewAssert(t, "TestAesCfbCrypt")
+	assert := internal.NewAssert(t, "TestAesCfbEncrypt")
 	assert.Equal(data, string(aesCfbDecrypt))
 }
 
-func TestAesOfbCrypt(t *testing.T) {
-	t.Parallel()
-
+func TestAesOfbEncrypt(t *testing.T) {
 	data := "hello world"
 	key := "abcdefghijklmnop"
 
@@ -72,9 +61,7 @@ func TestAesOfbCrypt(t *testing.T) {
 	assert.Equal(data, string(aesOfbDecrypt))
 }
 
-func TestDesEcbCrypt(t *testing.T) {
-	t.Parallel()
-
+func TestDesEcbEncrypt(t *testing.T) {
 	data := "hello world"
 	key := "abcdefgh"
 
@@ -85,9 +72,7 @@ func TestDesEcbCrypt(t *testing.T) {
 	assert.Equal(data, string(desEcbDecrypt))
 }
 
-func TestDesCbcCrypt(t *testing.T) {
-	t.Parallel()
-
+func TestDesCbcEncrypt(t *testing.T) {
 	data := "hello world"
 	key := "abcdefgh"
 
@@ -99,21 +84,17 @@ func TestDesCbcCrypt(t *testing.T) {
 }
 
 func TestDesCtrCrypt(t *testing.T) {
-	t.Parallel()
-
 	data := "hello world"
 	key := "abcdefgh"
 
-	desCtrCrypt := DesCtrEncrypt([]byte(data), []byte(key))
-	desCtrDeCrypt := DesCtrDecrypt(desCtrCrypt, []byte(key))
+	desCtrCrypt := DesCtrCrypt([]byte(data), []byte(key))
+	desCtrDeCrypt := DesCtrCrypt(desCtrCrypt, []byte(key))
 
 	assert := internal.NewAssert(t, "TestDesCtrCrypt")
 	assert.Equal(data, string(desCtrDeCrypt))
 }
 
-func TestDesCfbCrypt(t *testing.T) {
-	t.Parallel()
-
+func TestDesCfbEncrypt(t *testing.T) {
 	data := "hello world"
 	key := "abcdefgh"
 
@@ -124,9 +105,7 @@ func TestDesCfbCrypt(t *testing.T) {
 	assert.Equal(data, string(desCfbDecrypt))
 }
 
-func TestDesOfbCrypt(t *testing.T) {
-	t.Parallel()
-
+func TestDesOfbEncrypt(t *testing.T) {
 	data := "hello world"
 	key := "abcdefgh"
 
@@ -138,15 +117,13 @@ func TestDesOfbCrypt(t *testing.T) {
 }
 
 func TestRsaEncrypt(t *testing.T) {
-	t.Parallel()
-
-	err := GenerateRsaKey(4096, "./rsa_private_example.pem", "./rsa_public_example.pem")
+	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
 	if err != nil {
 		t.FailNow()
 	}
 	data := []byte("hello world")
-	encrypted := RsaEncrypt(data, "./rsa_public_example.pem")
-	decrypted := RsaDecrypt(encrypted, "./rsa_private_example.pem")
+	encrypted := RsaEncrypt(data, "rsa_public.pem")
+	decrypted := RsaDecrypt(encrypted, "rsa_private.pem")
 
 	assert := internal.NewAssert(t, "TestRsaEncrypt")
 	assert.Equal(string(data), string(decrypted))
@@ -169,66 +146,3 @@ func TestRsaEncryptOAEP(t *testing.T) {
 	assert.IsNil(err)
 	assert.Equal("hello world", string(decrypted))
 }
-
-func TestAesGcmEncrypt(t *testing.T) {
-	t.Parallel()
-
-	data := "hello world"
-	key := "abcdefghijklmnop"
-
-	encrypted := AesGcmEncrypt([]byte(data), []byte(key))
-	decrypted := AesGcmDecrypt(encrypted, []byte(key))
-
-	assert := internal.NewAssert(t, "TestAesGcmEncrypt")
-	assert.Equal(data, string(decrypted))
-}
-
-func TestRsaSignAndVerify(t *testing.T) {
-	t.Parallel()
-
-	data := []byte("This is a test data for RSA signing")
-	hash := crypto.SHA256
-
-	t.Run("RSA Sign and Verify", func(t *testing.T) {
-		privateKey := "./rsa_private_example.pem"
-		publicKey := "./rsa_public_example.pem"
-
-		signature, err := RsaSign(hash, data, privateKey)
-		if err != nil {
-			t.Fatalf("RsaSign failed: %v", err)
-		}
-
-		err = RsaVerifySign(hash, data, signature, publicKey)
-		if err != nil {
-			t.Fatalf("RsaVerifySign failed: %v", err)
-		}
-	})
-
-	t.Run("RSA Sign and Verify Invalid Signature", func(t *testing.T) {
-		publicKey := "./rsa_public_example.pem"
-
-		invalidSig := []byte("InvalidSignature")
-
-		err := RsaVerifySign(hash, data, invalidSig, publicKey)
-		if err == nil {
-			t.Fatalf("RsaVerifySign failed: %v", err)
-		}
-	})
-
-	t.Run("RSA Sign and Verify With Different Hash", func(t *testing.T) {
-		publicKey := "./rsa_public_example.pem"
-		privateKey := "./rsa_private_example.pem"
-		hashSign := crypto.SHA256
-		hashVerify := crypto.SHA512
-
-		signature, err := RsaSign(hashSign, data, privateKey)
-		if err != nil {
-			t.Fatalf("RsaSign failed: %v", err)
-		}
-
-		err = RsaVerifySign(hashVerify, data, signature, publicKey)
-		if err == nil {
-			t.Fatalf("RsaVerifySign failed: %v", err)
-		}
-	})
-}

cryptor/gm_example_test.go

@@ -1,71 +0,0 @@
-package cryptor_test
-
-import (
-	"encoding/hex"
-	"fmt"
-
-	"github.com/duke-git/lancet/v2/cryptor"
-)
-
-func ExampleSm3() {
-	data := []byte("hello world")
-	hash := cryptor.Sm3(data)
-
-	fmt.Println(hex.EncodeToString(hash))
-
-	// Output:
-	// 44f0061e69fa6fdfc290c494654a05dc0c053da7e5c52b84ef93a9d67d3fff88
-}
-
-func ExampleSm4EcbEncrypt() {
-	key := []byte("1234567890abcdef") // 16 bytes key
-	plaintext := []byte("hello world")
-
-	encrypted := cryptor.Sm4EcbEncrypt(plaintext, key)
-	decrypted := cryptor.Sm4EcbDecrypt(encrypted, key)
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello world
-}
-
-func ExampleSm4CbcEncrypt() {
-	key := []byte("1234567890abcdef") // 16 bytes key
-	plaintext := []byte("hello world")
-
-	encrypted := cryptor.Sm4CbcEncrypt(plaintext, key)
-	decrypted := cryptor.Sm4CbcDecrypt(encrypted, key)
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello world
-}
-
-func ExampleGenerateSm2Key() {
-	// Generate SM2 key pair
-	privateKey, err := cryptor.GenerateSm2Key()
-	if err != nil {
-		return
-	}
-
-	plaintext := []byte("hello world")
-
-	// Encrypt with public key
-	ciphertext, err := cryptor.Sm2Encrypt(&privateKey.PublicKey, plaintext)
-	if err != nil {
-		return
-	}
-
-	// Decrypt with private key
-	decrypted, err := cryptor.Sm2Decrypt(privateKey, ciphertext)
-	if err != nil {
-		return
-	}
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello world
-}

cryptor/gm_sm2.go

@@ -1,251 +0,0 @@
-package cryptor
-
-import (
-	"crypto/elliptic"
-	"crypto/rand"
-	"encoding/binary"
-	"errors"
-	"io"
-	"math/big"
-)
-
-// SM2 implements the Chinese SM2 elliptic curve public key algorithm.
-// SM2 is based on elliptic curve cryptography and provides encryption, decryption, signing and verification.
-//
-// Note: This implementation uses crypto/elliptic package methods (GenerateKey, ScalarBaseMult, ScalarMult, IsOnCurve)
-// which are marked as deprecated in Go 1.20+. These methods still work correctly and are widely used.
-// The //nolint:staticcheck directive suppresses deprecation warnings.
-// A future version may replace these with a custom elliptic curve implementation.
-
-var (
-	sm2P256       *sm2Curve
-	sm2P256Params = &elliptic.CurveParams{Name: "sm2p256v1"}
-)
-
-func init() {
-	// SM2 curve parameters
-	sm2P256Params.P, _ = new(big.Int).SetString("FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF", 16)
-	sm2P256Params.N, _ = new(big.Int).SetString("FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123", 16)
-	sm2P256Params.B, _ = new(big.Int).SetString("28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93", 16)
-	sm2P256Params.Gx, _ = new(big.Int).SetString("32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7", 16)
-	sm2P256Params.Gy, _ = new(big.Int).SetString("BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0", 16)
-	sm2P256Params.BitSize = 256
-
-	sm2P256 = &sm2Curve{sm2P256Params}
-}
-
-type sm2Curve struct {
-	*elliptic.CurveParams
-}
-
-// Sm2PrivateKey represents an SM2 private key.
-type Sm2PrivateKey struct {
-	D         *big.Int
-	PublicKey Sm2PublicKey
-}
-
-// Sm2PublicKey represents an SM2 public key.
-type Sm2PublicKey struct {
-	X, Y *big.Int
-}
-
-// GenerateSm2Key generates a new SM2 private/public key pair.
-// Play: https://go.dev/play/p/bKYMqRLvIx3
-func GenerateSm2Key() (*Sm2PrivateKey, error) {
-	priv, x, y, err := elliptic.GenerateKey(sm2P256, rand.Reader)
-	if err != nil {
-		return nil, err
-	}
-
-	privateKey := &Sm2PrivateKey{
-		D: new(big.Int).SetBytes(priv),
-		PublicKey: Sm2PublicKey{
-			X: x,
-			Y: y,
-		},
-	}
-
-	return privateKey, nil
-}
-
-// Sm2Encrypt encrypts plaintext using SM2 public key.
-// Returns ciphertext in the format: C1 || C3 || C2
-// C1 = kG (65 bytes in uncompressed format)
-// C3 = Hash(x2 || M || y2) (32 bytes for SM3)
-// C2 = M xor t (same length as plaintext)
-// Play: https://go.dev/play/p/bKYMqRLvIx3
-func Sm2Encrypt(pub *Sm2PublicKey, plaintext []byte) ([]byte, error) {
-	if pub == nil || pub.X == nil || pub.Y == nil {
-		return nil, errors.New("sm2: invalid public key")
-	}
-
-	for {
-		// Generate random k
-		k, err := randFieldElement(sm2P256, rand.Reader)
-		if err != nil {
-			return nil, err
-		}
-
-		// C1 = kG
-		c1x, c1y := sm2P256.ScalarBaseMult(k.Bytes())
-
-		// kP = (x2, y2)
-		x2, y2 := sm2P256.ScalarMult(pub.X, pub.Y, k.Bytes())
-
-		// Derive key using KDF
-		kdfLen := len(plaintext)
-		t := sm2KDF(append(toBytes(sm2P256, x2), toBytes(sm2P256, y2)...), kdfLen)
-
-		// Check if t is all zeros
-		allZero := true
-		for _, b := range t {
-			if b != 0 {
-				allZero = false
-				break
-			}
-		}
-		if allZero {
-			continue
-		}
-
-		// C2 = M xor t
-		c2 := make([]byte, len(plaintext))
-		for i := 0; i < len(plaintext); i++ {
-			c2[i] = plaintext[i] ^ t[i]
-		}
-
-		// C3 = Hash(x2 || M || y2)
-		c3Input := append(toBytes(sm2P256, x2), plaintext...)
-		c3Input = append(c3Input, toBytes(sm2P256, y2)...)
-		c3 := Sm3(c3Input)
-
-		// Return C1 || C3 || C2
-		c1 := sm2MarshalUncompressed(sm2P256, c1x, c1y)
-		result := append(c1, c3...)
-		result = append(result, c2...)
-
-		return result, nil
-	}
-}
-
-// Sm2Decrypt decrypts ciphertext using SM2 private key.
-// Expects ciphertext in the format: C1 || C3 || C2
-// Play: https://go.dev/play/p/bKYMqRLvIx3
-func Sm2Decrypt(priv *Sm2PrivateKey, ciphertext []byte) ([]byte, error) {
-	if priv == nil || priv.D == nil {
-		return nil, errors.New("sm2: invalid private key")
-	}
-
-	// Parse C1 (65 bytes), C3 (32 bytes), C2 (remaining)
-	if len(ciphertext) < 97 {
-		return nil, errors.New("sm2: ciphertext too short")
-	}
-
-	c1 := ciphertext[:65]
-	c3 := ciphertext[65:97]
-	c2 := ciphertext[97:]
-
-	// Parse C1
-	c1x, c1y := sm2UnmarshalUncompressed(sm2P256, c1)
-	if c1x == nil {
-		return nil, errors.New("sm2: invalid C1 point")
-	}
-
-	// Verify C1 is on curve
-	if !sm2P256.IsOnCurve(c1x, c1y) {
-		return nil, errors.New("sm2: C1 not on curve")
-	}
-
-	// dC1 = (x2, y2)
-	x2, y2 := sm2P256.ScalarMult(c1x, c1y, priv.D.Bytes())
-
-	// Derive key using KDF
-	kdfLen := len(c2)
-	t := sm2KDF(append(toBytes(sm2P256, x2), toBytes(sm2P256, y2)...), kdfLen)
-
-	// M = C2 xor t
-	plaintext := make([]byte, len(c2))
-	for i := 0; i < len(c2); i++ {
-		plaintext[i] = c2[i] ^ t[i]
-	}
-
-	// Verify C3 = Hash(x2 || M || y2)
-	u := append(toBytes(sm2P256, x2), plaintext...)
-	u = append(u, toBytes(sm2P256, y2)...)
-	hash := Sm3(u)
-
-	for i := 0; i < len(c3); i++ {
-		if c3[i] != hash[i] {
-			return nil, errors.New("sm2: hash verification failed")
-		}
-	}
-
-	return plaintext, nil
-}
-
-// SM2 KDF (Key Derivation Function)
-func sm2KDF(z []byte, klen int) []byte {
-	limit := (klen + 31) / 32
-	result := make([]byte, 0, limit*32)
-
-	for i := 1; i <= limit; i++ {
-		counter := make([]byte, 4)
-		binary.BigEndian.PutUint32(counter, uint32(i))
-		hash := Sm3(append(z, counter...))
-		result = append(result, hash...)
-	}
-
-	return result[:klen]
-}
-
-func toBytes(curve elliptic.Curve, value *big.Int) []byte {
-	byteLen := (curve.Params().BitSize + 7) / 8
-	buf := make([]byte, byteLen)
-	b := value.Bytes()
-	copy(buf[byteLen-len(b):], b)
-	return buf
-}
-
-func sm2MarshalUncompressed(curve *sm2Curve, x, y *big.Int) []byte {
-	byteLen := (curve.BitSize + 7) / 8
-	ret := make([]byte, 1+2*byteLen)
-	ret[0] = 4 // uncompressed point
-
-	xBytes := x.Bytes()
-	copy(ret[1+byteLen-len(xBytes):], xBytes)
-	yBytes := y.Bytes()
-	copy(ret[1+2*byteLen-len(yBytes):], yBytes)
-
-	return ret
-}
-
-func sm2UnmarshalUncompressed(curve *sm2Curve, data []byte) (*big.Int, *big.Int) {
-	byteLen := (curve.BitSize + 7) / 8
-	if len(data) != 1+2*byteLen {
-		return nil, nil
-	}
-	if data[0] != 4 {
-		return nil, nil
-	}
-
-	x := new(big.Int).SetBytes(data[1 : 1+byteLen])
-	y := new(big.Int).SetBytes(data[1+byteLen:])
-
-	return x, y
-}
-
-func randFieldElement(c elliptic.Curve, rand io.Reader) (*big.Int, error) {
-	params := c.Params()
-	b := make([]byte, params.BitSize/8+8)
-	_, err := io.ReadFull(rand, b)
-	if err != nil {
-		return nil, err
-	}
-
-	k := new(big.Int).SetBytes(b)
-	n := new(big.Int).Sub(params.N, big.NewInt(1))
-	k.Mod(k, n)
-	k.Add(k, big.NewInt(1))
-
-	return k, nil
-}

cryptor/gm_sm3.go

@@ -1,211 +0,0 @@
-package cryptor
-
-import (
-	"encoding/binary"
-	"hash"
-)
-
-// SM3 implements the Chinese SM3 cryptographic hash algorithm.
-// SM3 produces a 256-bit (32-byte) hash value.
-
-const (
-	sm3BlockSize = 64
-	sm3Size      = 32
-	sm3T1        = 0x79cc4519
-	sm3T2        = 0x7a879d8a
-)
-
-var sm3IV = [8]uint32{
-	0x7380166f, 0x4914b2b9, 0x172442d7, 0xda8a0600,
-	0xa96f30bc, 0x163138aa, 0xe38dee4d, 0xb0fb0e4e,
-}
-
-type sm3Digest struct {
-	h   [8]uint32
-	x   [sm3BlockSize]byte
-	nx  int
-	len uint64
-}
-
-// Sm3 returns a new hash.Hash computing the SM3 checksum.
-// Play: https://go.dev/play/p/zDAQpteAiOc
-func Sm3(data []byte) []byte {
-	h := newSm3()
-	h.Write(data)
-	return h.Sum(nil)
-}
-
-func newSm3() hash.Hash {
-	d := new(sm3Digest)
-	d.Reset()
-	return d
-}
-
-func (d *sm3Digest) Reset() {
-	d.h = sm3IV
-	d.nx = 0
-	d.len = 0
-}
-
-func (d *sm3Digest) Size() int {
-	return sm3Size
-}
-
-func (d *sm3Digest) BlockSize() int {
-	return sm3BlockSize
-}
-
-func (d *sm3Digest) Write(p []byte) (nn int, err error) {
-	nn = len(p)
-	d.len += uint64(nn)
-
-	if d.nx > 0 {
-		n := copy(d.x[d.nx:], p)
-		d.nx += n
-		if d.nx == sm3BlockSize {
-			sm3Block(d, d.x[:])
-			d.nx = 0
-		}
-		p = p[n:]
-	}
-
-	if len(p) >= sm3BlockSize {
-		n := len(p) &^ (sm3BlockSize - 1)
-		sm3Block(d, p[:n])
-		p = p[n:]
-	}
-
-	if len(p) > 0 {
-		d.nx = copy(d.x[:], p)
-	}
-
-	return
-}
-
-func (d *sm3Digest) Sum(in []byte) []byte {
-	d0 := *d
-	hash := d0.checkSum()
-	return append(in, hash[:]...)
-}
-
-func (d *sm3Digest) checkSum() [sm3Size]byte {
-	len := d.len
-	var tmp [64]byte
-	tmp[0] = 0x80
-
-	if len%64 < 56 {
-		d.Write(tmp[0 : 56-len%64])
-	} else {
-		d.Write(tmp[0 : 64+56-len%64])
-	}
-
-	len <<= 3
-	binary.BigEndian.PutUint64(tmp[:], len)
-	d.Write(tmp[0:8])
-
-	if d.nx != 0 {
-		panic("d.nx != 0")
-	}
-
-	var digest [sm3Size]byte
-	for i := 0; i < 8; i++ {
-		binary.BigEndian.PutUint32(digest[i*4:], d.h[i])
-	}
-
-	return digest
-}
-
-func sm3Block(dig *sm3Digest, p []byte) {
-	var w [68]uint32
-	var w1 [64]uint32
-
-	h0, h1, h2, h3, h4, h5, h6, h7 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]
-
-	for len(p) >= sm3BlockSize {
-		for i := 0; i < 16; i++ {
-			j := i * 4
-			w[i] = binary.BigEndian.Uint32(p[j : j+4])
-		}
-
-		for i := 16; i < 68; i++ {
-			w[i] = sm3P1(w[i-16]^w[i-9]^sm3RotateLeft(w[i-3], 15)) ^ sm3RotateLeft(w[i-13], 7) ^ w[i-6]
-		}
-
-		for i := 0; i < 64; i++ {
-			w1[i] = w[i] ^ w[i+4]
-		}
-
-		A, B, C, D, E, F, G, H := h0, h1, h2, h3, h4, h5, h6, h7
-
-		for j := 0; j < 64; j++ {
-			var ss1, ss2, tt1, tt2, t uint32
-
-			if j < 16 {
-				t = sm3T1
-			} else {
-				t = sm3T2
-			}
-
-			ss1 = sm3RotateLeft(sm3RotateLeft(A, 12)+E+sm3RotateLeft(t, uint32(j%32)), 7)
-			ss2 = ss1 ^ sm3RotateLeft(A, 12)
-
-			if j < 16 {
-				tt1 = sm3FF0(A, B, C) + D + ss2 + w1[j]
-				tt2 = sm3GG0(E, F, G) + H + ss1 + w[j]
-			} else {
-				tt1 = sm3FF1(A, B, C) + D + ss2 + w1[j]
-				tt2 = sm3GG1(E, F, G) + H + ss1 + w[j]
-			}
-
-			D = C
-			C = sm3RotateLeft(B, 9)
-			B = A
-			A = tt1
-			H = G
-			G = sm3RotateLeft(F, 19)
-			F = E
-			E = sm3P0(tt2)
-		}
-
-		h0 ^= A
-		h1 ^= B
-		h2 ^= C
-		h3 ^= D
-		h4 ^= E
-		h5 ^= F
-		h6 ^= G
-		h7 ^= H
-
-		p = p[sm3BlockSize:]
-	}
-
-	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h0, h1, h2, h3, h4, h5, h6, h7
-}
-
-func sm3RotateLeft(x, n uint32) uint32 {
-	return (x << n) | (x >> (32 - n))
-}
-
-func sm3P0(x uint32) uint32 {
-	return x ^ sm3RotateLeft(x, 9) ^ sm3RotateLeft(x, 17)
-}
-
-func sm3P1(x uint32) uint32 {
-	return x ^ sm3RotateLeft(x, 15) ^ sm3RotateLeft(x, 23)
-}
-
-func sm3FF0(x, y, z uint32) uint32 {
-	return x ^ y ^ z
-}
-
-func sm3FF1(x, y, z uint32) uint32 {
-	return (x & y) | (x & z) | (y & z)
-}
-
-func sm3GG0(x, y, z uint32) uint32 {
-	return x ^ y ^ z
-}
-
-func sm3GG1(x, y, z uint32) uint32 {
-	return (x & y) | (^x & z)
-}

cryptor/gm_sm4.go

@@ -1,270 +0,0 @@
-package cryptor
-
-import (
-	"crypto/cipher"
-	"crypto/rand"
-	"encoding/binary"
-	"io"
-)
-
-// SM4 implements the Chinese SM4 block cipher.
-// SM4 is a 128-bit block cipher with 128-bit keys.
-// This implementation uses pre-computed lookup tables for optimal performance.
-
-const sm4BlockSize = 16
-
-// Pre-computed T-transformation lookup tables for performance optimization
-var sm4T1Table [256][4]uint32 // S-box + L1 transformation
-var sm4T2Table [256][4]uint32 // S-box + L2 transformation
-
-var sm4Sbox = [256]byte{
-	0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7, 0x16, 0xb6, 0x14, 0xc2, 0x28, 0xfb, 0x2c, 0x05,
-	0x2b, 0x67, 0x9a, 0x76, 0x2a, 0xbe, 0x04, 0xc3, 0xaa, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
-	0x9c, 0x42, 0x50, 0xf4, 0x91, 0xef, 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43, 0xed, 0xcf, 0xac, 0x62,
-	0xe4, 0xb3, 0x1c, 0xa9, 0xc9, 0x08, 0xe8, 0x95, 0x80, 0xdf, 0x94, 0xfa, 0x75, 0x8f, 0x3f, 0xa6,
-	0x47, 0x07, 0xa7, 0xfc, 0xf3, 0x73, 0x17, 0xba, 0x83, 0x59, 0x3c, 0x19, 0xe6, 0x85, 0x4f, 0xa8,
-	0x68, 0x6b, 0x81, 0xb2, 0x71, 0x64, 0xda, 0x8b, 0xf8, 0xeb, 0x0f, 0x4b, 0x70, 0x56, 0x9d, 0x35,
-	0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, 0xd1, 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, 0x87,
-	0xd4, 0x00, 0x46, 0x57, 0x9f, 0xd3, 0x27, 0x52, 0x4c, 0x36, 0x02, 0xe7, 0xa0, 0xc4, 0xc8, 0x9e,
-	0xea, 0xbf, 0x8a, 0xd2, 0x40, 0xc7, 0x38, 0xb5, 0xa3, 0xf7, 0xf2, 0xce, 0xf9, 0x61, 0x15, 0xa1,
-	0xe0, 0xae, 0x5d, 0xa4, 0x9b, 0x34, 0x1a, 0x55, 0xad, 0x93, 0x32, 0x30, 0xf5, 0x8c, 0xb1, 0xe3,
-	0x1d, 0xf6, 0xe2, 0x2e, 0x82, 0x66, 0xca, 0x60, 0xc0, 0x29, 0x23, 0xab, 0x0d, 0x53, 0x4e, 0x6f,
-	0xd5, 0xdb, 0x37, 0x45, 0xde, 0xfd, 0x8e, 0x2f, 0x03, 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b, 0x51,
-	0x8d, 0x1b, 0xaf, 0x92, 0xbb, 0xdd, 0xbc, 0x7f, 0x11, 0xd9, 0x5c, 0x41, 0x1f, 0x10, 0x5a, 0xd8,
-	0x0a, 0xc1, 0x31, 0x88, 0xa5, 0xcd, 0x7b, 0xbd, 0x2d, 0x74, 0xd0, 0x12, 0xb8, 0xe5, 0xb4, 0xb0,
-	0x89, 0x69, 0x97, 0x4a, 0x0c, 0x96, 0x77, 0x7e, 0x65, 0xb9, 0xf1, 0x09, 0xc5, 0x6e, 0xc6, 0x84,
-	0x18, 0xf0, 0x7d, 0xec, 0x3a, 0xdc, 0x4d, 0x20, 0x79, 0xee, 0x5f, 0x3e, 0xd7, 0xcb, 0x39, 0x48,
-}
-
-var sm4FK = [4]uint32{0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc}
-
-var sm4CK = [32]uint32{
-	0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,
-	0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
-	0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249,
-	0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,
-	0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229,
-	0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,
-	0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209,
-	0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279,
-}
-
-// 初始化预计算查找表
-func init() {
-	// Pre-compute all possible T1 and T2 transformations
-	for pos := 0; pos < 4; pos++ {
-		for i := 0; i < 256; i++ {
-			// S-box 替换
-			sboxVal := sm4Sbox[i]
-			
-			// 根据字节位置计算偏移
-			shift := uint32((3 - pos) * 8)
-			b := uint32(sboxVal) << shift
-			
-			// L1 变换：b ^ ROL(b,2) ^ ROL(b,10) ^ ROL(b,18) ^ ROL(b,24)
-			sm4T1Table[i][pos] = b ^ sm4RotateLeft(b, 2) ^ sm4RotateLeft(b, 10) ^ sm4RotateLeft(b, 18) ^ sm4RotateLeft(b, 24)
-			
-			// L2 变换：b ^ ROL(b,13) ^ ROL(b,23)
-			sm4T2Table[i][pos] = b ^ sm4RotateLeft(b, 13) ^ sm4RotateLeft(b, 23)
-		}
-	}
-}
-
-type sm4Cipher struct {
-	enc [32]uint32
-	dec [32]uint32
-}
-
-// Sm4EcbEncrypt encrypts data using SM4 in ECB mode.
-// key must be 16 bytes.
-// Play: https://go.dev/play/p/l5IQxYuuaED
-func Sm4EcbEncrypt(data, key []byte) []byte {
-	if len(key) != 16 {
-		panic("sm4: key length must be 16 bytes")
-	}
-
-	c := newSm4Cipher(key)
-	padded := pkcs7Padding(data, sm4BlockSize)
-	encrypted := make([]byte, len(padded))
-
-	for i := 0; i < len(padded); i += sm4BlockSize {
-		c.Encrypt(encrypted[i:i+sm4BlockSize], padded[i:i+sm4BlockSize])
-	}
-
-	return encrypted
-}
-
-// Sm4EcbDecrypt decrypts data using SM4 in ECB mode.
-// key must be 16 bytes.
-// Play: https://go.dev/play/p/l5IQxYuuaED
-func Sm4EcbDecrypt(encrypted, key []byte) []byte {
-	if len(key) != 16 {
-		panic("sm4: key length must be 16 bytes")
-	}
-
-	if len(encrypted)%sm4BlockSize != 0 {
-		panic("sm4: encrypted data length must be multiple of block size")
-	}
-
-	c := newSm4Cipher(key)
-	decrypted := make([]byte, len(encrypted))
-
-	for i := 0; i < len(encrypted); i += sm4BlockSize {
-		c.Decrypt(decrypted[i:i+sm4BlockSize], encrypted[i:i+sm4BlockSize])
-	}
-
-	return pkcs7UnPadding(decrypted)
-}
-
-// Sm4CbcEncrypt encrypts data using SM4 in CBC mode.
-// key must be 16 bytes.
-// Play: https://go.dev/play/p/65Q6iYhLRTa
-func Sm4CbcEncrypt(data, key []byte) []byte {
-	if len(key) != 16 {
-		panic("sm4: key length must be 16 bytes")
-	}
-
-	c := newSm4Cipher(key)
-	padded := pkcs7Padding(data, sm4BlockSize)
-
-	iv := make([]byte, sm4BlockSize)
-	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic("sm4: failed to generate IV: " + err.Error())
-	}
-
-	encrypted := make([]byte, len(padded))
-	mode := cipher.NewCBCEncrypter(c, iv)
-	mode.CryptBlocks(encrypted, padded)
-
-	return append(iv, encrypted...)
-}
-
-// Sm4CbcDecrypt decrypts data using SM4 in CBC mode.
-// key must be 16 bytes.
-// Play: https://go.dev/play/p/65Q6iYhLRTa
-func Sm4CbcDecrypt(encrypted, key []byte) []byte {
-	if len(key) != 16 {
-		panic("sm4: key length must be 16 bytes")
-	}
-
-	if len(encrypted) < sm4BlockSize {
-		panic("sm4: encrypted data too short")
-	}
-
-	if len(encrypted)%sm4BlockSize != 0 {
-		panic("sm4: encrypted data length must be multiple of block size")
-	}
-
-	c := newSm4Cipher(key)
-	iv := encrypted[:sm4BlockSize]
-	ciphertext := encrypted[sm4BlockSize:]
-
-	decrypted := make([]byte, len(ciphertext))
-	mode := cipher.NewCBCDecrypter(c, iv)
-	mode.CryptBlocks(decrypted, ciphertext)
-
-	return pkcs7UnPadding(decrypted)
-}
-
-func newSm4Cipher(key []byte) *sm4Cipher {
-	c := &sm4Cipher{}
-
-	var mk [4]uint32
-	for i := 0; i < 4; i++ {
-		mk[i] = binary.BigEndian.Uint32(key[i*4 : (i+1)*4])
-	}
-
-	var k [36]uint32
-	k[0] = mk[0] ^ sm4FK[0]
-	k[1] = mk[1] ^ sm4FK[1]
-	k[2] = mk[2] ^ sm4FK[2]
-	k[3] = mk[3] ^ sm4FK[3]
-
-	for i := 0; i < 32; i++ {
-		k[i+4] = k[i] ^ sm4T2Fast(k[i+1]^k[i+2]^k[i+3]^sm4CK[i])
-		c.enc[i] = k[i+4]
-	}
-
-	for i := 0; i < 32; i++ {
-		c.dec[i] = c.enc[31-i]
-	}
-
-	return c
-}
-
-func (c *sm4Cipher) BlockSize() int {
-	return sm4BlockSize
-}
-
-func (c *sm4Cipher) Encrypt(dst, src []byte) {
-	if len(src) < sm4BlockSize {
-		panic("sm4: input not full block")
-	}
-	if len(dst) < sm4BlockSize {
-		panic("sm4: output not full block")
-	}
-
-	// 使用局部变量避免数组分配，提升性能
-	x0 := binary.BigEndian.Uint32(src[0:4])
-	x1 := binary.BigEndian.Uint32(src[4:8])
-	x2 := binary.BigEndian.Uint32(src[8:12])
-	x3 := binary.BigEndian.Uint32(src[12:16])
-
-	// 32 轮加密
-	for i := 0; i < 32; i++ {
-		t := x1 ^ x2 ^ x3 ^ c.enc[i]
-		x0 ^= sm4T1Fast(t)
-		x0, x1, x2, x3 = x1, x2, x3, x0
-	}
-
-	binary.BigEndian.PutUint32(dst[0:4], x3)
-	binary.BigEndian.PutUint32(dst[4:8], x2)
-	binary.BigEndian.PutUint32(dst[8:12], x1)
-	binary.BigEndian.PutUint32(dst[12:16], x0)
-}
-
-func (c *sm4Cipher) Decrypt(dst, src []byte) {
-	if len(src) < sm4BlockSize {
-		panic("sm4: input not full block")
-	}
-	if len(dst) < sm4BlockSize {
-		panic("sm4: output not full block")
-	}
-
-	x0 := binary.BigEndian.Uint32(src[0:4])
-	x1 := binary.BigEndian.Uint32(src[4:8])
-	x2 := binary.BigEndian.Uint32(src[8:12])
-	x3 := binary.BigEndian.Uint32(src[12:16])
-
-	// 32 轮解密
-	for i := 0; i < 32; i++ {
-		t := x1 ^ x2 ^ x3 ^ c.dec[i]
-		x0 ^= sm4T1Fast(t)
-		x0, x1, x2, x3 = x1, x2, x3, x0
-	}
-
-	binary.BigEndian.PutUint32(dst[0:4], x3)
-	binary.BigEndian.PutUint32(dst[4:8], x2)
-	binary.BigEndian.PutUint32(dst[8:12], x1)
-	binary.BigEndian.PutUint32(dst[12:16], x0)
-}
-
-// 使用预计算查找表的快速 T1 变换（用于加密轮函数）
-func sm4T1Fast(a uint32) uint32 {
-	return sm4T1Table[byte(a>>24)][0] ^
-		sm4T1Table[byte(a>>16)][1] ^
-		sm4T1Table[byte(a>>8)][2] ^
-		sm4T1Table[byte(a)][3]
-}
-
-// 使用预计算查找表的快速 T2 变换（用于密钥扩展）
-func sm4T2Fast(a uint32) uint32 {
-	return sm4T2Table[byte(a>>24)][0] ^
-		sm4T2Table[byte(a>>16)][1] ^
-		sm4T2Table[byte(a>>8)][2] ^
-		sm4T2Table[byte(a)][3]
-}
-
-func sm4RotateLeft(x uint32, n uint32) uint32 {
-	return (x << n) | (x >> (32 - n))
-}

cryptor/gm_test.go

@@ -1,163 +0,0 @@
-package cryptor
-
-import (
-	"encoding/hex"
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestSm3(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSm3")
-
-	tests := []struct {
-		input    string
-		expected string
-	}{
-		{
-			input:    "abc",
-			expected: "66c7f0f462eeedd9d1f2d46bdc10e4e24167c4875cf2f7a2297da02b8f4ba8e0",
-		},
-		{
-			input:    "abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd",
-			expected: "debe9ff92275b8a138604889c18e5a4d6fdb70e5387e5765293dcba39c0c5732",
-		},
-		{
-			input:    "",
-			expected: "1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b",
-		},
-	}
-
-	for _, tt := range tests {
-		result := Sm3([]byte(tt.input))
-		resultHex := hex.EncodeToString(result)
-		assert.Equal(tt.expected, resultHex)
-	}
-}
-
-func TestSm4EcbEncryptDecrypt(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSm4EcbEncryptDecrypt")
-
-	key := []byte("1234567890abcdef") // 16 bytes
-	plaintext := []byte("Hello, SM4!")
-
-	// Encrypt
-	encrypted := Sm4EcbEncrypt(plaintext, key)
-	assert.IsNotNil(encrypted)
-
-	// Decrypt
-	decrypted := Sm4EcbDecrypt(encrypted, key)
-	assert.Equal(plaintext, decrypted)
-}
-
-func TestSm4CbcEncryptDecrypt(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSm4CbcEncryptDecrypt")
-
-	key := []byte("1234567890abcdef") // 16 bytes
-	plaintext := []byte("Hello, SM4 CBC mode!")
-
-	// Encrypt
-	encrypted := Sm4CbcEncrypt(plaintext, key)
-	assert.IsNotNil(encrypted)
-
-	// Decrypt
-	decrypted := Sm4CbcDecrypt(encrypted, key)
-	assert.Equal(plaintext, decrypted)
-}
-
-func TestSm4EcbWithLongData(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSm4EcbWithLongData")
-
-	key := []byte("1234567890abcdef")
-	plaintext := []byte("This is a longer message that spans multiple blocks for SM4 encryption testing.")
-
-	encrypted := Sm4EcbEncrypt(plaintext, key)
-	decrypted := Sm4EcbDecrypt(encrypted, key)
-
-	assert.Equal(plaintext, decrypted)
-}
-
-func TestSm2EncryptDecrypt(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSm2EncryptDecrypt")
-
-	// Generate key pair
-	privateKey, err := GenerateSm2Key()
-	assert.IsNil(err)
-	assert.IsNotNil(privateKey)
-
-	plaintext := []byte("Hello, SM2!")
-
-	// Encrypt with public key
-	ciphertext, err := Sm2Encrypt(&privateKey.PublicKey, plaintext)
-	assert.IsNil(err)
-	assert.IsNotNil(ciphertext)
-
-	// Decrypt with private key
-	decrypted, err := Sm2Decrypt(privateKey, ciphertext)
-	assert.IsNil(err)
-	assert.Equal(plaintext, decrypted)
-}
-
-func TestSm2WithLongData(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSm2WithLongData")
-
-	privateKey, err := GenerateSm2Key()
-	assert.IsNil(err)
-
-	plaintext := []byte("This is a longer message for SM2 encryption testing. " +
-		"SM2 is an elliptic curve public key cryptography algorithm.")
-
-	ciphertext, err := Sm2Encrypt(&privateKey.PublicKey, plaintext)
-	assert.IsNil(err)
-
-	decrypted, err := Sm2Decrypt(privateKey, ciphertext)
-	assert.IsNil(err)
-	assert.Equal(plaintext, decrypted)
-}
-
-func TestSm4InvalidKeyLength(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSm4InvalidKeyLength")
-
-	defer func() {
-		if r := recover(); r != nil {
-			assert.IsNotNil(r)
-		}
-	}()
-
-	key := []byte("short")
-	plaintext := []byte("test")
-	Sm4EcbEncrypt(plaintext, key) // Should panic
-}
-
-func TestSm2InvalidInput(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSm2InvalidInput")
-
-	// Test with nil public key
-	_, err := Sm2Encrypt(nil, []byte("test"))
-	assert.IsNotNil(err)
-
-	// Test with nil private key
-	_, err = Sm2Decrypt(nil, []byte("test"))
-	assert.IsNotNil(err)
-
-	// Test with invalid ciphertext
-	privateKey, _ := GenerateSm2Key()
-	_, err = Sm2Decrypt(privateKey, []byte("short"))
-	assert.IsNotNil(err)
-}

cryptor/rsa_private.pem

@@ -1,51 +0,0 @@
------BEGIN rsa private key-----
-MIIJKAIBAAKCAgEA5IqWfYbW1NlTDWE2plFWqD6CTquA0Ar/1E66lY8OMtrdpxTm
-chirmoISWN0BD7r2tV9T/kHs44Sy3raAfkR5ixYF5FRkb63FdIAtoynsxS6MEE26
-fgWuDAa1xwNt+t/uivnpfJk25htpBNkKGT8ii0TPPLn1N15hMHenT6PzWVjGjQxW
-cp4dUA4gXTDuqaeu7Oy7Ku2yP90/ra+cjTV8DnBJ9enQhAfu1LivJO3FgmXeuC3u
-qhhM3t9ZbNy7tvJI5PXDCaS8iesBvCp5carTSXWLpFEgvIhXQIsXtxezKAP3gRd8
-r5JPQI9FZlxyUcyf+Htkn2A4qyKhFElnP1z9j0YLFhL/gQMdtNIY7yhSb29PyuCG
-7noz25swrfxbA7ZVppM0J19JNhlpqmusBKLBNqN+KMD8EDli7NLX17S9Dj2pQF9I
-8fVXPEhkdTb67rr7y3OUANKjh0Opnt3JLoj9u1X7BfCeUSR/qq3E8RFPeyxvP1tc
-5QVqKBG6UPBo8nLQqdzJhUd8a1YEfXIUbdHLs2q5WVFu2MDavIp634+fzfcIFRoB
-tdxf5aCdxLaLocsA/aLLyL1pK6K0rpdrSUtcEBMST26qIlU0Ht+SQtaMdE2gyjkM
-M5RpLh1q/gpow+0j3zu6f5tDsu3qwgjLIx78YCTGUuCpsVMzFK4tahYSPNkCAwEA
-AQKCAgEAuXz97X2uCW0lqjtXhp+HrN+nFUC/OJtkziTj7RUBmibnNX+SFdKOHMYr
-K/KbtO+y4rwvSLKrGHIQVxBas6DR4SALwij4p2erVgXehIo3gEZqKaVckoH7pAki
-KhdPgQmU6zkw1w7nbtWaY/Pf7WO/nrdHV+s56ilwykyi/9F6Ze7Wn43+7+ICuoHs
-pJZdblcJc4Qj2RC41nq0/zwD3NwnBvT+IlgWA8MIhaArjtZospAJtwSYq3czlMRE
-KUXyGOcGYMZS+RW6bFnPu6/hh271M67ymne6ESq7XkhGBDV5FCY8EItGiJ1AM47U
-7eJkap2gzKUhovUOqV9eyz9UTComJETl2kmcjpZeaxrZZxtPap23IzBu6PJoPuDg
-hgzRWh3BrkakLdq6Km2z+jDFEQhWeHsksozuKzln5USx9wovb9LDKKFSpKm4vzW+
-7YVLZnH4Z1m4wvWQJShvZur7kkM7aNfK+xcS81OBMtqKerjWhdHqfMRVvLvtG/ev
-ftPTwRy+u02w+FoYcassTS+lW+Pnhj0ZuOewsWoNvgWg1TpPEDBkY4UJOYQPkTrS
-bixTBVI3teSjMXmjEAif+BG2LBCl7pFY5SW9Jk6eRvmxt9rEly13C+4tcBHEJnXu
-eVUMurRuB/9BAKgj4qGHPQlG455mKHQzWJxJXBpRurh+U478xm0CggEBAOgduMra
-tPDhyhy01iIAzYsh0PW9p11AcCoJkDUE/5IUf03fVt3WKdSNauHZBKTulqaCHkvz
-+pjmSwPr4JdJKcJzwk5ncResFBYF177JmYXzJzwpIPRQFNP34heaUd9cVsFckddV
-G3jR7c1vD33VElexUM94BubZFEqF2lO3/y0sLwhd7prKhwy6mctJyvyDFk02psDc
-6XzBG/sMiZ6meWA1sP4QIM6+sYdZ9ihvTNWGb1+TGojvgOHCEQ3Hv9u/qwdkzFKj
-qo25pRMV4VNMQUvYIywSB7K5c0w1ccfOINzB8kgqpHhpimAHqZw9ix4H98YmvaXS
-rr0LP8ES9xVvelcCggEBAPwOs7pWvm/R3RAXZ8Erk9x68Fsn8wzoofsGP/BG5QCC
-r1fDJr9aJAVggXOVNDktWRKkN7Cnib+Z7ymL5br3FfYPy945cF2e8nkx2ri0VveF
-glkPCFLb3lF3iLKD8nJNtiv1rpu2v4Dj09+SzQYSIF3h55BaZGUCHLskR7Mhdd74
-iTBzPaQ3NC+n0xrv8o1EXjy9w/nBt07sZojrf82Ae3mIbEFYdEHUVDaCZKKeBT4b
-9W8Q5aAt56DIkSkaBAZZZhzbfxollmeKiwJ32+finR7LZ1Fj2cTHia19Ef85U8bE
-Ow7E2cTDZkqaqgi+pFescl518DQ47PCeXfnFP0g65E8CggEAUApHubO3J0VE06dM
-G8eZGTwc+VBf0RkyVFyd3JqPoojs6SZ1puN94yysyZpzLoiTbHF8DwbfyC/JeF2z
-QZfaDZKrUyv6ZIZTGtEC92g/R2B0jBtGoNiohft5fFgbmWEXDXBlXhKb+YqybN+6
-QNLjk1eynQgvoRUEGTqU8b+F/8a3pTP23muuLCaAeAhHNdHiM9f/oovK+9j/VA+b
-uRiAzDtXgBSBq6k4QIs2BfVzUkIcT6HDSasFD1RDWzQhJZ6vVEpe5rRHUL3OfYlS
-/M1TytqKLl09SFUIvCPFy3d5/4XljRsfQeJq8/hQdW8HdOCcgTjEttSyqr+hSWvH
-xh192wKCAQB0uSY3u2XTCH9zrTMJ/HErn+7gd76REsW4JmvDjEEOHHawkJnH8SlP
-KCKqcMTPWZWvEUcM0njytolPVw6ap0OPQD9reHP1lt64iwK7mB/R3gy/yztSi6kH
-VvCBoqLKlfwvnUUvrNBAEsER/rxc/FXqw+tlKMbnE7RUYXeml28rQzLcsfEws7PC
-Adi717QeATQWstYnObL2pHjTHSOA+ee0Hx3qoNith3M8DuQlfkH1QiNFPLDpnXhv
-N5IpU3fbrNihsm/InvFon3rCONkoKAQUt6LvyOqWusSiB5Im+9g06rhinXwvJ0Ge
-eMMW65nVU/FelwUWWeo3f08LlHE6tLL3AoIBABcc549sTCMhBmQS9prESurzhPVk
-HCFYlR/GdlfNmRtTYssk25xaG+tiaEzXi7DXBq20TGNOATgoX7l9EWIRXkDuR6hS
-aRXyn+CVU3y2dhpGZBf+EUWP0u9TNSJ/RFO0ViAriL5J9kjF9hFvG36B9kRSiMrn
-mCp9NCdtRYOHjzkvbY5uRMqP8H4/nAXNMA+odPnOPDUOIcH2ztaFOtQgZxa9x/eS
-eGmnJ/V/rLvS04uVw5d7juJstEspnM4MxPHSFEDN7NG13bN+c1jTY1/85icIeRBi
-nP47M2kDQ6RrEdgYfPbdlx1wGdTUIeAm3duptTiwpwa5Q2Js22TMJYRTnbM=
------END rsa private key-----

cryptor/rsa_private_example.pem

@@ -1,51 +0,0 @@
------BEGIN rsa private key-----
-MIIJKQIBAAKCAgEAuzBz+aC+e7Lvny2zYlcyAfG6AAtPkxZqJ9JkYkM+0CP87pe0
-xOXQh4dz9iJekOwAq7FKpasUEUzkTm6Z0PUoj/TWY/xpoPNXXzz/5dz3u6r/A5Tu
-mJ6BmX/7K/x8FsokIeP+lWaN1l+7uBKK8rgfm4AZOXd/plzBkTrnu6lKG/rH9cnr
-2leKWDqk2jcG6r15r/07MdStpWgt0OBYoHzvjLJWmJ08VrnF9PFtWhL939xSAIic
-FzJ0T9fAdmSSYmg22mKgN1zeWtZndJ/Ejv+5YlWmuFJ8YKvwR0+4XIRLX9qsMy7q
-PTh7zsZhgtKzyb7qvVqDh2pmwekGJcwxGcoCLHLqNKf/dD+4vXxgS+f1ObfOcJpD
-qBajD/U6BXtrZ/p4cvoYnZA383YR/CRG/nJ8jIvt2FutT4hsNSd0L6c2mfo5mTno
-DOEL3mkreZ4Az+GE57jMw1Ia9jwkM1QQoy0a+kTiW8BedNqcRnVVGT9/OS/ggyKF
-wxJ/Xh1DfxZXAuyCBRUJUyVl9YCr2y30znguCdaTTViA9UbrjtcE2bZtnqOMAU2s
-08F0IiaGLKKMhrxUoXLgngXSX7gomC4aEfcg5hf7ft6FA+bXB9DHwGdv/UyrGr88
-nve5um1OT5kmyOujKpka4QZ5/rU+RznBE0UWDcHAyc+Zv+te0DqPUNcAW5ECAwEA
-AQKCAgBLJ0Do0Cip8UVTWz3SFb/2F97dda0VGMK2CjpTWTw2xLwf7ric9MesIi3k
-fBgLhzUduaiGqxD7gSuIcc8/na4TXfFVY1nlTM2fZxY2a2jq59RK09iXXcwanM9y
-8YPAgpfPI4Jq6Sm5D+aGGKvAlzvZaqy17cxKNqNgc43mQimG4kC15cPTfaIFmkXl
-doJIbJoWlkzVzNWKuzDp06jBhmeGzXMHAtne1+cqWGPW7hkPb51cqXxBs/gOtkiH
-QAmliMG9HCvHDnoXbk1K/XolD3aWjFzLVBKrnVxyxQb33gWFDn5kbkmNGshaVDuC
-EqYsMYJ9U4HLNGTdJXlaY4izGe+UyExET5p2KYKC9S34jMvR5k9Hf4pATSUYRhjL
-t/EV8EZlWCJGvGRAdtlKNLjRuIAiMTofUZca+sCHDvdcv8+/imOnKCXOETtcOHzw
-I7MRdIi2JigcBKuKaua9H77cEuvwG9Bb7aLbqQ3XM5JhoBEBe2jHG39GYDAAjEWz
-XWo2ri8rkU0nhixN26x7DXCfMewxZ/zc4czBTU2giM0Yrh4BMpRpHnw14QXRb58y
-eTD7GVrC9g1/6HXsAzzBfKyTMZhZhmfjcgSuYMUbzwIvvttJQtw5Ic/LJmR1Eg2F
-YZ3mUmwJwDEPyVlV2mXNUYYa64v7O3h+NsjXukWXw080fWdsoQKCAQEA8ZcVn863
-wXQVex7RcXs5frdnKEtHx6V6tXXq4tvK71Jbkny3gOmPqwwEF0fk4m2Fo07CmJkX
-t5o0tbPxfVbxeWGRGubAstjd5oWgt6nMAgcEkRbAzYM8qLGAGekS4g5+2/SjrQhG
-oR2phBv+T9w/Oglf6mVzc8YDNP9B0PB0CTICTYhej16Qhc/jpFmXkjXfslGlUp0F
-WVkNE7BZEk/fNgCbmAV1hCcDt7MwoOYBqGBoWb3tRKNhtBIDfJY1LVPjB6Jo3FWl
-nolJ1v1In9MhsNudZ6QlYbO8uMadsx3a1Flsu/w69TT+sPjmw+GoSzGuMlH15cFY
-qZZ6k75WmwyRGwKCAQEAxlq0SEK86+5zAIvVRQI5pQk0HEGy0dtcUgwBhpy13Bga
-sCezorJwS1tEHXfWYMtwmHytMXbySnFQEx5jJLFaQhPfOHybHV94fqq+qcC+NuEt
-z2KMoQG+zlupH5LwZv3RzzMSng0AuxNaiPx/tXfXM+5O19wb8VKu7X+hkgOW+psu
-wGnofT1zYTCWEbRPZENSL6Mi8BShwu3UIMFhKhVZJZH6MOSU/AoULv49ije39Z58
-B06IERBIGpM6FE6L73BHphbUh9Osr/I9vbi7zCzt/utQ1uzMzzxxJjjadYf1K7xa
-MYsmtKJ85+dG2/WOw6bRSGk1Dw9KqUBqHQ7bwXq8wwKCAQEAtrCwuotg69qzz8oL
-SgyL+uYIDTF4U2Iwu/4ypGDfQkD+XHURc1uruAY7JbvJOuzlbQxHHYxPohjrmSg9
-CrJvooGEcFplCBn1G7ibQ6gUTMgvzOPu4rpGaa7oly9ohye9COojx9qFRpsesHdW
-xd9gtKuYK7GSL89iZ3ZLuAvNQ5LcqPLhxvsUwQvnMkZJ11gEFF2nbiStgdZUjDoD
-8VQTEEw/XSNrrYavSgAoWtP0FvbokkyMmyYN4VTp7BHOnrtb6E8Jiuz9dDiPbRNW
-Ev5e8NXyXwiC+DIqGXSglm2SKJiDIFjp4Lm1i/B82U3QrSQhfY37LEYcnQndIdKC
-vXcwVwKCAQA0K2UhYFQ6JYQfz6dvOA+bRZlsGSeEJJLajYfVNOBsG/bhAAAyOYZp
-e36l1YAQA1IA+UHAMc22IKlz7dkbrH3VxU4/mB5gEl0py5TMJwKggoc+9WeRbVkX
-A2qvAEG0hOuq+H7cDQV1LrjwMKESRIvYf8RC6AR9a0bQ9nGzarhJ/4jDWNeqIQB4
-voOp8mezMjWqi9jDllmZYF4bo2D/5Y+F3ygTtfstcyUt2vaqpM8AjgeHEHOfMU4V
-l0V+U85gUoK1v2l0tArGWAs/HBhgsiyCkLe5X5zaoMYNzIRAx1qHf0mloDi058u8
-Xsr3TVWYRgbjabBn3pi/fU6rh93qvHJrAoIBAQCHNkNclB3UMBoZv2Dnd2ZwUZnP
-BzN6pq/NjG4GnjSCxPYwYnvB1TakTVLTYOjMS/7TCsFqPFSi93mjDsZ+0ZHBUZOH
-076AdxzFD+WxxYZ2+vl3iRhgERY3LgqHOBTt7O1/OYcNraJ6Pk2ppU/PqYaVb389
-2dsgqEEbO0np59I2+BP6giIFr3L2xKk2CRdVLKqCQ8FNx2xpi+1kcJlUW+ZxPiwu
-JaOA/mNHOz3Kq4DDE+1XjvKq602zm7D1oG67xM/gE5UV/KT7auI9M+zQcTPWZ3T6
-cl5A3z4tP9KdWJInadUQyOrVIHCbqxIlZCQjYFo2m9HzFr6fWbgtWC+IyGJQ
------END rsa private key-----

cryptor/rsa_public.pem

@@ -1,14 +0,0 @@
------BEGIN rsa public key-----
-MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA5IqWfYbW1NlTDWE2plFW
-qD6CTquA0Ar/1E66lY8OMtrdpxTmchirmoISWN0BD7r2tV9T/kHs44Sy3raAfkR5
-ixYF5FRkb63FdIAtoynsxS6MEE26fgWuDAa1xwNt+t/uivnpfJk25htpBNkKGT8i
-i0TPPLn1N15hMHenT6PzWVjGjQxWcp4dUA4gXTDuqaeu7Oy7Ku2yP90/ra+cjTV8
-DnBJ9enQhAfu1LivJO3FgmXeuC3uqhhM3t9ZbNy7tvJI5PXDCaS8iesBvCp5carT
-SXWLpFEgvIhXQIsXtxezKAP3gRd8r5JPQI9FZlxyUcyf+Htkn2A4qyKhFElnP1z9
-j0YLFhL/gQMdtNIY7yhSb29PyuCG7noz25swrfxbA7ZVppM0J19JNhlpqmusBKLB
-NqN+KMD8EDli7NLX17S9Dj2pQF9I8fVXPEhkdTb67rr7y3OUANKjh0Opnt3JLoj9
-u1X7BfCeUSR/qq3E8RFPeyxvP1tc5QVqKBG6UPBo8nLQqdzJhUd8a1YEfXIUbdHL
-s2q5WVFu2MDavIp634+fzfcIFRoBtdxf5aCdxLaLocsA/aLLyL1pK6K0rpdrSUtc
-EBMST26qIlU0Ht+SQtaMdE2gyjkMM5RpLh1q/gpow+0j3zu6f5tDsu3qwgjLIx78
-YCTGUuCpsVMzFK4tahYSPNkCAwEAAQ==
------END rsa public key-----

cryptor/rsa_public_example.pem

@@ -1,14 +0,0 @@
------BEGIN rsa public key-----
-MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAuzBz+aC+e7Lvny2zYlcy
-AfG6AAtPkxZqJ9JkYkM+0CP87pe0xOXQh4dz9iJekOwAq7FKpasUEUzkTm6Z0PUo
-j/TWY/xpoPNXXzz/5dz3u6r/A5TumJ6BmX/7K/x8FsokIeP+lWaN1l+7uBKK8rgf
-m4AZOXd/plzBkTrnu6lKG/rH9cnr2leKWDqk2jcG6r15r/07MdStpWgt0OBYoHzv
-jLJWmJ08VrnF9PFtWhL939xSAIicFzJ0T9fAdmSSYmg22mKgN1zeWtZndJ/Ejv+5
-YlWmuFJ8YKvwR0+4XIRLX9qsMy7qPTh7zsZhgtKzyb7qvVqDh2pmwekGJcwxGcoC
-LHLqNKf/dD+4vXxgS+f1ObfOcJpDqBajD/U6BXtrZ/p4cvoYnZA383YR/CRG/nJ8
-jIvt2FutT4hsNSd0L6c2mfo5mTnoDOEL3mkreZ4Az+GE57jMw1Ia9jwkM1QQoy0a
-+kTiW8BedNqcRnVVGT9/OS/ggyKFwxJ/Xh1DfxZXAuyCBRUJUyVl9YCr2y30zngu
-CdaTTViA9UbrjtcE2bZtnqOMAU2s08F0IiaGLKKMhrxUoXLgngXSX7gomC4aEfcg
-5hf7ft6FA+bXB9DHwGdv/UyrGr88nve5um1OT5kmyOujKpka4QZ5/rU+RznBE0UW
-DcHAyc+Zv+te0DqPUNcAW5ECAwEAAQ==
------END rsa public key-----

datastructure/hashmap/hashmap.go

@@ -1,217 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package datastructure implements some data structure. hashmap structure.
-package datastructure
-
-import (
-	"fmt"
-	"hash/fnv"
-	"reflect"
-)
-
-var defaultMapCapacity uint64 = 1 << 10
-
-type mapNode struct {
-	key   any
-	value any
-	next  *mapNode
-}
-
-// HashMap implements a hash map
-type HashMap struct {
-	capacity uint64
-	size     uint64
-	table    []*mapNode
-}
-
-// NewHashMap return a HashMap instance
-func NewHashMap() *HashMap {
-	return &HashMap{
-		capacity: defaultMapCapacity,
-		table:    make([]*mapNode, defaultMapCapacity),
-	}
-}
-
-// NewHashMapWithCapacity return a HashMap instance with given size and capacity
-func NewHashMapWithCapacity(size, capacity uint64) *HashMap {
-	return &HashMap{
-		size:     size,
-		capacity: capacity,
-		table:    make([]*mapNode, capacity),
-	}
-}
-
-// Get return the value of given key in hashmap
-func (hm *HashMap) Get(key any) any {
-	hashValue := hm.hash(key)
-	node := hm.table[hashValue]
-	for node != nil {
-		if reflect.DeepEqual(node.key, key) {
-			return node.value
-		}
-		node = node.next
-	}
-	return nil
-}
-
-// GetOrDefault return the value of given key in hashmap, if not found return default value
-func (hm *HashMap) GetOrDefault(key any, defaultValue any) any {
-	value := hm.Get(key)
-	if value == nil {
-		return defaultValue
-	}
-	return value
-}
-
-// Put new key value in hashmap
-func (hm *HashMap) Put(key any, value any) {
-	hm.putValue(hm.hash(key), key, value)
-}
-
-func (hm *HashMap) putValue(hash uint64, key, value any) {
-	if hm.capacity == 0 {
-		hm.capacity = defaultMapCapacity
-		hm.table = make([]*mapNode, defaultMapCapacity)
-	}
-
-	node := hm.table[hash]
-	if node == nil {
-		hm.table[hash] = newMapNode(key, value)
-	} else if node.key == key {
-		hm.table[hash] = newMapNodeWithNext(key, value, node)
-	} else {
-		hm.resize()
-		hm.putValue(hash, value, value)
-	}
-	hm.size++
-}
-
-// Delete item by given key in hashmap
-func (hm *HashMap) Delete(key any) {
-	hash := hm.hash(key)
-	node := hm.table[hash]
-	if node == nil {
-		return
-	}
-
-	hm.table = append(hm.table[:hash], hm.table[hash+1:]...)
-	hm.size--
-}
-
-// Contains checks if given key is in hashmap or not
-func (hm *HashMap) Contains(key any) bool {
-	node := hm.table[hm.hash(key)]
-	for node != nil {
-		if reflect.DeepEqual(node.key, key) {
-			return true
-		}
-		node = node.next
-	}
-	return false
-}
-
-// Iterate executes iteratee funcation for every key and value pair of hashmap (random order)
-func (hm *HashMap) Iterate(iteratee func(key, value any)) {
-	if hm.size > 0 {
-		for i := 0; i < len(hm.table); i++ {
-			item := hm.table[i]
-			if item != nil {
-				iteratee(item.key, item.value)
-			}
-		}
-	}
-}
-
-// FilterByValue returns a filtered HashMap.
-// If any value is not matching the perdicate function then it returns nil
-// otherwise it returns the HashMap with selected values.
-func (hm *HashMap) FilterByValue(perdicate func(value any) bool) *HashMap {
-	var filteredHM *HashMap
-	if hm.size > 0 {
-		for i := 0; i < len(hm.table); i++ {
-			item := hm.table[i]
-			if item != nil && perdicate(item.value) {
-				if filteredHM == nil {
-					filteredHM = NewHashMap()
-				}
-				filteredHM.Put(item.key, item.value)
-			}
-		}
-	}
-	return filteredHM
-}
-
-// Keys returns a slice of the hashmap's keys (random order)
-func (hm *HashMap) Keys() []any {
-	keys := make([]any, int(hm.size))
-	index := 0
-	if hm.size > 0 {
-		hm.Iterate(func(key, value any) {
-			keys[index] = key
-			index++
-		})
-	}
-
-	return keys
-}
-
-// Values returns a slice of the hashmap's keys (random order)
-func (hm *HashMap) Values() []any {
-	values := make([]any, int(hm.size))
-	index := 0
-	if hm.size > 0 {
-		hm.Iterate(func(key, value any) {
-			values[index] = value
-			index++
-		})
-	}
-
-	return values
-}
-
-func (hm *HashMap) resize() {
-	hm.capacity <<= 1
-
-	tempTable := hm.table
-
-	hm.table = make([]*mapNode, hm.capacity)
-
-	for i := 0; i < len(tempTable); i++ {
-		node := tempTable[i]
-		if node == nil {
-			continue
-		}
-
-		hm.table[hm.hash(node.key)] = node
-	}
-}
-
-// Size returns current size of Hashmap
-func (hm *HashMap) Size() uint64 {
-	return hm.size
-}
-
-func (hm *HashMap) hash(key any) uint64 {
-	h := fnv.New64a()
-	_, _ = h.Write([]byte(fmt.Sprintf("%v", key)))
-
-	hashValue := h.Sum64()
-
-	return (hm.capacity - 1) & (hashValue ^ (hashValue >> 16))
-}
-
-func newMapNode(key, value any) *mapNode {
-	return &mapNode{
-		key:   key,
-		value: value,
-	}
-}
-
-func newMapNodeWithNext(key, value any, next *mapNode) *mapNode {
-	return &mapNode{
-		key:   key,
-		value: value,
-		next:  next,
-	}
-}

datastructure/hashmap/hashmap_test.go

@@ -1,128 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestHashMap_PutAndGet(t *testing.T) {
-	assert := internal.NewAssert(t, "TestHashMap_PutAndGet")
-
-	hm := NewHashMap()
-
-	hm.Put("abc", 3)
-	assert.Equal(3, hm.Get("abc"))
-	assert.IsNil(hm.Get("abcd"))
-
-	hm.Put("abc", 4)
-	assert.Equal(4, hm.Get("abc"))
-}
-
-func TestHashMap_Resize(t *testing.T) {
-	assert := internal.NewAssert(t, "TestHashMap_Resize")
-
-	hm := NewHashMapWithCapacity(3, 3)
-
-	for i := 0; i < 20; i++ {
-		hm.Put(i, 10)
-	}
-
-	assert.Equal(10, hm.Get(5))
-}
-
-func TestHashMap_Delete(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestHashMap_Delete")
-
-	hm := NewHashMap()
-
-	hm.Put("abc", 3)
-	assert.Equal(3, hm.Get("abc"))
-
-	hm.Delete("abc")
-	assert.IsNil(hm.Get("abc"))
-}
-
-func TestHashMap_Contains(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestHashMap_Contains")
-
-	hm := NewHashMap()
-	assert.Equal(false, hm.Contains("abc"))
-
-	hm.Put("abc", 3)
-	assert.Equal(true, hm.Contains("abc"))
-}
-
-func TestHashMap_KeysValues(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestHashMap_KeysValues")
-
-	hm := NewHashMap()
-
-	hm.Put("a", 1)
-	hm.Put("b", 2)
-	hm.Put("c", 3)
-
-	keys := hm.Keys()
-	values := hm.Values()
-
-	assert.Equal(3, len(values))
-	assert.Equal(3, len(keys))
-}
-
-func TestHashMap_Keys(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestHashMap_Keys")
-
-	hm := NewHashMap()
-
-	hm.Put("a", 1)
-	hm.Put("b", 2)
-	hm.Put("c", 3)
-
-	keys := hm.Keys()
-
-	assert.Equal(3, len(keys))
-}
-
-func TestHashMap_GetOrDefault(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestHashMap_GetOrDefault")
-
-	hm := NewHashMap()
-
-	hm.Put("a", 1)
-	hm.Put("b", 2)
-	hm.Put("c", 3)
-
-	assert.Equal(1, hm.GetOrDefault("a", 5))
-	assert.Equal(5, hm.GetOrDefault("d", 5))
-}
-
-func TestHashMap_FilterByValue(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestHashMap_FilterByValue")
-
-	hm := NewHashMap()
-
-	hm.Put("a", 1)
-	hm.Put("b", 2)
-	hm.Put("c", 3)
-	hm.Put("d", 4)
-	hm.Put("e", 5)
-	hm.Put("f", 6)
-
-	filteredHM := hm.FilterByValue(func(value any) bool {
-		return value.(int) == 1 || value.(int) == 3
-	})
-
-	assert.Equal(uint64(2), filteredHM.Size())
-}

datastructure/heap/maxheap.go

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

datastructure/heap/maxheap_test.go

@@ -1,98 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-type intComparator struct{}
-
-func (c *intComparator) Compare(v1, v2 any) int {
-	val1, _ := v1.(int)
-	val2, _ := v2.(int)
-
-	if val1 < val2 {
-		return -1
-	} else if val1 > val2 {
-		return 1
-	}
-	return 0
-}
-
-func TestMaxHeap_BuildMaxHeap(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestMaxHeap_BuildMaxHeap")
-
-	values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
-	heap := BuildMaxHeap(values, &intComparator{})
-
-	expected := []int{12, 9, 11, 4, 8, 10, 7, 1, 3, 5, 6, 2}
-	assert.Equal(expected, heap.data)
-
-	assert.Equal(12, heap.Size())
-}
-
-func TestMaxHeap_Push(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestMaxHeap_Push")
-
-	heap := NewMaxHeap[int](&intComparator{})
-	values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
-
-	for _, v := range values {
-		heap.Push(v)
-	}
-
-	expected := []int{12, 9, 11, 4, 8, 10, 7, 1, 3, 5, 6, 2}
-	assert.Equal(expected, heap.data)
-
-	assert.Equal(12, heap.Size())
-
-	heap.PrintStructure()
-}
-
-func TestMaxHeap_Pop(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestMaxHeap_Pop")
-
-	heap := NewMaxHeap[int](&intComparator{})
-
-	_, ok := heap.Pop()
-	assert.Equal(false, ok)
-
-	values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
-	for _, v := range values {
-		heap.Push(v)
-	}
-
-	val, ok := heap.Pop()
-	assert.Equal(12, val)
-	assert.Equal(true, ok)
-	assert.Equal(11, heap.Size())
-}
-
-func TestMaxHeap_Peek(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestMaxHeap_Peek")
-
-	heap := NewMaxHeap[int](&intComparator{})
-
-	_, ok := heap.Peek()
-	assert.Equal(false, ok)
-
-	values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
-	for _, v := range values {
-		heap.Push(v)
-	}
-
-	val, ok := heap.Peek()
-	assert.Equal(12, val)
-	assert.Equal(true, ok)
-
-	assert.Equal(12, heap.Size())
-}

datastructure/link/doublylink.go

@@ -1,242 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package datastructure contains some data structure. Link structure contains SinglyLink and DoublyLink.
-package datastructure
-
-import (
-	"fmt"
-
-	"github.com/duke-git/lancet/v2/datastructure"
-)
-
-// DoublyLink is a linked list. Whose node has a generic Value, Pre pointer points to a previous node of the dl, Next pointer points to a next node of the dl.
-type DoublyLink[T any] struct {
-	Head   *datastructure.LinkNode[T]
-	length int
-}
-
-// NewDoublyLink return *DoublyLink instance
-func NewDoublyLink[T any]() *DoublyLink[T] {
-	return &DoublyLink[T]{Head: nil}
-}
-
-// InsertAtHead insert value into doubly linklist at head index
-func (dl *DoublyLink[T]) InsertAtHead(value T) {
-	newNode := datastructure.NewLinkNode(value)
-	size := dl.Size()
-
-	if size == 0 {
-		dl.Head = newNode
-		dl.length++
-		return
-	}
-
-	newNode.Next = dl.Head
-	newNode.Pre = nil
-
-	dl.Head.Pre = newNode
-	dl.Head = newNode
-
-	dl.length++
-}
-
-// InsertAtTail insert value into doubly linklist at tail index
-func (dl *DoublyLink[T]) InsertAtTail(value T) {
-	current := dl.Head
-	if current == nil {
-		dl.InsertAtHead(value)
-		return
-	}
-
-	for current.Next != nil {
-		current = current.Next
-	}
-
-	newNode := datastructure.NewLinkNode(value)
-	newNode.Next = nil
-	newNode.Pre = current
-	current.Next = newNode
-
-	dl.length++
-}
-
-// InsertAt insert value into doubly linklist at index
-// param `index` should between [0, length], if index do not meet the conditions, do nothing
-func (dl *DoublyLink[T]) InsertAt(index int, value T) {
-	size := dl.length
-	if index < 0 || index > size {
-		return
-	}
-
-	if index == 0 {
-		dl.InsertAtHead(value)
-		return
-	}
-
-	if index == size {
-		dl.InsertAtTail(value)
-		return
-	}
-
-	i := 0
-	current := dl.Head
-
-	for current != nil {
-		if i == index-1 {
-			newNode := datastructure.NewLinkNode(value)
-			newNode.Next = current.Next
-			newNode.Pre = current
-
-			current.Next = newNode
-			dl.length++
-
-			return
-		}
-		i++
-		current = current.Next
-	}
-}
-
-// DeleteAtHead delete value in doubly linklist at head index
-func (dl *DoublyLink[T]) DeleteAtHead() {
-	if dl.Head == nil {
-		return
-	}
-
-	current := dl.Head
-	dl.Head = current.Next
-	dl.Head.Pre = nil
-	dl.length--
-}
-
-// DeleteAtTail delete value in doubly linklist at tail
-func (dl *DoublyLink[T]) DeleteAtTail() {
-	if dl.Head == nil {
-		return
-	}
-
-	current := dl.Head
-	if current.Next == nil {
-		dl.DeleteAtHead()
-	}
-
-	for current.Next.Next != nil {
-		current = current.Next
-	}
-
-	current.Next = nil
-	dl.length--
-}
-
-// DeleteAt delete value in doubly linklist at index
-// param `index` should be [0, len(DoublyLink)-1]
-func (dl *DoublyLink[T]) DeleteAt(index int) {
-	if dl.Head == nil {
-		return
-	}
-
-	current := dl.Head
-	if current.Next == nil || index == 0 {
-		dl.DeleteAtHead()
-	}
-
-	if index == dl.length-1 {
-		dl.DeleteAtTail()
-	}
-
-	if index < 0 || index > dl.length-1 {
-		return
-	}
-
-	i := 0
-	for current != nil {
-		if i == index-1 {
-			current.Next = current.Next.Next
-			dl.length--
-			return
-		}
-		i++
-		current = current.Next
-	}
-}
-
-// Reverse the linked list
-func (dl *DoublyLink[T]) Reverse() {
-	current := dl.Head
-	var temp *datastructure.LinkNode[T]
-
-	for current != nil {
-		temp = current.Pre
-		current.Pre = current.Next
-		current.Next = temp
-		current = current.Pre
-	}
-
-	if temp != nil {
-		dl.Head = temp.Pre
-	}
-}
-
-// GetMiddleNode return node at middle index of linked list
-func (dl *DoublyLink[T]) GetMiddleNode() *datastructure.LinkNode[T] {
-	if dl.Head == nil {
-		return nil
-	}
-	if dl.Head.Next == nil {
-		return dl.Head
-	}
-	fast := dl.Head
-	slow := dl.Head
-
-	for fast != nil {
-		fast = fast.Next
-
-		if fast != nil {
-			fast = fast.Next
-			slow = slow.Next
-		} else {
-			return slow
-		}
-	}
-	return slow
-}
-
-// Size return the count of doubly linked list
-func (dl *DoublyLink[T]) Size() int {
-	return dl.length
-}
-
-// Values return slice of all doubly linklist node value
-func (dl *DoublyLink[T]) Values() []T {
-	result := make([]T, 0, dl.length)
-	current := dl.Head
-	for current != nil {
-		result = append(result, current.Value)
-		current = current.Next
-	}
-	return result
-}
-
-// Print all nodes info of a linked list
-func (dl *DoublyLink[T]) Print() {
-	current := dl.Head
-	info := "[ "
-	for current != nil {
-		info += fmt.Sprintf("%+v, ", current)
-		current = current.Next
-	}
-	info += " ]"
-	fmt.Println(info)
-}
-
-// IsEmpty checks if dl is empty or not
-func (dl *DoublyLink[T]) IsEmpty() bool {
-	return dl.length == 0
-}
-
-// Clear all nodes in doubly linklist
-func (dl *DoublyLink[T]) Clear() {
-	dl.Head = nil
-	dl.length = 0
-}

datastructure/link/doublylink_test.go

@@ -1,181 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestDoublyLink_InsertAtFirst(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestDoublyLink_InsertAtFirst")
-
-	link := NewDoublyLink[int]()
-	link.InsertAtHead(1)
-	link.InsertAtHead(2)
-	link.InsertAtHead(3)
-	link.Print()
-
-	expected := []int{3, 2, 1}
-	values := link.Values()
-
-	assert.Equal(expected, values)
-}
-
-func TestDoublyLink_InsertAtTail(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestDoublyLink_InsertAtTail")
-
-	link := NewDoublyLink[int]()
-	link.InsertAtTail(1)
-	link.InsertAtTail(2)
-	link.InsertAtTail(3)
-	link.Print()
-
-	expected := []int{1, 2, 3}
-	values := link.Values()
-
-	assert.Equal(expected, values)
-}
-
-func TestDoublyLink_InsertAt(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestDoublyLink_InsertAt")
-
-	link := NewDoublyLink[int]()
-	link.InsertAt(1, 1) //do nothing
-	link.InsertAt(0, 1)
-	link.InsertAt(1, 2)
-	link.InsertAt(2, 4)
-	link.InsertAt(2, 3)
-
-	expected := []int{1, 2, 3, 4}
-	values := link.Values()
-
-	assert.Equal(expected, values)
-}
-
-func TestDoublyLink_DeleteAtHead(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestDoublyLink_DeleteAtHead")
-
-	link := NewDoublyLink[int]()
-	link.DeleteAtHead()
-
-	link.InsertAtTail(1)
-	link.InsertAtTail(2)
-	link.InsertAtTail(3)
-	link.InsertAtTail(4)
-
-	link.DeleteAtHead()
-
-	expected := []int{2, 3, 4}
-	values := link.Values()
-
-	assert.Equal(expected, values)
-}
-
-func TestDoublyLink_DeleteAtTail(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestDoublyLink_DeleteAtTail")
-
-	link := NewDoublyLink[int]()
-	link.DeleteAtTail()
-
-	link.InsertAtTail(1)
-	link.InsertAtTail(2)
-	link.InsertAtTail(3)
-	link.InsertAtTail(4)
-
-	link.DeleteAtTail()
-
-	expected := []int{1, 2, 3}
-	values := link.Values()
-
-	assert.Equal(expected, values)
-}
-
-func TestDoublyLink_DeleteAt(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestDoublyLink_DeleteAt")
-
-	link := NewDoublyLink[int]()
-	link.DeleteAt(0)
-
-	link.InsertAtTail(1)
-	link.InsertAtTail(2)
-	link.InsertAtTail(3)
-	link.InsertAtTail(4)
-	link.InsertAtTail(5)
-
-	link.DeleteAt(0)
-	assert.Equal([]int{2, 3, 4, 5}, link.Values())
-
-	link.DeleteAt(3)
-	assert.Equal([]int{2, 3, 4}, link.Values())
-
-	link.DeleteAt(1)
-	assert.Equal(2, link.Size())
-	assert.Equal([]int{2, 4}, link.Values())
-}
-
-func TestDoublyLink_Reverse(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestDoublyLink_Reverse")
-
-	link := NewDoublyLink[int]()
-	link.InsertAtTail(1)
-	link.InsertAtTail(2)
-	link.InsertAtTail(3)
-	link.InsertAtTail(4)
-
-	link.Reverse()
-	link.Print()
-	assert.Equal([]int{4, 3, 2, 1}, link.Values())
-}
-
-func TestDoublyLink_GetMiddleNode(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestDoublyLink_GetMiddleNode")
-
-	link := NewDoublyLink[int]()
-	link.InsertAtTail(1)
-	link.InsertAtTail(2)
-	link.InsertAtTail(3)
-	link.InsertAtTail(4)
-
-	middle1 := link.GetMiddleNode()
-	assert.Equal(3, middle1.Value)
-
-	link.InsertAtTail(5)
-	link.InsertAtTail(6)
-	link.InsertAtTail(7)
-	middle2 := link.GetMiddleNode()
-	assert.Equal(4, middle2.Value)
-}
-
-func TestDoublyLink_Clear(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestDoublyLink_Clear")
-
-	link := NewDoublyLink[int]()
-	assert.Equal(true, link.IsEmpty())
-	assert.Equal(0, link.Size())
-
-	link.InsertAtTail(1)
-	assert.Equal(false, link.IsEmpty())
-	assert.Equal(1, link.Size())
-
-	link.Clear()
-	assert.Equal(true, link.IsEmpty())
-	assert.Equal(0, link.Size())
-}

datastructure/link/singlylink.go

@@ -1,245 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package datastructure contains some data structure. Link structure contains SinglyLink and DoublyLink.
-package datastructure
-
-import (
-	"fmt"
-	"reflect"
-
-	"github.com/duke-git/lancet/v2/datastructure"
-)
-
-// SinglyLink is a linked list. Whose node has a Value generics and Next pointer points to a next node of the sl.
-type SinglyLink[T any] struct {
-	Head   *datastructure.LinkNode[T]
-	length int
-}
-
-// NewSinglyLink return *SinglyLink instance
-func NewSinglyLink[T any]() *SinglyLink[T] {
-	return &SinglyLink[T]{Head: nil}
-}
-
-// InsertAtHead insert value into singly linklist at head index
-func (sl *SinglyLink[T]) InsertAtHead(value T) {
-	newNode := datastructure.NewLinkNode(value)
-	newNode.Next = sl.Head
-	sl.Head = newNode
-	sl.length++
-}
-
-// InsertAtTail insert value into singly linklist at tail index
-func (sl *SinglyLink[T]) InsertAtTail(value T) {
-	current := sl.Head
-	if current == nil {
-		sl.InsertAtHead(value)
-		return
-	}
-
-	for current.Next != nil {
-		current = current.Next
-	}
-
-	newNode := datastructure.NewLinkNode(value)
-	newNode.Next = nil
-	current.Next = newNode
-
-	sl.length++
-}
-
-// InsertAt insert value into singly linklist at index
-// param `index` should between [0, len(SinglyLink)], if index do not meet the conditions, do nothing
-func (sl *SinglyLink[T]) InsertAt(index int, value T) {
-	size := sl.length
-	if index < 0 || index > size {
-		return
-	}
-
-	if index == 0 {
-		sl.InsertAtHead(value)
-		return
-	}
-
-	if index == size {
-		sl.InsertAtTail(value)
-		return
-	}
-
-	i := 0
-	current := sl.Head
-
-	for current != nil {
-		if i == index-1 {
-			newNode := datastructure.NewLinkNode(value)
-			newNode.Next = current.Next
-			current.Next = newNode
-			sl.length++
-			return
-		}
-		i++
-		current = current.Next
-	}
-}
-
-// DeleteAtHead delete value in singly linklist at head index
-func (sl *SinglyLink[T]) DeleteAtHead() {
-	if sl.Head == nil {
-		return
-	}
-
-	current := sl.Head
-	sl.Head = current.Next
-	sl.length--
-}
-
-// DeleteAtTail delete value in singly linklist at tail
-func (sl *SinglyLink[T]) DeleteAtTail() {
-	if sl.Head == nil {
-		return
-	}
-
-	current := sl.Head
-	if current.Next == nil {
-		sl.DeleteAtHead()
-	}
-
-	for current.Next.Next != nil {
-		current = current.Next
-	}
-
-	current.Next = nil
-	sl.length--
-}
-
-// DeleteAt delete value in singly linklist at index
-// param `index` should be [0, len(SinglyLink)-1]
-func (sl *SinglyLink[T]) DeleteAt(index int) {
-	if sl.Head == nil {
-		return
-	}
-	current := sl.Head
-	if current.Next == nil || index == 0 {
-		sl.DeleteAtHead()
-	}
-
-	if index == sl.length-1 {
-		sl.DeleteAtTail()
-	}
-
-	if index < 0 || index > sl.length-1 {
-		return
-	}
-
-	i := 0
-	for current != nil {
-		if i == index-1 {
-			current.Next = current.Next.Next
-			sl.length--
-			return
-		}
-		i++
-		current = current.Next
-	}
-}
-
-// DeleteValue delete value in singly linklist
-func (sl *SinglyLink[T]) DeleteValue(value T) {
-	if sl.Head == nil {
-		return
-	}
-	dummyHead := datastructure.NewLinkNode(value)
-	dummyHead.Next = sl.Head
-	current := dummyHead
-
-	for current.Next != nil {
-		if reflect.DeepEqual(current.Next.Value, value) {
-			current.Next = current.Next.Next
-			sl.length--
-		} else {
-			current = current.Next
-		}
-	}
-
-	sl.Head = dummyHead.Next
-}
-
-// Reverse the linked list
-func (sl *SinglyLink[T]) Reverse() {
-	var pre, next *datastructure.LinkNode[T]
-
-	current := sl.Head
-
-	for current != nil {
-		next = current.Next
-		current.Next = pre
-		pre = current
-		current = next
-	}
-
-	sl.Head = pre
-}
-
-// GetMiddleNode return node at middle index of linked list
-func (sl *SinglyLink[T]) GetMiddleNode() *datastructure.LinkNode[T] {
-	if sl.Head == nil {
-		return nil
-	}
-	if sl.Head.Next == nil {
-		return sl.Head
-	}
-	fast := sl.Head
-	slow := sl.Head
-
-	for fast != nil {
-		fast = fast.Next
-
-		if fast != nil {
-			fast = fast.Next
-			slow = slow.Next
-		} else {
-			return slow
-		}
-	}
-	return slow
-}
-
-// Size return the count of singly linked list
-func (sl *SinglyLink[T]) Size() int {
-	return sl.length
-}
-
-// Values return slice of all singly linklist node value
-func (sl *SinglyLink[T]) Values() []T {
-	result := make([]T, 0, sl.length)
-	current := sl.Head
-	for current != nil {
-		result = append(result, current.Value)
-		current = current.Next
-	}
-	return result
-}
-
-// IsEmpty checks if sl is empty or not
-func (sl *SinglyLink[T]) IsEmpty() bool {
-	return sl.length == 0
-}
-
-// Clear all the node in singly linklist
-func (sl *SinglyLink[T]) Clear() {
-	sl.Head = nil
-	sl.length = 0
-}
-
-// Print all nodes info of a linked list
-func (sl *SinglyLink[T]) Print() {
-	current := sl.Head
-	info := "[ "
-	for current != nil {
-		info += fmt.Sprintf("%+v, ", current)
-		current = current.Next
-	}
-	info += " ]"
-	fmt.Println(info)
-}

datastructure/link/singlylink_test.go

@@ -1,198 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestSinglyLink_InsertAtFirst(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSinglyLink_InsertAtFirst")
-
-	link := NewSinglyLink[int]()
-	link.InsertAtHead(1)
-	link.InsertAtHead(2)
-	link.InsertAtHead(3)
-
-	expected := []int{3, 2, 1}
-	values := link.Values()
-
-	assert.Equal(expected, values)
-}
-
-func TestSinglyLink_InsertAtTail(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSinglyLink_InsertAtTail")
-
-	link := NewSinglyLink[int]()
-	link.InsertAtTail(1)
-	link.InsertAtTail(2)
-	link.InsertAtTail(3)
-
-	expected := []int{1, 2, 3}
-	values := link.Values()
-
-	assert.Equal(expected, values)
-}
-
-func TestSinglyLink_InsertAt(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSinglyLink_InsertAt")
-
-	link := NewSinglyLink[int]()
-
-	link.InsertAt(1, 1) //do nothing
-
-	link.InsertAt(0, 1)
-	link.InsertAt(1, 2)
-	link.InsertAt(2, 4)
-	link.InsertAt(2, 3)
-
-	link.Print()
-
-	expected := []int{1, 2, 3, 4}
-	values := link.Values()
-
-	assert.Equal(expected, values)
-}
-
-func TestSinglyLink_DeleteAtHead(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSinglyLink_DeleteAtHead")
-
-	link := NewSinglyLink[int]()
-
-	link.DeleteAtHead()
-
-	link.InsertAtTail(1)
-	link.InsertAtTail(2)
-	link.InsertAtTail(3)
-	link.InsertAtTail(4)
-
-	link.DeleteAtHead()
-
-	expected := []int{2, 3, 4}
-	values := link.Values()
-
-	assert.Equal(expected, values)
-}
-
-func TestSinglyLink_DeleteAtTail(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSinglyLink_DeleteAtTail")
-
-	link := NewSinglyLink[int]()
-	link.InsertAtTail(1)
-	link.InsertAtTail(2)
-	link.InsertAtTail(3)
-	link.InsertAtTail(4)
-
-	link.DeleteAtTail()
-
-	expected := []int{1, 2, 3}
-	values := link.Values()
-
-	assert.Equal(expected, values)
-}
-
-func TestSinglyLink_DeleteValue(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSinglyLink_DeleteValue")
-
-	link := NewSinglyLink[int]()
-	link.InsertAtTail(1)
-	link.InsertAtTail(2)
-	link.InsertAtTail(2)
-	link.InsertAtTail(3)
-	link.InsertAtTail(4)
-
-	link.DeleteValue(2)
-	assert.Equal([]int{1, 3, 4}, link.Values())
-
-	link.DeleteValue(1)
-	assert.Equal([]int{3, 4}, link.Values())
-}
-
-func TestSinglyLink_DeleteAt(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSinglyLink_DeleteAt")
-
-	link := NewSinglyLink[int]()
-	link.InsertAtTail(1)
-	link.InsertAtTail(2)
-	link.InsertAtTail(3)
-	link.InsertAtTail(4)
-	link.InsertAtTail(5)
-
-	link.DeleteAt(0)
-	assert.Equal([]int{2, 3, 4, 5}, link.Values())
-
-	link.DeleteAt(3)
-	assert.Equal([]int{2, 3, 4}, link.Values())
-
-	link.DeleteAt(1)
-	assert.Equal(2, link.Size())
-	assert.Equal([]int{2, 4}, link.Values())
-}
-
-func TestSinglyLink_Reverse(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSinglyLink_Reverse")
-
-	link := NewSinglyLink[int]()
-	link.InsertAtTail(1)
-	link.InsertAtTail(2)
-	link.InsertAtTail(3)
-	link.InsertAtTail(4)
-
-	link.Reverse()
-	assert.Equal([]int{4, 3, 2, 1}, link.Values())
-}
-
-func TestSinglyLink_GetMiddleNode(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSinglyLink_GetMiddleNode")
-
-	link := NewSinglyLink[int]()
-	link.InsertAtTail(1)
-	link.InsertAtTail(2)
-	link.InsertAtTail(3)
-	link.InsertAtTail(4)
-
-	middle1 := link.GetMiddleNode()
-	assert.Equal(3, middle1.Value)
-
-	link.InsertAtTail(5)
-	link.InsertAtTail(6)
-	link.InsertAtTail(7)
-
-	middle2 := link.GetMiddleNode()
-	assert.Equal(4, middle2.Value)
-}
-
-func TestSinglyLink_Clear(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSinglyLink_Clear")
-
-	link := NewSinglyLink[int]()
-
-	assert.Equal(true, link.IsEmpty())
-	assert.Equal(0, link.Size())
-
-	link.InsertAtTail(1)
-	assert.Equal(false, link.IsEmpty())
-	assert.Equal(1, link.Size())
-
-	link.Clear()
-	assert.Equal(true, link.IsEmpty())
-	assert.Equal(0, link.Size())
-}

datastructure/list/copyonwritelist.go

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

datastructure/list/copyonwritelist_test.go

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

datastructure/list/list.go

@@ -1,418 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package datastructure contains some data structure. list is a linear table, implemented with slice.
-package datastructure
-
-import (
-	"reflect"
-
-	"github.com/duke-git/lancet/v2/iterator"
-)
-
-// List is a linear table, implemented with slice.
-type List[T any] struct {
-	data []T
-}
-
-// NewList return a pointer of List.
-func NewList[T any](data []T) *List[T] {
-	return &List[T]{data: data}
-}
-
-// Data return list data.
-func (l *List[T]) Data() []T {
-	return l.data
-}
-
-// ValueOf return the value pointer at index of list data.
-func (l *List[T]) ValueOf(index int) (*T, bool) {
-	if index < 0 || index >= len(l.data) {
-		return nil, false
-	}
-	return &l.data[index], true
-}
-
-// IndexOf returns the index of value. if not found return -1.
-func (l *List[T]) IndexOf(value T) int {
-	index := -1
-	data := l.data
-	for i, v := range data {
-		if reflect.DeepEqual(v, value) {
-			index = i
-			break
-		}
-	}
-	return index
-}
-
-// LastIndexOf returns the index of the last occurrence of the value in this list.
-// if not found return -1.
-func (l *List[T]) LastIndexOf(value T) int {
-	index := -1
-	data := l.data
-	for i := len(data) - 1; i >= 0; i-- {
-		if reflect.DeepEqual(data[i], value) {
-			index = i
-			break
-		}
-	}
-	return index
-}
-
-// IndexOfFunc returns the first index satisfying f(v)
-// if not found return -1.
-func (l *List[T]) IndexOfFunc(f func(T) bool) int {
-	index := -1
-	data := l.data
-	for i, v := range data {
-		if f(v) {
-			index = i
-			break
-		}
-	}
-	return index
-}
-
-// LastIndexOfFunc returns the index of the last occurrence of the value in this list satisfying f(data[i])
-// if not found return -1.
-func (l *List[T]) LastIndexOfFunc(f func(T) bool) int {
-	index := -1
-	data := l.data
-	for i := len(data) - 1; i >= 0; i-- {
-		if f(data[i]) {
-			index = i
-			break
-		}
-	}
-	return index
-}
-
-// Contain checks if the value in the list or not.
-func (l *List[T]) Contain(value T) bool {
-	data := l.data
-	for _, v := range data {
-		if reflect.DeepEqual(v, value) {
-			return true
-		}
-	}
-	return false
-}
-
-// Push append value to the list data.
-func (l *List[T]) Push(value T) {
-	l.data = append(l.data, value)
-}
-
-// InsertAtFirst insert value into list at first index.
-func (l *List[T]) InsertAtFirst(value T) {
-	l.InsertAt(0, value)
-}
-
-// InsertAtLast insert value into list at last index.
-func (l *List[T]) InsertAtLast(value T) {
-	l.InsertAt(len(l.data), value)
-}
-
-// InsertAt insert value into list at index.
-func (l *List[T]) InsertAt(index int, value T) {
-	data := l.data
-	size := len(data)
-
-	if index < 0 || index > size {
-		return
-	}
-	l.data = append(data[:index], append([]T{value}, data[index:]...)...)
-}
-
-// PopFirst delete the first value of list and return it.
-func (l *List[T]) PopFirst() (*T, bool) {
-	if len(l.data) == 0 {
-		return nil, false
-	}
-
-	v := l.data[0]
-	l.DeleteAt(0)
-
-	return &v, true
-}
-
-// PopLast delete the last value of list and return it.
-func (l *List[T]) PopLast() (*T, bool) {
-	size := len(l.data)
-	if size == 0 {
-		return nil, false
-	}
-
-	v := l.data[size-1]
-	l.DeleteAt(size - 1)
-
-	return &v, true
-}
-
-// DeleteAt delete the value of list at index.
-func (l *List[T]) DeleteAt(index int) {
-	data := l.data
-	size := len(data)
-	if index < 0 || index > size-1 {
-		return
-	}
-	if index == size-1 {
-		data = data[:index]
-	} else {
-		data = append(data[:index], data[index+1:]...)
-	}
-	l.data = data
-}
-
-// DeleteIf delete all satisfying f(data[i]), returns count of removed elements
-func (l *List[T]) DeleteIf(f func(T) bool) int {
-	data := l.data
-	size := len(data)
-
-	var c int
-	for index := 0; index < len(data); index++ {
-		if !f(data[index]) {
-			continue
-		}
-		if index == size-1 {
-			data = data[:index]
-		} else {
-			data = append(data[:index], data[index+1:]...)
-			index--
-		}
-		c++
-	}
-
-	if c > 0 {
-		l.data = data
-	}
-	return c
-}
-
-// UpdateAt update value of list at index, index shoud between 0 and list size -1
-func (l *List[T]) UpdateAt(index int, value T) {
-	data := l.data
-	size := len(data)
-
-	if index < 0 || index >= size {
-		return
-	}
-	l.data = append(data[:index], append([]T{value}, data[index+1:]...)...)
-}
-
-// Equal compare list to other list, use reflect.DeepEqual.
-func (l *List[T]) Equal(other *List[T]) bool {
-	if len(l.data) != len(other.data) {
-		return false
-	}
-
-	for i := 0; i < len(l.data); i++ {
-		if !reflect.DeepEqual(l.data[i], other.data[i]) {
-			return false
-		}
-	}
-
-	return true
-}
-
-// IsEmpty check if the list is empty or not.
-func (l *List[T]) IsEmpty() bool {
-	return len(l.data) == 0
-}
-
-// Clear the data of list.
-func (l *List[T]) Clear() {
-	l.data = make([]T, 0)
-}
-
-// Clone return a copy of list.
-func (l *List[T]) Clone() *List[T] {
-	cl := NewList(make([]T, len(l.data)))
-	copy(cl.data, l.data)
-
-	return cl
-}
-
-// Merge two list, return new list, don't change original list.
-func (l *List[T]) Merge(other *List[T]) *List[T] {
-	l1, l2 := len(l.data), len(other.data)
-	ml := NewList(make([]T, l1+l2))
-
-	data := append([]T{}, append(l.data, other.data...)...)
-	ml.data = data
-
-	return ml
-}
-
-// Size return number of list data items.
-func (l *List[T]) Size() int {
-	return len(l.data)
-}
-
-// Cap return cap of the inner data.
-func (l *List[T]) Cap() int {
-	return cap(l.data)
-}
-
-// Swap the value of index i and j in list.
-func (l *List[T]) Swap(i, j int) {
-	size := len(l.data)
-	if i < 0 || i >= size || j < 0 || j >= size {
-		return
-	}
-	l.data[i], l.data[j] = l.data[j], l.data[i]
-}
-
-// Reverse the item order of list.
-func (l *List[T]) Reverse() {
-	for i, j := 0, len(l.data)-1; i < j; i, j = i+1, j-1 {
-		l.data[i], l.data[j] = l.data[j], l.data[i]
-	}
-}
-
-// Unique delete duplicate items in list.
-func (l *List[T]) Unique() {
-	data := l.data
-	size := len(data)
-
-	uniqueData := make([]T, 0)
-	for i := 0; i < size; i++ {
-		value := data[i]
-		skip := true
-		for _, v := range uniqueData {
-			if reflect.DeepEqual(value, v) {
-				skip = false
-				break
-			}
-		}
-		if skip {
-			uniqueData = append(uniqueData, value)
-		}
-	}
-
-	l.data = uniqueData
-}
-
-// Union creates a new list contain all element in list l and other, delete duplicate element.
-func (l *List[T]) Union(other *List[T]) *List[T] {
-	result := NewList([]T{})
-
-	result.data = append(result.data, l.data...)
-	result.data = append(result.data, other.data...)
-	result.Unique()
-
-	return result
-}
-
-// Intersection creates a new list whose element both be contained in list l and other.
-func (l *List[T]) Intersection(other *List[T]) *List[T] {
-	result := NewList(make([]T, 0))
-
-	for _, v := range l.data {
-		if other.Contain(v) {
-			result.data = append(result.data, v)
-		}
-	}
-
-	return result
-}
-
-// Difference returns the difference between two collections.
-// return a list whose element in the original list, not in the given list.
-func (l *List[T]) Difference(other *List[T]) *List[T] {
-	result := NewList(make([]T, 0))
-
-	intersectList := l.Intersection(other)
-
-	for _, v := range l.data {
-		if !intersectList.Contain(v) {
-			result.data = append(result.data, v)
-		}
-	}
-
-	return result
-}
-
-// SymmetricDifference oppoiste operation of intersection function.
-func (l *List[T]) SymmetricDifference(other *List[T]) *List[T] {
-	result := NewList(make([]T, 0))
-
-	intersectList := l.Intersection(other)
-
-	for _, v := range l.data {
-		if !intersectList.Contain(v) {
-			result.data = append(result.data, v)
-		}
-	}
-
-	for _, v := range other.data {
-		if !intersectList.Contain(v) {
-			result.data = append(result.data, v)
-		}
-	}
-
-	return result
-}
-
-// SubList returns a sub list of the original list between the specified fromIndex, inclusive, and toIndex, exclusive.
-func (l *List[T]) SubList(fromIndex, toIndex int) *List[T] {
-	data := l.data[fromIndex:toIndex]
-	subList := make([]T, len(data))
-	copy(subList, data)
-	return NewList(subList)
-}
-
-// ForEach performs the given action for each element of the list.
-func (l *List[T]) ForEach(consumer func(T)) {
-	for _, it := range l.data {
-		consumer(it)
-	}
-}
-
-// RetainAll retains only the elements in this list that are contained in the given list.
-func (l *List[T]) RetainAll(list *List[T]) bool {
-	return l.batchRemove(list, true)
-}
-
-// DeleteAll removes from this list all of its elements that are contained in the given list.
-func (l *List[T]) DeleteAll(list *List[T]) bool {
-	return l.batchRemove(list, false)
-}
-
-func (l *List[T]) batchRemove(list *List[T], complement bool) bool {
-	var (
-		w    = 0
-		data = l.data
-		size = len(data)
-	)
-
-	for i := 0; i < size; i++ {
-		if list.Contain(data[i]) == complement {
-			data[w] = data[i]
-			w++
-		}
-	}
-
-	if w != size {
-		l.data = data[:w]
-		return true
-	}
-	return false
-}
-
-// Iterator returns an iterator over the elements in this list in proper sequence.
-func (l *List[T]) Iterator() iterator.Iterator[T] {
-	return iterator.FromSlice(l.data)
-}
-
-// ListToMap convert a list to a map based on iteratee function.
-func ListToMap[T any, K comparable, V any](list *List[T], iteratee func(T) (K, V)) map[K]V {
-	result := make(map[K]V, list.Size())
-	for _, item := range list.data {
-		k, v := iteratee(item)
-		result[k] = v
-	}
-
-	return result
-}

datastructure/list/list_test.go

@@ -1,531 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestListData(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestListData")
-
-	list := NewList([]int{1, 2, 3})
-	assert.Equal([]int{1, 2, 3}, list.Data())
-}
-
-func TestValueOf(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestValueOf")
-
-	list := NewList([]int{1, 2, 3})
-	v, ok := list.ValueOf(0)
-	assert.Equal(1, *v)
-	assert.Equal(true, ok)
-
-	_, ok = list.ValueOf(3)
-	assert.Equal(false, ok)
-}
-
-func TestIndexOf(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestIndexOf")
-
-	list := NewList([]int{1, 2, 3})
-	i := list.IndexOf(1)
-	assert.Equal(0, i)
-
-	i = list.IndexOf(4)
-	assert.Equal(-1, i)
-}
-
-func TestIndexOfFunc(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestIndexOf")
-
-	list := NewList([]int{1, 2, 3})
-	i := list.IndexOfFunc(func(a int) bool { return a == 1 })
-	assert.Equal(0, i)
-
-	i = list.IndexOfFunc(func(a int) bool { return a == 4 })
-	assert.Equal(-1, i)
-}
-
-func TestLastIndexOf(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestIndexOf")
-
-	list := NewList([]int{1, 2, 3, 3, 3, 3, 4, 5, 6, 9})
-	i := list.LastIndexOf(3)
-	assert.Equal(5, i)
-
-	i = list.LastIndexOf(10)
-	assert.Equal(-1, i)
-
-	i = list.LastIndexOf(4)
-	assert.Equal(6, i)
-
-	i = list.LastIndexOf(1)
-	assert.Equal(0, i)
-}
-
-func TestLastIndexOfFunc(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestIndexOf")
-
-	list := NewList([]int{1, 2, 3, 3, 3, 3, 4, 5, 6, 9})
-	i := list.LastIndexOfFunc(func(a int) bool { return a == 3 })
-	assert.Equal(5, i)
-
-	i = list.LastIndexOfFunc(func(a int) bool { return a == 10 })
-	assert.Equal(-1, i)
-
-	i = list.LastIndexOfFunc(func(a int) bool { return a == 4 })
-	assert.Equal(6, i)
-
-	i = list.LastIndexOfFunc(func(a int) bool { return a == 1 })
-	assert.Equal(0, i)
-}
-
-func TestContain(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestContain")
-
-	list := NewList([]int{1, 2, 3})
-	assert.Equal(true, list.Contain(1))
-	assert.Equal(false, list.Contain(0))
-}
-
-func TestPush(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestPush")
-
-	list := NewList([]int{1, 2, 3})
-	list.Push(4)
-
-	assert.Equal([]int{1, 2, 3, 4}, list.Data())
-}
-
-func TestInsertAtFirst(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestInsertAtFirst")
-
-	list := NewList([]int{1, 2, 3})
-	list.InsertAtFirst(0)
-
-	assert.Equal([]int{0, 1, 2, 3}, list.Data())
-}
-
-func TestInsertAtLast(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestInsertAtLast")
-
-	list := NewList([]int{1, 2, 3})
-	list.InsertAtLast(4)
-
-	assert.Equal([]int{1, 2, 3, 4}, list.Data())
-}
-
-func TestInsertAt(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestInsertAt")
-
-	list := NewList([]int{1, 2, 3})
-
-	list.InsertAt(-1, 0)
-	assert.Equal([]int{1, 2, 3}, list.Data())
-
-	list.InsertAt(4, 0)
-	assert.Equal([]int{1, 2, 3}, list.Data())
-
-	list.InsertAt(0, 0)
-	assert.Equal([]int{0, 1, 2, 3}, list.Data())
-
-	list.InsertAt(4, 4)
-	assert.Equal([]int{0, 1, 2, 3, 4}, list.Data())
-}
-
-func TestPopFirst(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestPopFirst")
-
-	list := NewList([]int{1, 2, 3})
-	v, ok := list.PopFirst()
-	assert.Equal(1, *v)
-	assert.Equal(true, ok)
-	assert.Equal([]int{2, 3}, list.Data())
-
-	list2 := NewList([]int{})
-	_, ok = list2.PopFirst()
-	assert.Equal(false, ok)
-	assert.Equal([]int{}, list2.Data())
-}
-
-func TestPopLast(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestPopLast")
-
-	list := NewList([]int{1, 2, 3})
-	v, ok := list.PopLast()
-	assert.Equal(3, *v)
-	assert.Equal(true, ok)
-	assert.Equal([]int{1, 2}, list.Data())
-
-	list2 := NewList([]int{})
-	_, ok = list2.PopLast()
-	assert.Equal(false, ok)
-	assert.Equal([]int{}, list2.Data())
-}
-
-func TestDeleteAt(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestDeleteAt")
-
-	list := NewList([]int{1, 2, 3, 4})
-
-	list.DeleteAt(-1)
-	assert.Equal([]int{1, 2, 3, 4}, list.Data())
-
-	list.DeleteAt(4)
-	assert.Equal([]int{1, 2, 3, 4}, list.Data())
-
-	list.DeleteAt(0)
-	assert.Equal([]int{2, 3, 4}, list.Data())
-
-	list.DeleteAt(2)
-	assert.Equal([]int{2, 3}, list.Data())
-}
-
-func TestUpdateAt(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestUpdateAt")
-
-	list := NewList([]int{1, 2, 3, 4})
-
-	list.UpdateAt(-1, 0)
-	assert.Equal([]int{1, 2, 3, 4}, list.Data())
-
-	list.UpdateAt(4, 0)
-	assert.Equal([]int{1, 2, 3, 4}, list.Data())
-
-	list.UpdateAt(0, 5)
-	assert.Equal([]int{5, 2, 3, 4}, list.Data())
-
-	list.UpdateAt(3, 1)
-	assert.Equal([]int{5, 2, 3, 1}, list.Data())
-}
-
-func TestEqual(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestEqual")
-
-	list1 := NewList([]int{1, 2, 3, 4})
-	list2 := NewList([]int{1, 2, 3, 4})
-	list3 := NewList([]int{1, 2, 3})
-
-	assert.Equal(true, list1.Equal(list2))
-	assert.Equal(false, list1.Equal(list3))
-}
-
-func TestIsEmpty(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestIsEmpty")
-
-	list1 := NewList([]int{1, 2, 3, 4})
-	list2 := NewList([]int{})
-
-	assert.Equal(false, list1.IsEmpty())
-	assert.Equal(true, list2.IsEmpty())
-}
-
-func TestIsClear(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestIsClear")
-
-	list1 := NewList([]int{1, 2, 3, 4})
-	list1.Clear()
-	empty := NewList([]int{})
-
-	assert.Equal(empty, list1)
-}
-
-func TestClone(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestClone")
-
-	list1 := NewList([]int{1, 2, 3, 4})
-	list2 := list1.Clone()
-
-	assert.Equal(true, list1.Equal(list2))
-}
-
-func TestMerge(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestMerge")
-
-	list1 := NewList([]int{1, 2, 3, 4})
-	list2 := NewList([]int{4, 5, 6})
-	expected := NewList([]int{1, 2, 3, 4, 4, 5, 6})
-
-	list3 := list1.Merge(list2)
-	assert.Equal(true, expected.Equal(list3))
-}
-
-func TestSize(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSize")
-
-	list := NewList([]int{1, 2, 3, 4})
-	empty := NewList([]int{})
-
-	assert.Equal(4, list.Size())
-	assert.Equal(0, empty.Size())
-}
-
-func TestCap(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestCap")
-
-	data := make([]int, 0, 100)
-	list := NewList(data)
-	assert.Equal(100, list.Cap())
-
-	data = make([]int, 0)
-	list = NewList(data)
-	assert.Equal(0, list.Cap())
-}
-
-func TestSwap(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSwap")
-
-	list := NewList([]int{1, 2, 3, 4})
-	expected := NewList([]int{4, 2, 3, 1})
-
-	list.Swap(0, 3)
-
-	assert.Equal(true, expected.Equal(list))
-}
-
-func TestReverse(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestReverse")
-
-	list := NewList([]int{1, 2, 3, 4})
-	expected := NewList([]int{4, 3, 2, 1})
-
-	list.Reverse()
-
-	assert.Equal(true, expected.Equal(list))
-}
-
-func TestUnique(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestUnique")
-
-	list := NewList([]int{1, 2, 2, 3, 4})
-	expected := NewList([]int{1, 2, 3, 4})
-
-	list.Unique()
-
-	assert.Equal(true, expected.Equal(list))
-}
-
-func TestUnion(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestUnion")
-
-	list1 := NewList([]int{1, 2, 3, 4})
-	list2 := NewList([]int{4, 5, 6})
-	expected := NewList([]int{1, 2, 3, 4, 5, 6})
-
-	list3 := list1.Union(list2)
-	assert.Equal(true, expected.Equal(list3))
-}
-
-func TestIntersection(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestIntersection")
-
-	list1 := NewList([]int{1, 2, 3, 4})
-	list2 := NewList([]int{4, 5, 6})
-	expected := NewList([]int{4})
-
-	list3 := list1.Intersection(list2)
-	assert.Equal(true, expected.Equal(list3))
-}
-
-func TestDifference(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestDifference")
-
-	list1 := NewList([]int{1, 2, 3})
-	list2 := NewList([]int{1, 2, 4})
-	expected := NewList([]int{3})
-
-	list3 := list1.Difference(list2)
-	assert.Equal(true, expected.Equal(list3))
-}
-
-func TestSymmetricDifference(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSymmetricDifference")
-
-	list1 := NewList([]int{1, 2, 3})
-	list2 := NewList([]int{1, 2, 4})
-	expected := NewList([]int{3, 4})
-
-	list3 := list1.SymmetricDifference(list2)
-	assert.Equal(true, expected.Equal(list3))
-}
-
-func TestSubSlice(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSubSlice")
-
-	list := NewList([]int{1, 2, 3, 4, 5, 8})
-	subList := list.SubList(2, 5)
-
-	assert.Equal([]int{3, 4, 5}, subList.Data())
-}
-
-func BenchmarkSubSlice(b *testing.B) {
-	list := NewList([]int{1, 2, 3, 4, 5, 8})
-	for n := 0; n < b.N; n++ {
-		list.SubList(2, 5)
-	}
-}
-
-func TestDeleteIf(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestDeleteIf")
-
-	list := NewList([]int{1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1, 1, 1})
-
-	count := list.DeleteIf(func(a int) bool { return a == 1 })
-	assert.Equal([]int{2, 3, 4}, list.Data())
-	assert.Equal(12, count)
-
-	count = list.DeleteIf(func(a int) bool { return a == 5 })
-	assert.Equal([]int{2, 3, 4}, list.Data())
-	assert.Equal(0, count)
-}
-
-func TestForEach(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestForEach")
-
-	list := NewList([]int{1, 2, 3, 4})
-	rs := make([]int, 0)
-	list.ForEach(func(i int) {
-		rs = append(rs, i)
-	})
-
-	assert.Equal([]int{1, 2, 3, 4}, rs)
-}
-
-func TestRetainAll(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestRetainAll")
-
-	list := NewList([]int{1, 2, 3, 4})
-	list1 := NewList([]int{1, 2, 3, 4})
-	list2 := NewList([]int{1, 2, 3, 4})
-
-	retain := NewList([]int{1, 2})
-	retain1 := NewList([]int{2, 3})
-	retain2 := NewList([]int{1, 2, 5})
-
-	list.RetainAll(retain)
-	list1.RetainAll(retain1)
-	list2.RetainAll(retain2)
-
-	assert.Equal([]int{1, 2}, list.Data())
-	assert.Equal([]int{2, 3}, list1.Data())
-	assert.Equal([]int{1, 2}, list2.Data())
-}
-
-func TestDeleteAll(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestDeleteAll")
-
-	list := NewList([]int{1, 2, 3, 4})
-	list1 := NewList([]int{1, 2, 3, 4})
-	list2 := NewList([]int{1, 2, 3, 4})
-
-	del := NewList([]int{1})
-	del1 := NewList([]int{2, 3})
-	del2 := NewList([]int{1, 2, 5})
-
-	list.DeleteAll(del)
-	list1.DeleteAll(del1)
-	list2.DeleteAll(del2)
-	assert.Equal([]int{2, 3, 4}, list.Data())
-	assert.Equal([]int{1, 4}, list1.Data())
-	assert.Equal([]int{3, 4}, list2.Data())
-}
-
-func TestIterator(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestIterator")
-
-	list := NewList([]int{1, 2, 3, 4})
-	iterator := list.Iterator()
-
-	rs := make([]int, 0)
-	for iterator.HasNext() {
-		item, _ := iterator.Next()
-		rs = append(rs, item)
-	}
-
-	assert.Equal([]int{1, 2, 3, 4}, rs)
-}
-
-func TestListToMap(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "ListToMap")
-
-	list := NewList([]int{1, 2, 3, 4})
-	result := ListToMap(list, func(n int) (int, bool) {
-		return n, n > 1
-	})
-
-	expected := map[int]bool{1: false, 2: true, 3: true, 4: true}
-	assert.Equal(expected, result)
-}

datastructure/node.go

@@ -1,51 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package datastructure implements some data structure.
-package datastructure
-
-// LinkNode is a linkedlist node, which have a Value and Pre points to previous node, Next points to a next node of the link.
-type LinkNode[T any] struct {
-	Value T
-	Pre   *LinkNode[T]
-	Next  *LinkNode[T]
-}
-
-// NewLinkNode return a LinkNode pointer
-func NewLinkNode[T any](value T) *LinkNode[T] {
-	return &LinkNode[T]{value, nil, nil}
-}
-
-// StackNode is a node in stack, which have a Value and Next pointer points to next node in the stack.
-type StackNode[T any] struct {
-	Value T
-	Next  *StackNode[T]
-}
-
-// NewStackNode return a StackNode pointer
-func NewStackNode[T any](value T) *StackNode[T] {
-	return &StackNode[T]{value, nil}
-}
-
-// QueueNode is a node in a queue, which have a Value and Next pointer points to next node in the queue.
-type QueueNode[T any] struct {
-	Value T
-	Next  *QueueNode[T]
-}
-
-// NewQueueNode return a QueueNode pointer
-func NewQueueNode[T any](value T) *QueueNode[T] {
-	return &QueueNode[T]{value, nil}
-}
-
-// TreeNode is node of tree
-type TreeNode[T any] struct {
-	Value T
-	Left  *TreeNode[T]
-	Right *TreeNode[T]
-}
-
-// NewTreeNode return a TreeNode pointer
-func NewTreeNode[T any](val T) *TreeNode[T] {
-	return &TreeNode[T]{val, nil, nil}
-}

datastructure/optional/optional.go

@@ -1,108 +0,0 @@
-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

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

datastructure/queue/arrayqueue.go

@@ -1,155 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package datastructure contains some data structure.
-// Queue structure contains ArrayQueue, LinkedQueue, CircularQueue, and PriorityQueue.
-package datastructure
-
-import (
-	"fmt"
-	"reflect"
-)
-
-// ArrayQueue implements queue with slice
-type ArrayQueue[T any] struct {
-	data     []T
-	head     int
-	tail     int
-	capacity int
-	size     int
-}
-
-func NewArrayQueue[T any](capacity int) *ArrayQueue[T] {
-	return &ArrayQueue[T]{
-		data:     make([]T, 0, capacity),
-		head:     0,
-		tail:     0,
-		capacity: capacity,
-		size:     0,
-	}
-}
-
-// Data return slice of queue data
-func (q *ArrayQueue[T]) Data() []T {
-	items := make([]T, 0, q.tail-q.head)
-	for i := q.head; i < q.tail; i++ {
-		items = append(items, q.data[i])
-	}
-	return items
-}
-
-// Size return number of elements in queue
-func (q *ArrayQueue[T]) Size() int {
-	return q.size
-}
-
-// IsEmpty checks if queue is empty or not
-func (q *ArrayQueue[T]) IsEmpty() bool {
-	return q.size == 0
-}
-
-// IsFull checks if queue is full or not
-func (q *ArrayQueue[T]) IsFull() bool {
-	return q.size == q.capacity
-}
-
-// Front return front value of queue
-func (q *ArrayQueue[T]) Front() T {
-	return q.data[q.head]
-}
-
-// Back return back value of queue
-func (q *ArrayQueue[T]) Back() T {
-	return q.data[q.tail-1]
-}
-
-// EnQueue put element into queue
-func (q *ArrayQueue[T]) Enqueue(item T) bool {
-	if q.tail < q.capacity {
-		q.data = append(q.data, item)
-		// q.tail++
-		q.data[q.tail] = item
-	} else {
-		//upgrade
-		if q.head > 0 {
-			for i := 0; i < q.tail-q.head; i++ {
-				q.data[i] = q.data[i+q.head]
-			}
-			q.tail -= q.head
-			q.head = 0
-		} else {
-			if q.capacity < 65536 {
-				if q.capacity == 0 {
-					q.capacity = 1
-				}
-				q.capacity *= 2
-			} else {
-				q.capacity += 2 ^ 16
-			}
-
-			tmp := make([]T, q.capacity, q.capacity)
-			copy(tmp, q.data)
-			q.data = tmp
-		}
-
-		q.data[q.tail] = item
-	}
-
-	q.tail++
-	q.size++
-
-	return true
-}
-
-// DeQueue remove head element of queue and return it, if queue is empty, return nil and error
-func (q *ArrayQueue[T]) Dequeue() (T, bool) {
-	var item T
-	if q.size == 0 {
-		return item, false
-	}
-
-	item = q.data[q.head]
-	q.head++
-
-	if q.head >= 1024 || q.head*2 > q.tail {
-		q.capacity -= q.head
-		q.tail -= q.head
-		tmp := make([]T, q.capacity, q.capacity)
-		copy(tmp, q.data[q.head:])
-		q.data = tmp
-		q.head = 0
-	}
-
-	q.size--
-	return item, true
-}
-
-// Clear the queue data
-func (q *ArrayQueue[T]) Clear() {
-	capacity := q.capacity
-	q.data = make([]T, 0, capacity)
-	q.head = 0
-	q.tail = 0
-	q.size = 0
-	q.capacity = capacity
-}
-
-// Contain checks if the value is in queue or not
-func (q *ArrayQueue[T]) Contain(value T) bool {
-	for _, v := range q.data {
-		if reflect.DeepEqual(v, value) {
-			return true
-		}
-	}
-	return false
-}
-
-// Print queue data
-func (q *ArrayQueue[T]) Print() {
-	info := "["
-	for i := q.head; i < q.tail; i++ {
-		info += fmt.Sprintf("%+v, ", q.data[i])
-	}
-	info += "]"
-	fmt.Println(info)
-}

datastructure/queue/arrayqueue_test.go

@@ -1,119 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestArrayQueue_Enqueue(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestArrayQueue_Enqueue")
-
-	queue := NewArrayQueue[int](2)
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-
-	data := queue.Data()
-	size := queue.Size()
-
-	assert.Equal([]int{1, 2, 3}, data)
-	assert.Equal(3, size)
-}
-
-func TestArrayQueue_Dequeue(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestArrayQueue_Dequeue")
-
-	queue := NewArrayQueue[int](4)
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-
-	val, ok := queue.Dequeue()
-	assert.Equal(true, ok)
-
-	assert.Equal(1, val)
-	assert.Equal([]int{2, 3}, queue.Data())
-}
-
-func TestArrayQueue_Front(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestArrayQueue_Front")
-
-	queue := NewArrayQueue[int](4)
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-
-	val := queue.Front()
-
-	assert.Equal(1, val)
-	assert.Equal([]int{1, 2, 3}, queue.Data())
-}
-
-func TestArrayQueue_Back(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestArrayQueue_Back")
-
-	queue := NewArrayQueue[int](4)
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-
-	val := queue.Back()
-
-	assert.Equal(3, val)
-	assert.Equal([]int{1, 2, 3}, queue.Data())
-}
-
-func TestArrayQueue_Contain(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestArrayQueue_Contain")
-
-	queue := NewArrayQueue[int](4)
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-
-	assert.Equal(true, queue.Contain(1))
-	assert.Equal(false, queue.Contain(4))
-}
-
-func TestArrayQueue_Clear(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestArrayQueue_Clear")
-
-	queue := NewArrayQueue[int](4)
-
-	assert.Equal(true, queue.IsEmpty())
-	assert.Equal(0, queue.Size())
-
-	queue.Enqueue(1)
-	assert.Equal(false, queue.IsEmpty())
-	assert.Equal(1, queue.Size())
-
-	queue.Clear()
-	assert.Equal(true, queue.IsEmpty())
-	assert.Equal(0, queue.Size())
-}
-
-func TestArrayQueue_IsFull(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestArrayQueue_IsFull")
-
-	queue := NewArrayQueue[int](3)
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-
-	assert.Equal(true, queue.IsFull())
-}

datastructure/queue/circularqueue.go

@@ -1,123 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package datastructure contains some data structure.
-// Queue structure contains ArrayQueue, LinkedQueue, CircularQueue, and PriorityQueue.
-package datastructure
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-)
-
-// CircularQueue implements circular queue with slice,
-// last index of CircularQueue don't contain value, so acturl capacity is capacity - 1
-type CircularQueue[T any] struct {
-	data     []T
-	front    int
-	rear     int
-	capacity int
-}
-
-// NewCircularQueue return a empty CircularQueue pointer
-func NewCircularQueue[T any](capacity int) *CircularQueue[T] {
-	data := make([]T, capacity)
-	return &CircularQueue[T]{data: data, front: 0, rear: 0, capacity: capacity}
-}
-
-// Data return slice of queue data
-func (q *CircularQueue[T]) Data() []T {
-	data := []T{}
-
-	front := q.front
-	rear := q.rear
-	if front <= rear {
-		return q.data[front:rear]
-	}
-
-	data = append(data, q.data[front:]...)
-	data = append(data, q.data[0:rear]...)
-
-	return data
-}
-
-// Size return number of elements in circular queue
-func (q *CircularQueue[T]) Size() int {
-	if q.capacity == 0 {
-		return 0
-	}
-	return (q.rear - q.front + q.capacity) % q.capacity
-}
-
-// IsEmpty checks if queue is empty or not
-func (q *CircularQueue[T]) IsEmpty() bool {
-	return q.front == q.rear
-}
-
-// IsFull checks if queue is full or not
-func (q *CircularQueue[T]) IsFull() bool {
-	return (q.rear+1)%q.capacity == q.front
-}
-
-// Front return front value of queue
-func (q *CircularQueue[T]) Front() T {
-	return q.data[q.front]
-}
-
-// Back return back value of queue
-func (q *CircularQueue[T]) Back() T {
-	if q.rear-1 >= 0 {
-		return q.data[q.rear-1]
-	}
-	return q.data[q.capacity-1]
-}
-
-// Enqueue put element into queue
-func (q *CircularQueue[T]) Enqueue(value T) error {
-	if q.IsFull() {
-		return errors.New("queue is full!")
-	}
-
-	q.data[q.rear] = value
-	q.rear = (q.rear + 1) % q.capacity
-
-	return nil
-}
-
-// Dequeue remove head element of queue and return it, if queue is empty, return nil and error
-func (q *CircularQueue[T]) Dequeue() (*T, error) {
-	if q.IsEmpty() {
-		return nil, errors.New("queue is empty")
-	}
-
-	headItem := q.data[q.front]
-	var t T
-	q.data[q.front] = t
-	q.front = (q.front + 1) % q.capacity
-
-	return &headItem, nil
-}
-
-// Clear the queue data
-func (q *CircularQueue[T]) Clear() {
-	q.data = []T{}
-	q.front = 0
-	q.rear = 0
-	q.capacity = 0
-}
-
-// Contain checks if the value is in queue or not
-func (q *CircularQueue[T]) Contain(value T) bool {
-	for _, v := range q.data {
-		if reflect.DeepEqual(v, value) {
-			return true
-		}
-	}
-	return false
-}
-
-// Print queue data
-func (q *CircularQueue[T]) Print() {
-	fmt.Printf("%+v\n", q)
-}

datastructure/queue/circularqueue_test.go

@@ -1,159 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestCircularQueue_Enqueue(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestCircularQueue_Enqueue")
-
-	queue := NewCircularQueue[int](6)
-
-	err := queue.Enqueue(1)
-	assert.IsNil(err)
-
-	err = queue.Enqueue(2)
-	assert.IsNil(err)
-
-	err = queue.Enqueue(3)
-	assert.IsNil(err)
-
-	err = queue.Enqueue(4)
-	assert.IsNil(err)
-
-	err = queue.Enqueue(5)
-	assert.IsNil(err)
-
-	assert.Equal([]int{1, 2, 3, 4, 5}, queue.Data())
-	assert.Equal(5, queue.Size())
-
-	err = queue.Enqueue(6)
-	assert.IsNotNil(err)
-}
-
-func TestCircularQueue_Dequeue(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestCircularQueue_DeQueue")
-
-	queue := NewCircularQueue[int](4)
-	assert.Equal(true, queue.IsEmpty())
-
-	err := queue.Enqueue(1)
-	assert.IsNil(err)
-
-	err = queue.Enqueue(2)
-	assert.IsNil(err)
-
-	err = queue.Enqueue(3)
-	assert.IsNil(err)
-
-	val, err := queue.Dequeue()
-	assert.IsNil(err)
-
-	assert.Equal(1, *val)
-	assert.Equal(false, queue.IsFull())
-
-	val, _ = queue.Dequeue()
-	assert.Equal(2, *val)
-	assert.Equal(false, queue.IsFull())
-}
-
-func TestCircularQueue_Front(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestCircularQueue_Front")
-
-	queue := NewCircularQueue[int](6)
-
-	err := queue.Enqueue(1)
-	assert.IsNil(err)
-
-	err = queue.Enqueue(2)
-	assert.IsNil(err)
-
-	err = queue.Enqueue(3)
-	assert.IsNil(err)
-
-	val := queue.Front()
-	assert.IsNil(err)
-	assert.Equal(1, val)
-	assert.Equal(3, queue.Size())
-}
-
-func TestCircularQueue_Back(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestCircularQueue_Back")
-
-	queue := NewCircularQueue[int](3)
-	assert.Equal(true, queue.IsEmpty())
-
-	err := queue.Enqueue(1)
-	assert.IsNil(err)
-
-	err = queue.Enqueue(2)
-	assert.IsNil(err)
-
-	assert.Equal(2, queue.Back())
-
-	val, _ := queue.Dequeue()
-	assert.Equal(1, *val)
-
-	err = queue.Enqueue(3)
-	assert.IsNil(err)
-
-	assert.Equal(3, queue.Back())
-}
-
-func TestCircularQueue_Contain(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestCircularQueue_Contain")
-
-	queue := NewCircularQueue[int](2)
-	err := queue.Enqueue(1)
-	assert.IsNil(err)
-
-	assert.Equal(true, queue.Contain(1))
-	assert.Equal(false, queue.Contain(2))
-}
-
-func TestCircularQueue_Clear(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestCircularQueue_Clear")
-
-	queue := NewCircularQueue[int](3)
-	assert.Equal(true, queue.IsEmpty())
-	assert.Equal(0, queue.Size())
-
-	err := queue.Enqueue(1)
-	assert.IsNil(err)
-
-	assert.Equal(false, queue.IsEmpty())
-	assert.Equal(1, queue.Size())
-
-	queue.Clear()
-	assert.Equal(true, queue.IsEmpty())
-	assert.Equal(0, queue.Size())
-}
-
-func TestCircularQueue_Data(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestCircularQueue_Data")
-
-	queue := NewCircularQueue[int](3)
-	err := queue.Enqueue(1)
-	assert.IsNil(err)
-
-	err = queue.Enqueue(2)
-	assert.IsNil(err)
-
-	assert.Equal([]int{1, 2}, queue.Data())
-}

datastructure/queue/linkedqueue.go

@@ -1,122 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package datastructure contains some data structure.
-// Queue structure contains ArrayQueue, LinkedQueue, CircularQueue, and PriorityQueue.
-package datastructure
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-
-	"github.com/duke-git/lancet/v2/datastructure"
-)
-
-// LinkedQueue implements queue with link list
-type LinkedQueue[T any] struct {
-	head   *datastructure.QueueNode[T]
-	tail   *datastructure.QueueNode[T]
-	length int
-}
-
-// NewLinkedQueue return a empty LinkedQueue pointer
-func NewLinkedQueue[T any]() *LinkedQueue[T] {
-	return &LinkedQueue[T]{head: nil, tail: nil, length: 0}
-}
-
-// Data return slice of queue data
-func (q *LinkedQueue[T]) Data() []T {
-	res := make([]T, 0, q.length)
-	current := q.head
-
-	for current != nil {
-		res = append(res, current.Value)
-		current = current.Next
-	}
-	return res
-}
-
-// Size return length of queue data
-func (q *LinkedQueue[T]) Size() int {
-	return q.length
-}
-
-// IsEmpty checks if queue is empty or not
-func (q *LinkedQueue[T]) IsEmpty() bool {
-	return q.length == 0
-}
-
-// Enqueue put element into queue
-func (q *LinkedQueue[T]) Enqueue(value T) {
-	newNode := datastructure.NewQueueNode(value)
-
-	if q.IsEmpty() {
-		q.head = newNode
-		q.tail = newNode
-	} else {
-		q.tail.Next = newNode
-		q.tail = newNode
-	}
-	q.length++
-}
-
-// Dequeue delete head element of queue then return it, if queue is empty, return nil and error
-func (q *LinkedQueue[T]) Dequeue() (*T, error) {
-	if q.IsEmpty() {
-		return nil, errors.New("queue is empty")
-	}
-
-	head := q.head
-	q.head = q.head.Next
-	q.length--
-
-	return &head.Value, nil
-}
-
-// Front return front value of queue
-func (q *LinkedQueue[T]) Front() (*T, error) {
-	if q.IsEmpty() {
-		return nil, errors.New("queue is empty")
-	}
-	return &q.head.Value, nil
-}
-
-// Back return back value of queue
-func (q *LinkedQueue[T]) Back() (*T, error) {
-	if q.IsEmpty() {
-		return nil, errors.New("queue is empty")
-	}
-	return &q.tail.Value, nil
-}
-
-// Clear clear the queue data
-func (q *LinkedQueue[T]) Clear() {
-	q.head = nil
-	q.tail = nil
-	q.length = 0
-}
-
-// Print all nodes info of queue link
-func (q *LinkedQueue[T]) Print() {
-	current := q.head
-	info := "[ "
-	for current != nil {
-		info += fmt.Sprintf("%+v, ", current)
-		current = current.Next
-	}
-	info += " ]"
-	fmt.Println(info)
-}
-
-// Contain checks if the value is in queue or not
-func (q *LinkedQueue[T]) Contain(value T) bool {
-	current := q.head
-	for current != nil {
-		if reflect.DeepEqual(current.Value, value) {
-			return true
-		}
-		current = current.Next
-	}
-	return false
-}

datastructure/queue/linkedqueue_test.go

@@ -1,106 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestLinkedQueue_Enqueue(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestLinkedQueue_Enqueue")
-
-	queue := NewLinkedQueue[int]()
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-
-	assert.Equal([]int{1, 2, 3}, queue.Data())
-	assert.Equal(3, queue.Size())
-}
-
-func TestLinkedQueue_Dequeue(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestLinkedQueue_DeQueue")
-
-	queue := NewLinkedQueue[int]()
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-
-	val, _ := queue.Dequeue()
-
-	queue.Print()
-
-	assert.Equal([]int{2, 3}, queue.Data())
-	assert.Equal(1, *val)
-}
-
-func TestLinkedQueue_Front(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestLinkedQueue_Front")
-
-	queue := NewLinkedQueue[int]()
-	_, err := queue.Front()
-	assert.IsNotNil(err)
-
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-
-	val, err := queue.Front()
-	assert.Equal(1, *val)
-	assert.IsNil(err)
-}
-
-func TestLinkedQueue_Back(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestLinkedQueue_Back")
-
-	queue := NewLinkedQueue[int]()
-	_, err := queue.Back()
-	assert.IsNotNil(err)
-
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-
-	val, err := queue.Back()
-	assert.Equal(3, *val)
-	assert.IsNil(err)
-}
-
-func TestLinkedQueue_Clear(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestLinkedQueue_Back")
-
-	queue := NewLinkedQueue[int]()
-	assert.Equal(true, queue.IsEmpty())
-
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-	assert.Equal(false, queue.IsEmpty())
-
-	queue.Clear()
-	assert.Equal(true, queue.IsEmpty())
-}
-
-func TestLinkedQueue_Contain(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestLinkedQueue_Contain")
-
-	queue := NewLinkedQueue[int]()
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-
-	assert.Equal(true, queue.Contain(1))
-	assert.Equal(false, queue.Contain(4))
-}

datastructure/queue/priorityqueue.go

@@ -1,118 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package datastructure contains some data structure.
-// Queue structure contains ArrayQueue, LinkedQueue, CircularQueue, and PriorityQueue.
-package datastructure
-
-import (
-	"errors"
-
-	"github.com/duke-git/lancet/v2/constraints"
-)
-
-// PriorityQueue is a priority queue implemented by binary heap tree
-// type T should implements Compare function in constraints.Comparator interface.
-type PriorityQueue[T any] struct {
-	items      []T
-	size       int
-	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 constraints.Comparator) *PriorityQueue[T] {
-	return &PriorityQueue[T]{
-		items:      make([]T, capacity+1),
-		size:       0,
-		comparator: comparator,
-	}
-}
-
-// IsEmpty checks if the queue is empty or not
-func (q *PriorityQueue[T]) IsEmpty() bool {
-	return q.size == 0
-}
-
-// Size get number of items in the queue
-func (q *PriorityQueue[T]) Size() int {
-	return q.size
-}
-
-// IsFull checks if the queue capacity is full or not
-func (q *PriorityQueue[T]) IsFull() bool {
-	return q.size == len(q.items)-1
-}
-
-// Data return a slice of queue data
-func (q *PriorityQueue[T]) Data() []T {
-	data := make([]T, q.size)
-	for i := 1; i < q.size+1; i++ {
-		data[i-1] = q.items[i]
-	}
-
-	return data
-}
-
-// Enqueue insert value into queue
-func (q *PriorityQueue[T]) Enqueue(val T) error {
-	if q.IsFull() {
-		return errors.New("queue is already full.")
-	}
-	q.size++
-	q.items[q.size] = val
-	q.swim(q.size)
-	return nil
-}
-
-// Dequeue delete and return max value in queue
-func (q *PriorityQueue[T]) Dequeue() (T, bool) {
-	var val T
-	if q.IsEmpty() {
-		return val, false
-	}
-
-	max := q.items[1]
-
-	q.swap(1, q.size)
-	q.size--
-	q.sink(1)
-
-	//set zero value for rest values of the queue
-	q.items[q.size+1] = val
-
-	return max, true
-}
-
-// swim when child's key is larger than parent's key, exchange them.
-func (q *PriorityQueue[T]) swim(index int) {
-	for index > 1 && q.comparator.Compare(q.items[index/2], q.items[index]) < 0 {
-		q.swap(index, index/2)
-		index = index / 2
-	}
-}
-
-// sink when parent's key smaller than child's key, exchange parent's key with larger child's key.
-func (q *PriorityQueue[T]) sink(index int) {
-
-	for 2*index <= q.size {
-		j := 2 * index
-
-		// get larger child node index
-		if j < q.size && q.comparator.Compare(q.items[j], q.items[j+1]) < 0 {
-			j++
-		}
-		// if parent larger than child, stop
-		if !(q.comparator.Compare(q.items[index], q.items[j]) < 0) {
-			break
-		}
-
-		q.swap(index, j)
-		index = j
-	}
-}
-
-// swap the two values at index i and j
-func (q *PriorityQueue[T]) swap(i, j int) {
-	q.items[i], q.items[j] = q.items[j], q.items[i]
-}

datastructure/queue/priorityqueue_test.go

@@ -1,74 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-type intComparator struct{}
-
-func (c *intComparator) Compare(v1, v2 any) int {
-	val1, _ := v1.(int)
-	val2, _ := v2.(int)
-
-	if val1 < val2 {
-		return -1
-	} else if val1 > val2 {
-		return 1
-	}
-	return 0
-}
-func TestPriorityQueue_Enqueue(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestPriorityQueue_Enqueue")
-
-	comparator := &intComparator{}
-	pq := NewPriorityQueue[int](3, comparator)
-
-	assert.Equal(true, pq.IsEmpty())
-	assert.Equal(false, pq.IsFull())
-
-	err := pq.Enqueue(1)
-	assert.IsNil(err)
-
-	err = pq.Enqueue(2)
-	assert.IsNil(err)
-
-	err = pq.Enqueue(3)
-	assert.IsNil(err)
-
-	assert.Equal(true, pq.IsFull())
-
-	queueData := pq.Data()
-	assert.Equal([]int{3, 1, 2}, queueData)
-
-}
-
-func TestPriorityQueue_Dequeue(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestPriorityQueue_Dequeue")
-
-	comparator := &intComparator{}
-	pq := NewPriorityQueue[int](3, comparator)
-
-	_, ok := pq.Dequeue()
-	assert.Equal(false, ok)
-
-	err := pq.Enqueue(1)
-	assert.IsNil(err)
-
-	err = pq.Enqueue(2)
-	assert.IsNil(err)
-
-	err = pq.Enqueue(3)
-	assert.IsNil(err)
-
-	assert.Equal(3, pq.Size())
-
-	val, ok := pq.Dequeue()
-	assert.Equal(true, ok)
-	assert.Equal(3, val)
-}

datastructure/set/set.go

@@ -1,220 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package datastructure contains some data structure. Set is a data container, like slice, but element of set is not duplicate.
-package datastructure
-
-import "sort"
-
-// Set is a data container, like slice, but element of set is not duplicate.
-type Set[T comparable] map[T]struct{}
-
-// New create a instance of set from given values.
-func New[T comparable](items ...T) Set[T] {
-	set := make(Set[T], len(items))
-	set.Add(items...)
-	return set
-}
-
-// FromSlice create a set from given slice.
-func FromSlice[T comparable](items []T) Set[T] {
-	set := make(Set[T], len(items))
-	for _, item := range items {
-		set.Add(item)
-	}
-	return set
-}
-
-// Add items to set
-func (s Set[T]) Add(items ...T) {
-	for _, v := range items {
-		s[v] = struct{}{}
-	}
-}
-
-// AddIfNotExist checks if item exists in the set,
-// it adds the item to set and returns true if it does not exist in the set,
-// or else it does nothing and returns false.
-func (s Set[T]) AddIfNotExist(item T) bool {
-	if !s.Contain(item) {
-		if _, ok := s[item]; !ok {
-			s[item] = struct{}{}
-			return true
-		}
-	}
-	return false
-}
-
-// AddIfNotExistBy checks if item exists in the set and pass the `checker` function
-// it adds the item to set and returns true if it does not exists in the set and
-// function `checker` returns true, or else it does nothing and returns false.
-func (s Set[T]) AddIfNotExistBy(item T, checker func(element T) bool) bool {
-	if !s.Contain(item) {
-		if checker(item) {
-			if _, ok := s[item]; !ok {
-				s[item] = struct{}{}
-				return true
-			}
-		}
-	}
-	return false
-}
-
-// Contain checks if set contains item or not
-func (s Set[T]) Contain(item T) bool {
-	_, ok := s[item]
-	return ok
-}
-
-// ContainAll checks if set contains other set
-func (s Set[T]) ContainAll(other Set[T]) bool {
-	for k := range other {
-		_, ok := s[k]
-		if !ok {
-			return false
-		}
-	}
-	return true
-}
-
-// Clone return a copy of set
-func (s Set[T]) Clone() Set[T] {
-	set := FromSlice(s.ToSlice())
-	return set
-}
-
-// Delete item of set
-func (s Set[T]) Delete(items ...T) {
-	for _, v := range items {
-		delete(s, v)
-	}
-}
-
-// Equal checks if two set has same elements or not
-func (s Set[T]) Equal(other Set[T]) bool {
-	if s.Size() != other.Size() {
-		return false
-	}
-
-	return s.ContainAll(other) && other.ContainAll(s)
-}
-
-// Iterate call function by every element of set
-func (s Set[T]) Iterate(fn func(item T)) {
-	for v := range s {
-		fn(v)
-	}
-}
-
-// IsEmpty checks the set is empty or not
-func (s Set[T]) IsEmpty() bool {
-	return len(s) == 0
-}
-
-// Size get the number of elements in set
-func (s Set[T]) Size() int {
-	return len(s)
-}
-
-// Values return all values of set
-// Deprecated: Values function is deprecated and will be removed in future versions. Please use ToSlice() function instead.
-//
-// The ToSlice() function provides the same functionality as Values and returns a slice containing all values of the set.
-func (s Set[T]) Values() []T {
-	return s.ToSlice()
-}
-
-// Union creates a new set contain all element of set s and other
-func (s Set[T]) Union(other Set[T]) Set[T] {
-	set := s.Clone()
-	set.Add(other.Values()...)
-	return set
-}
-
-// Intersection creates a new set whose element both be contained in set s and other
-func (s Set[T]) Intersection(other Set[T]) Set[T] {
-	set := New[T]()
-	s.Iterate(func(value T) {
-		if other.Contain(value) {
-			set.Add(value)
-		}
-	})
-
-	return set
-}
-
-// SymmetricDifference creates a new set whose element is in set1 or set2, but not in both sets
-func (s Set[T]) SymmetricDifference(other Set[T]) Set[T] {
-	set := New[T]()
-	s.Iterate(func(value T) {
-		if !other.Contain(value) {
-			set.Add(value)
-		}
-	})
-
-	other.Iterate(func(value T) {
-		if !s.Contain(value) {
-			set.Add(value)
-		}
-	})
-
-	return set
-}
-
-// Minus creates a set of whose element in origin set but not in compared set
-func (s Set[T]) Minus(comparedSet Set[T]) Set[T] {
-	set := New[T]()
-
-	s.Iterate(func(value T) {
-		if !comparedSet.Contain(value) {
-			set.Add(value)
-		}
-	})
-
-	return set
-}
-
-// EachWithBreak iterates over elements of a set and invokes function for each element,
-// when iteratee return false, will break the for each loop.
-func (s Set[T]) EachWithBreak(iteratee func(item T) bool) {
-	for _, v := range s.Values() {
-		if !iteratee(v) {
-			break
-		}
-	}
-}
-
-// Pop delete the top element of set then return it, if set is empty, return nil-value of T and false.
-func (s Set[T]) Pop() (v T, ok bool) {
-	if len(s) > 0 {
-		for item := range s {
-			v = item
-			delete(s, item)
-			return v, true
-		}
-	}
-
-	return v, false
-}
-
-// ToSlice returns a slice containing all values of the set.
-func (s Set[T]) ToSlice() []T {
-	if s.IsEmpty() {
-		return []T{}
-	}
-	result := make([]T, 0, s.Size())
-	s.Iterate(func(value T) {
-		result = append(result, value)
-	})
-
-	return result
-}
-
-// ToSortedSlice returns a sorted slice containing all values of the set.
-func (s Set[T]) ToSortedSlice(less func(v1, v2 T) bool) []T {
-	result := s.ToSlice()
-	sort.Slice(result, func(i, j int) bool {
-		return less(result[i], result[j])
-	})
-	return result
-}

datastructure/set/set_test.go

@@ -1,335 +0,0 @@
-package datastructure
-
-import (
-	"reflect"
-	"sort"
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestSet_FromSlice(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_FromSlice")
-
-	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 := FromSlice([]int{})
-	assert.Equal(0, s2.Size())
-}
-
-func TestSet_Add(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_Add")
-
-	set := New[int]()
-	set.Add(1, 2, 3)
-
-	cmpSet := New(1, 2, 3)
-
-	assert.Equal(true, set.Equal(cmpSet))
-}
-
-func TestSet_AddIfNotExist(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_AddIfNotExist")
-
-	set := New[int]()
-	set.Add(1, 2, 3)
-
-	assert.Equal(false, set.AddIfNotExist(1))
-	assert.Equal(true, set.AddIfNotExist(4))
-	assert.Equal(New(1, 2, 3, 4), set)
-}
-
-func TestSet_AddIfNotExistBy(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_AddIfNotExistBy")
-
-	set := New[int]()
-	set.Add(1, 2)
-
-	ok := set.AddIfNotExistBy(3, func(val int) bool {
-		return val%2 != 0
-	})
-
-	notOk := set.AddIfNotExistBy(4, func(val int) bool {
-		return val%2 != 0
-	})
-
-	assert.Equal(true, ok)
-	assert.Equal(false, notOk)
-
-	assert.Equal(true, set.Contain(3))
-	assert.Equal(false, set.Contain(4))
-}
-
-func TestSet_Contain(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_Contain")
-
-	set := New[int]()
-	set.Add(1, 2, 3)
-
-	assert.Equal(true, set.Contain(1))
-	assert.Equal(false, set.Contain(4))
-}
-
-func TestSet_ContainAll(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_ContainAll")
-
-	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))
-}
-
-func TestSet_Clone(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_Clone")
-
-	set1 := New(1, 2, 3)
-	set2 := set1.Clone()
-
-	assert.Equal(true, set1.Size() == set2.Size())
-	assert.Equal(true, set1.ContainAll(set2))
-}
-
-func TestSet_Delete(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_Delete")
-
-	set := New[int]()
-	set.Add(1, 2, 3)
-	set.Delete(3)
-
-	assert.Equal(true, set.Equal(New(1, 2)))
-}
-
-func TestSet_Equal(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_Equal")
-
-	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))
-}
-
-func TestSet_Iterate(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_Iterate")
-
-	set := New(1, 2, 3)
-	arr := []int{}
-	set.Iterate(func(value int) {
-		arr = append(arr, value)
-	})
-
-	assert.Equal(3, len(arr))
-}
-
-func TestSet_IsEmpty(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_IsEmpty")
-
-	set := New[int]()
-	assert.Equal(true, set.IsEmpty())
-}
-
-func TestSet_Size(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_Size")
-
-	set := New(1, 2, 3)
-	assert.Equal(3, set.Size())
-}
-
-func TestSet_Values(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_Values")
-
-	set := New(1, 2, 3)
-	values := set.Values()
-
-	assert.Equal(3, len(values))
-}
-
-func TestSet_Union(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_Union")
-
-	set1 := New(1, 2, 3)
-	set2 := New(2, 3, 4, 5)
-
-	unionSet := set1.Union(set2)
-
-	assert.Equal(New(1, 2, 3, 4, 5), unionSet)
-}
-
-func TestSet_Intersection(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_Intersection")
-
-	set1 := New(1, 2, 3)
-	set2 := New(2, 3, 4, 5)
-	intersectionSet := set1.Intersection(set2)
-
-	assert.Equal(New(2, 3), intersectionSet)
-}
-
-func TestSet_SymmetricDifference(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_SymmetricDifference")
-
-	set1 := New(1, 2, 3)
-	set2 := New(2, 3, 4, 5)
-
-	assert.Equal(New(1, 4, 5), set1.SymmetricDifference(set2))
-}
-
-func TestSet_Minus(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_Minus")
-
-	set1 := New(1, 2, 3)
-	set2 := New(2, 3, 4, 5)
-	set3 := New(2, 3)
-
-	assert.Equal(New(1), set1.Minus(set2))
-	assert.Equal(New(4, 5), set2.Minus(set3))
-}
-
-func TestEachWithBreak(t *testing.T) {
-	// s := New(1, 2, 3, 4, 5)
-
-	// var sum int
-
-	// s.EachWithBreak(func(n int) bool {
-	// 	if n > 3 {
-	// 		return false
-	// 	}
-	// 	sum += n
-	// 	return true
-	// })
-
-	// assert := internal.NewAssert(t, "TestEachWithBreak")
-	// assert.Equal(6, sum)
-}
-
-func TestPop(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestSet_Pop")
-
-	s := New[int]()
-
-	val, ok := s.Pop()
-	assert.Equal(0, val)
-	assert.Equal(false, ok)
-
-	s = New(1, 2, 3, 4, 5)
-	sl := s.ToSlice()
-
-	val, ok = s.Pop()
-	assert.Equal(false, s.Contain(val))
-	assert.Equal(true, ok)
-	assert.Equal(len(sl)-1, s.Size())
-
-	var found bool
-
-	for _, v := range sl {
-		if v == val {
-			found = true
-		}
-	}
-
-	assert.Equal(true, found)
-}
-
-func TestSet_ToSlice(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_ToSlice")
-
-	set1 := FromSlice([]int{6, 3, 1, 5, 6, 7, 1})
-	set2 := FromSlice([]float64{-2.65, 4.25, 4.25 - 3.14, 0})
-	set3 := New[string]()
-
-	slice1 := set1.ToSlice()
-	slice2 := set2.ToSlice()
-	slice3 := set3.ToSlice()
-
-	sort.Ints(slice1)
-	sort.Float64s(slice2)
-
-	assert.Equal(5, len(slice1))
-	assert.Equal(4, len(slice2))
-	assert.Equal(0, len(slice3))
-
-	assert.Equal(true, reflect.DeepEqual(slice1, []int{1, 3, 5, 6, 7}))
-	assert.Equal(true, reflect.DeepEqual(slice2, []float64{-2.65, 0, 1.11, 4.25}))
-	assert.Equal("[]string", reflect.TypeOf(slice3).String())
-}
-
-func TestSet_ToSortedSlice(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestSet_ToSortedSlice")
-
-	set1 := FromSlice([]int{6, 3, 1, 5, 6, 7, 1})
-	set2 := FromSlice([]float64{-2.65, 4.25, 4.25 - 3.14, 0})
-
-	type Person struct {
-		Name string
-		Age  int
-	}
-	set3 := FromSlice([]Person{{"Tom", 20}, {"Jerry", 18}, {"Spike", 25}})
-
-	slice1 := set1.ToSortedSlice(func(v1, v2 int) bool {
-		return v1 < v2
-	})
-	slice2 := set2.ToSortedSlice(func(v1, v2 float64) bool {
-		return v2 < v1
-	})
-	slice3 := set3.ToSortedSlice(func(v1, v2 Person) bool {
-		return v1.Age < v2.Age
-	})
-
-	assert.Equal(5, len(slice1))
-	assert.Equal(4, len(slice2))
-	assert.Equal(3, len(slice3))
-
-	assert.Equal(true, reflect.DeepEqual(slice1, []int{1, 3, 5, 6, 7}))
-	assert.Equal(true, reflect.DeepEqual(slice2, []float64{4.25, 1.11, 0, -2.65}))
-	assert.Equal(true, reflect.DeepEqual(slice3, []Person{
-		{"Jerry", 18},
-		{"Tom", 20},
-		{"Spike", 25},
-	}))
-}

datastructure/stack/arraystack.go

@@ -1,66 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package datastructure contains some data structure. Stack structure contains ArrayStack and LinkedStack.
-package datastructure
-
-import "errors"
-
-// ArrayStack implements stack with slice
-type ArrayStack[T any] struct {
-	data   []T
-	length int
-}
-
-// NewArrayStack return a empty ArrayStack pointer
-func NewArrayStack[T any]() *ArrayStack[T] {
-	return &ArrayStack[T]{data: []T{}, length: 0}
-}
-
-// Data return stack data
-func (s *ArrayStack[T]) Data() []T {
-	return s.data
-}
-
-// Size return length of stack data
-func (s *ArrayStack[T]) Size() int {
-	return s.length
-}
-
-// IsEmpty checks if stack is empty or not
-func (s *ArrayStack[T]) IsEmpty() bool {
-	return s.length == 0
-}
-
-// Push element into stack
-func (s *ArrayStack[T]) Push(value T) {
-	s.data = append([]T{value}, s.data...)
-	s.length++
-}
-
-// Pop delete the top element of stack then return it, if stack is empty, return nil and error
-func (s *ArrayStack[T]) Pop() (*T, error) {
-	if s.IsEmpty() {
-		return nil, errors.New("stack is empty")
-	}
-
-	topItem := s.data[0]
-	s.data = s.data[1:]
-	s.length--
-
-	return &topItem, nil
-}
-
-// Peak return the top element of stack
-func (s *ArrayStack[T]) Peak() (*T, error) {
-	if s.IsEmpty() {
-		return nil, errors.New("stack is empty")
-	}
-	return &s.data[0], nil
-}
-
-// Clear the stack data
-func (s *ArrayStack[T]) Clear() {
-	s.data = []T{}
-	s.length = 0
-}

datastructure/stack/arraystack_test.go

@@ -1,82 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestArrayStack_Push(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestArrayStack_Push")
-
-	stack := NewArrayStack[int]()
-	stack.Push(1)
-	stack.Push(2)
-	stack.Push(3)
-
-	values := stack.Data()
-	length := stack.Size()
-
-	assert.Equal([]int{3, 2, 1}, values)
-	assert.Equal(3, length)
-}
-
-func TestArrayStack_Pop(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestArrayStack_Pop")
-
-	stack := NewArrayStack[int]()
-	_, err := stack.Pop()
-	assert.IsNotNil(err)
-
-	stack.Push(1)
-	stack.Push(2)
-	stack.Push(3)
-
-	topItem, err := stack.Pop()
-	assert.IsNil(err)
-	assert.Equal(3, *topItem)
-
-	assert.Equal([]int{2, 1}, stack.Data())
-}
-
-func TestArrayStack_Peak(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestArrayStack_Peak")
-
-	stack := NewArrayStack[int]()
-	_, err := stack.Peak()
-	assert.IsNotNil(err)
-
-	stack.Push(1)
-	stack.Push(2)
-	stack.Push(3)
-
-	topItem, err := stack.Peak()
-	assert.IsNil(err)
-	assert.Equal(3, *topItem)
-
-	assert.Equal([]int{3, 2, 1}, stack.Data())
-}
-
-func TestArrayStack_Clear(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestArrayStack_Clear")
-
-	stack := NewArrayStack[int]()
-	assert.Equal(true, stack.IsEmpty())
-	assert.Equal(0, stack.Size())
-
-	stack.Push(1)
-	assert.Equal(false, stack.IsEmpty())
-	assert.Equal(1, stack.Size())
-
-	stack.Clear()
-	assert.Equal(true, stack.IsEmpty())
-	assert.Equal(0, stack.Size())
-}

datastructure/stack/linkedstack.go

@@ -1,98 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package datastructure contains some data structure. Stack structure contains ArrayStack and LinkedStack.
-package datastructure
-
-import (
-	"errors"
-	"fmt"
-
-	"github.com/duke-git/lancet/v2/datastructure"
-)
-
-// LinkedStack implements stack with link list
-type LinkedStack[T any] struct {
-	top    *datastructure.StackNode[T]
-	length int
-}
-
-// NewLinkedStack return a empty LinkedStack pointer
-func NewLinkedStack[T any]() *LinkedStack[T] {
-	return &LinkedStack[T]{top: nil, length: 0}
-}
-
-// Data return stack data
-func (s *LinkedStack[T]) Data() []T {
-	res := make([]T, 0, s.length)
-	current := s.top
-
-	for current != nil {
-		res = append(res, current.Value)
-		current = current.Next
-	}
-	return res
-}
-
-// Size return length of stack data
-func (s *LinkedStack[T]) Size() int {
-	return s.length
-}
-
-// IsEmpty checks if stack is empty or not
-func (s *LinkedStack[T]) IsEmpty() bool {
-	return s.length == 0
-}
-
-// Push element into stack
-func (s *LinkedStack[T]) Push(value T) {
-	newNode := datastructure.NewStackNode(value)
-	top := s.top
-	if top == nil {
-		s.top = newNode
-	} else {
-		newNode.Next = top
-		s.top = newNode
-	}
-
-	s.length++
-}
-
-// Pop delete the top element of stack then return it, if stack is empty, return nil and error
-func (s *LinkedStack[T]) Pop() (*T, error) {
-	if s.IsEmpty() {
-		return nil, errors.New("stack is empty")
-	}
-
-	top := s.top
-	s.top = s.top.Next
-	s.length--
-
-	return &top.Value, nil
-}
-
-// Peak return the top element of stack then return it
-func (s *LinkedStack[T]) Peak() (*T, error) {
-	if s.IsEmpty() {
-		return nil, errors.New("stack is empty")
-	}
-	return &s.top.Value, nil
-}
-
-// Clear clear the stack data
-func (s *LinkedStack[T]) Clear() {
-	s.top = nil
-	s.length = 0
-}
-
-// Print all nodes info of stack link
-func (s *LinkedStack[T]) Print() {
-	current := s.top
-	info := "[ "
-	for current != nil {
-		info += fmt.Sprintf("%+v, ", current)
-		current = current.Next
-	}
-	info += " ]"
-	fmt.Println(info)
-}

datastructure/stack/linkedstack_test.go

@@ -1,83 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestLinkedStack_Push(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestLinkedStack_Push")
-
-	stack := NewLinkedStack[int]()
-	stack.Push(1)
-	stack.Push(2)
-	stack.Push(3)
-
-	values := stack.Data()
-	size := stack.Size()
-
-	assert.Equal([]int{3, 2, 1}, values)
-	assert.Equal(3, size)
-}
-
-func TestLinkedStack_Pop(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestLinkedStack_Pop")
-
-	stack := NewLinkedStack[int]()
-	_, err := stack.Pop()
-	assert.IsNotNil(err)
-
-	stack.Push(1)
-	stack.Push(2)
-	stack.Push(3)
-
-	topItem, err := stack.Pop()
-	assert.IsNil(err)
-	assert.Equal(3, *topItem)
-
-	stack.Print()
-	assert.Equal([]int{2, 1}, stack.Data())
-}
-
-func TestLinkedStack_Peak(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestLinkedStack_Peak")
-
-	stack := NewLinkedStack[int]()
-	_, err := stack.Peak()
-	assert.IsNotNil(err)
-
-	stack.Push(1)
-	stack.Push(2)
-	stack.Push(3)
-
-	topItem, err := stack.Peak()
-	assert.IsNil(err)
-	assert.Equal(3, *topItem)
-
-	assert.Equal([]int{3, 2, 1}, stack.Data())
-}
-
-func TestLinkedStack_Empty(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestLinkedStack_Empty")
-
-	stack := NewLinkedStack[int]()
-	assert.Equal(true, stack.IsEmpty())
-	assert.Equal(0, stack.Size())
-
-	stack.Push(1)
-	assert.Equal(false, stack.IsEmpty())
-	assert.Equal(1, stack.Size())
-
-	stack.Clear()
-	assert.Equal(true, stack.IsEmpty())
-	assert.Equal(0, stack.Size())
-}

datastructure/tree/bstree.go

@@ -1,112 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package datastructure contains some data structure. BSTree is binary search tree.
-package datastructure
-
-import (
-	"math"
-
-	"github.com/duke-git/lancet/v2/constraints"
-	"github.com/duke-git/lancet/v2/datastructure"
-)
-
-// 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 constraints.Comparator interface.
-type BSTree[T any] struct {
-	root       *datastructure.TreeNode[T]
-	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 constraints.Comparator) *BSTree[T] {
-	root := datastructure.NewTreeNode(rootData)
-	return &BSTree[T]{root, comparator}
-}
-
-// InsertNode insert data into BSTree
-func (t *BSTree[T]) Insert(data T) {
-	root := t.root
-	newNode := datastructure.NewTreeNode(data)
-	if root == nil {
-		t.root = newNode
-	} else {
-		insertTreeNode(root, newNode, t.comparator)
-	}
-}
-
-// DeletetNode delete data into BSTree
-func (t *BSTree[T]) Delete(data T) {
-	deleteTreeNode(t.root, data, t.comparator)
-}
-
-// NodeLevel get node level in BSTree
-func (t *BSTree[T]) NodeLevel(node *datastructure.TreeNode[T]) int {
-	if node == nil {
-		return 0
-	}
-	left := float64(t.NodeLevel(node.Left))
-	right := float64(t.NodeLevel(node.Right))
-
-	return int(math.Max(left, right)) + 1
-}
-
-// PreOrderTraverse traverse tree node in pre order
-func (t *BSTree[T]) PreOrderTraverse() []T {
-	return preOrderTraverse(t.root)
-}
-
-// PostOrderTraverse traverse tree node in post order
-func (t *BSTree[T]) PostOrderTraverse() []T {
-	return postOrderTraverse(t.root)
-}
-
-// InOrderTraverse traverse tree node in mid order
-func (t *BSTree[T]) InOrderTraverse() []T {
-	return inOrderTraverse(t.root)
-}
-
-// LevelOrderTraverse traverse tree node in level order
-func (t *BSTree[T]) LevelOrderTraverse() []T {
-	traversal := make([]T, 0)
-	levelOrderTraverse(t.root, &traversal)
-	return traversal
-}
-
-// Depth returns the calculated depth of a binary saerch tree
-func (t *BSTree[T]) Depth() int {
-	return calculateDepth(t.root, 0)
-}
-
-// IsSubTree checks if the tree `t` has `subTree` or not
-func (t *BSTree[T]) HasSubTree(subTree *BSTree[T]) bool {
-	return hasSubTree(t.root, subTree.root, t.comparator)
-}
-
-func hasSubTree[T any](superTreeRoot, subTreeRoot *datastructure.TreeNode[T],
-	comparator constraints.Comparator) bool {
-	result := false
-
-	if superTreeRoot != nil && subTreeRoot != nil {
-		if comparator.Compare(superTreeRoot.Value, subTreeRoot.Value) == 0 {
-			result = isSubTree(superTreeRoot, subTreeRoot, comparator)
-		}
-		if !result {
-			result = hasSubTree(superTreeRoot.Left, subTreeRoot, comparator)
-		}
-		if !result {
-			result = hasSubTree(superTreeRoot.Right, subTreeRoot, comparator)
-		}
-	}
-	return result
-}
-
-// Print the bstree structure
-func (t *BSTree[T]) Print() {
-	maxLevel := t.NodeLevel(t.root)
-	nodes := []*datastructure.TreeNode[T]{t.root}
-	printTreeNodes(nodes, 1, maxLevel)
-}

datastructure/tree/bstree_test.go

@@ -1,140 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-type intComparator struct{}
-
-func (c *intComparator) Compare(v1, v2 any) int {
-	val1, _ := v1.(int)
-	val2, _ := v2.(int)
-
-	if val1 < val2 {
-		return -1
-	} else if val1 > val2 {
-		return 1
-	}
-	return 0
-}
-
-func TestBSTree_PreOrderTraverse(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestBSTree_PreOrderTraverse")
-
-	bstree := NewBSTree(6, &intComparator{})
-
-	bstree.Insert(7)
-	bstree.Insert(5)
-	bstree.Insert(2)
-	bstree.Insert(4)
-
-	acturl := bstree.PreOrderTraverse()
-	assert.Equal([]int{6, 5, 2, 4, 7}, acturl)
-}
-
-func TestBSTree_PostOrderTraverse(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestBSTree_PostOrderTraverse")
-
-	bstree := NewBSTree(6, &intComparator{})
-
-	bstree.Insert(7)
-	bstree.Insert(5)
-	bstree.Insert(2)
-	bstree.Insert(4)
-
-	acturl := bstree.PostOrderTraverse()
-	assert.Equal([]int{5, 2, 4, 7, 6}, acturl)
-}
-
-func TestBSTree_InOrderTraverse(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestBSTree_InOrderTraverse")
-
-	bstree := NewBSTree(6, &intComparator{})
-
-	bstree.Insert(7)
-	bstree.Insert(5)
-	bstree.Insert(2)
-	bstree.Insert(4)
-
-	acturl := bstree.InOrderTraverse()
-	assert.Equal([]int{2, 4, 5, 6, 7}, acturl)
-}
-
-func TestBSTree_LevelOrderTraverse(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestBSTree_LevelOrderTraverse")
-
-	bstree := NewBSTree(6, &intComparator{})
-
-	bstree.Insert(7)
-	bstree.Insert(5)
-	bstree.Insert(2)
-	bstree.Insert(4)
-
-	acturl := bstree.LevelOrderTraverse()
-	assert.Equal([]int{6, 5, 7, 2, 4}, acturl)
-}
-
-func TestBSTree_Delete(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestBSTree_Delete")
-
-	bstree := NewBSTree(6, &intComparator{})
-
-	bstree.Insert(7)
-	bstree.Insert(5)
-	bstree.Insert(2)
-	bstree.Insert(4)
-
-	bstree.Delete(4)
-
-	acturl1 := bstree.InOrderTraverse()
-	assert.Equal([]int{2, 5, 6, 7}, acturl1)
-}
-
-func TestBSTree_Depth(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestBSTree_Depth")
-
-	bstree := NewBSTree(6, &intComparator{})
-
-	bstree.Insert(7)
-	bstree.Insert(5)
-	bstree.Insert(2)
-	bstree.Insert(4)
-
-	assert.Equal(bstree.Depth(), 4)
-}
-
-func TestBSTree_IsSubTree(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestBSTree_IsSubTree")
-
-	superTree := NewBSTree(8, &intComparator{})
-	superTree.Insert(4)
-	superTree.Insert(5)
-	superTree.Insert(6)
-	superTree.Insert(9)
-	superTree.Insert(4)
-
-	superTree.Print()
-
-	subTree := NewBSTree(5, &intComparator{})
-	subTree.Insert(4)
-	subTree.Insert(6)
-
-	assert.Equal(true, superTree.HasSubTree(subTree))
-	assert.Equal(false, subTree.HasSubTree(superTree))
-}

datastructure/tree/tree_internal.go

@@ -1,238 +0,0 @@
-package datastructure
-
-import (
-	"fmt"
-	"math"
-
-	"github.com/duke-git/lancet/v2/constraints"
-	"github.com/duke-git/lancet/v2/datastructure"
-)
-
-func preOrderTraverse[T any](node *datastructure.TreeNode[T]) []T {
-	data := []T{}
-	if node != nil {
-		data = append(data, node.Value)
-		data = append(data, preOrderTraverse(node.Left)...)
-		data = append(data, preOrderTraverse(node.Right)...)
-	}
-	return data
-}
-
-func postOrderTraverse[T any](node *datastructure.TreeNode[T]) []T {
-	data := []T{}
-	if node != nil {
-		data = append(data, preOrderTraverse(node.Left)...)
-		data = append(data, preOrderTraverse(node.Right)...)
-		data = append(data, node.Value)
-	}
-	return data
-}
-
-func inOrderTraverse[T any](node *datastructure.TreeNode[T]) []T {
-	data := []T{}
-	if node != nil {
-		data = append(data, inOrderTraverse(node.Left)...)
-		data = append(data, node.Value)
-		data = append(data, inOrderTraverse(node.Right)...)
-	}
-	return data
-}
-
-// func preOrderPrint[T any](node *datastructure.TreeNode[T]) {
-// 	if node == nil {
-// 		return
-// 	}
-
-// 	fmt.Printf("%v, ", node.Value)
-// 	preOrderPrint(node.Left)
-// 	preOrderPrint(node.Right)
-// }
-
-// func postOrderPrint[T any](node *datastructure.TreeNode[T]) {
-// 	if node == nil {
-// 		return
-// 	}
-
-// 	postOrderPrint(node.Left)
-// 	postOrderPrint(node.Right)
-// 	fmt.Printf("%v, ", node.Value)
-// }
-
-// func inOrderPrint[T any](node *datastructure.TreeNode[T]) {
-// 	if node == nil {
-// 		return
-// 	}
-
-// 	inOrderPrint(node.Left)
-// 	fmt.Printf("%v, ", node.Value)
-// 	inOrderPrint(node.Right)
-// }
-
-func levelOrderTraverse[T any](root *datastructure.TreeNode[T], traversal *[]T) {
-	var q []*datastructure.TreeNode[T] // queue
-	var n *datastructure.TreeNode[T]   // temp node
-
-	q = append(q, root)
-
-	for len(q) != 0 {
-		n, q = q[0], q[1:]
-		*traversal = append(*traversal, n.Value)
-		if n.Left != nil {
-			q = append(q, n.Left)
-		}
-		if n.Right != nil {
-			q = append(q, n.Right)
-		}
-	}
-}
-
-func insertTreeNode[T any](rootNode, newNode *datastructure.TreeNode[T], comparator constraints.Comparator) {
-	if comparator.Compare(newNode.Value, rootNode.Value) == -1 {
-		if rootNode.Left == nil {
-			rootNode.Left = newNode
-		} else {
-			insertTreeNode(rootNode.Left, newNode, comparator)
-		}
-	} else {
-		if rootNode.Right == nil {
-			rootNode.Right = newNode
-		} else {
-			insertTreeNode(rootNode.Right, newNode, comparator)
-		}
-	}
-}
-
-// todo, delete root node failed
-func deleteTreeNode[T any](node *datastructure.TreeNode[T], data T, comparator constraints.Comparator) *datastructure.TreeNode[T] {
-	if node == nil {
-		return nil
-	}
-	if comparator.Compare(data, node.Value) == -1 {
-		node.Left = deleteTreeNode(node.Left, data, comparator)
-	} else if comparator.Compare(data, node.Value) == 1 {
-		node.Right = deleteTreeNode(node.Right, data, comparator)
-	} else {
-		if node.Left == nil {
-			node = node.Right
-		} else if node.Right == nil {
-			node = node.Left
-		} else {
-			l := node.Right
-			d := inOrderSuccessor(l)
-			d.Left = node.Left
-			return node.Right
-		}
-	}
-
-	return node
-}
-
-func inOrderSuccessor[T any](root *datastructure.TreeNode[T]) *datastructure.TreeNode[T] {
-	cur := root
-	for cur.Left != nil {
-		cur = cur.Left
-	}
-	return cur
-}
-
-func printTreeNodes[T any](nodes []*datastructure.TreeNode[T], level, maxLevel int) {
-	if len(nodes) == 0 || isAllNil(nodes) {
-		return
-	}
-
-	floor := maxLevel - level
-	endgeLines := int(math.Pow(float64(2), (math.Max(float64(floor)-1, 0))))
-	firstSpaces := int(math.Pow(float64(2), float64(floor))) - 1
-	betweenSpaces := int(math.Pow(float64(2), float64(floor)+1)) - 1
-
-	printSpaces(firstSpaces)
-
-	newNodes := make([]*datastructure.TreeNode[T], 0, len(nodes)*2)
-	for _, node := range nodes {
-		if node != nil {
-			fmt.Printf("%v", node.Value)
-			newNodes = append(newNodes, node.Left)
-			newNodes = append(newNodes, node.Right)
-		} else {
-			newNodes = append(newNodes, nil)
-			newNodes = append(newNodes, nil)
-			printSpaces(1)
-		}
-
-		printSpaces(betweenSpaces)
-	}
-
-	fmt.Println("")
-
-	for i := 1; i <= endgeLines; i++ {
-		for j := 0; j < len(nodes); j++ {
-			printSpaces(firstSpaces - i)
-			if nodes[j] == nil {
-				printSpaces(endgeLines + endgeLines + i + 1)
-				continue
-			}
-
-			if nodes[j].Left != nil {
-				fmt.Print("/")
-			} else {
-				printSpaces(1)
-			}
-
-			printSpaces(i + i - 1)
-
-			if nodes[j].Right != nil {
-				fmt.Print("\\")
-			} else {
-				printSpaces(1)
-			}
-			printSpaces(endgeLines + endgeLines - 1)
-		}
-		fmt.Println("")
-	}
-
-	printTreeNodes(newNodes, level+1, maxLevel)
-}
-
-// printSpaces
-func printSpaces(n int) {
-	for i := 0; i < n; i++ {
-		fmt.Print(" ")
-	}
-}
-
-func isAllNil[T any](nodes []*datastructure.TreeNode[T]) bool {
-	for _, v := range nodes {
-		if v != nil {
-			return false
-		}
-	}
-	return true
-}
-
-func calculateDepth[T any](node *datastructure.TreeNode[T], depth int) int {
-	if node == nil {
-		return depth
-	}
-	return max(calculateDepth(node.Left, depth+1), calculateDepth(node.Right, depth+1))
-}
-
-func isSubTree[T any](superTreeRoot, subTreeRoot *datastructure.TreeNode[T], comparator constraints.Comparator) bool {
-	if subTreeRoot == nil {
-		return true
-	}
-	if superTreeRoot == nil {
-		return false
-	}
-	if comparator.Compare(superTreeRoot.Value, subTreeRoot.Value) != 0 {
-		return false
-	}
-	result := isSubTree(superTreeRoot.Left, subTreeRoot.Left, comparator) && isSubTree(superTreeRoot.Right, subTreeRoot.Right, comparator)
-	return result
-}
-
-func max(a, b int) int {
-	if a > b {
-		return a
-	}
-	return b
-}

datetime/conversion.go

@@ -9,20 +9,17 @@ type theTime struct {
 	unix int64
 }
 
-// NewUnixNow return unix timestamp of current time.
-// Play: https://go.dev/play/p/U4PPx-9D0oz
+// NewUnixNow return unix timestamp of current time
 func NewUnixNow() *theTime {
 	return &theTime{unix: time.Now().Unix()}
 }
 
-// NewUnix return unix timestamp of specified time.
-// Play: https://go.dev/play/p/psoSuh_kLRt
+// NewUnix return unix timestamp of specified time
 func NewUnix(unix int64) *theTime {
 	return &theTime{unix: unix}
 }
 
-// NewFormat return unix timestamp of specified time string, t should be "yyyy-mm-dd hh:mm:ss".
-// Play: https://go.dev/play/p/VkW08ZOaXPZ
+// NewFormat return unix timestamp of specified time string, t should be "yyyy-mm-dd hh:mm:ss"
 func NewFormat(t string) (*theTime, error) {
 	timeLayout := "2006-01-02 15:04:05"
 	loc := time.FixedZone("CST", 8*3600)
@@ -33,8 +30,7 @@ func NewFormat(t string) (*theTime, error) {
 	return &theTime{unix: tt.Unix()}, nil
 }
 
-// NewISO8601 return unix timestamp of specified iso8601 time string.
-// Play: https://go.dev/play/p/mkhOHQkdeA2
+// NewISO8601 return unix timestamp of specified iso8601 time string
 func NewISO8601(iso8601 string) (*theTime, error) {
 	t, err := time.ParseInLocation(time.RFC3339, iso8601, time.UTC)
 	if err != nil {
@@ -43,26 +39,22 @@ func NewISO8601(iso8601 string) (*theTime, error) {
 	return &theTime{unix: t.Unix()}, nil
 }
 
-// ToUnix return unix timestamp.
-// Play: https://go.dev/play/p/_LUiwAdocjy
+// ToUnix return unix timestamp
 func (t *theTime) ToUnix() int64 {
 	return t.unix
 }
 
-// ToFormat return the time string 'yyyy-mm-dd hh:mm:ss' of unix time.
-// Play: https://go.dev/play/p/VkW08ZOaXPZ
+// ToFormat return the time string 'yyyy-mm-dd hh:mm:ss' of unix time
 func (t *theTime) ToFormat() string {
 	return time.Unix(t.unix, 0).Format("2006-01-02 15:04:05")
 }
 
-// ToFormatForTpl return the time string which format is specified tpl.
-// Play: https://go.dev/play/p/nyXxXcQJ8L5
+// ToFormatForTpl return the time string which format is specified tpl
 func (t *theTime) ToFormatForTpl(tpl string) string {
 	return time.Unix(t.unix, 0).Format(tpl)
 }
 
-// ToFormatForTpl return iso8601 time string.
-// Play: https://go.dev/play/p/mkhOHQkdeA2
+// ToFormatForTpl return iso8601 time string
 func (t *theTime) ToIso8601() string {
 	return time.Unix(t.unix, 0).Format(time.RFC3339)
 }

datetime/conversion_test.go

@@ -3,12 +3,10 @@ package datetime
 import (
 	"testing"
 
-	"github.com/duke-git/lancet/v2/internal"
+	"github.com/duke-git/lancet/internal"
 )
 
 func TestToUnix(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestToUnix")
 
 	tm1 := NewUnixNow()
@@ -19,37 +17,38 @@ func TestToUnix(t *testing.T) {
 }
 
 func TestToFormat(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestToFormat")
 
-	tm, err := NewFormat("2022-03-18 17:04:05")
-	t.Log("TestToFormat", tm.ToFormat())
+	tm, err := NewFormat("2022/03/18 17:04:05")
+	assert.IsNotNil(err)
+
+	tm, err = NewFormat("2022-03-18 17:04:05")
 	assert.IsNil(err)
+
+	t.Log("ToFormat -> ", tm.ToFormat())
 }
 
 func TestToFormatForTpl(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestToFormatForTpl")
 
-	_, err := NewFormat("2022/03/18 17:04:05")
+	tm, err := NewFormat("2022/03/18 17:04:05")
 	assert.IsNotNil(err)
 
-	tm, err := NewFormat("2022-03-18 17:04:05")
-	t.Log("TestToFormatForTpl", tm.ToFormatForTpl("2006/01/02 15:04:05"))
+	tm, err = NewFormat("2022-03-18 17:04:05")
 	assert.IsNil(err)
+
+	t.Log("ToFormatForTpl -> ", tm.ToFormatForTpl("2006/01/02 15:04:05"))
+
 }
 
 func TestToIso8601(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestToIso8601")
 
-	_, err := NewISO8601("2022-03-18 17:04:05")
+	tm, err := NewISO8601("2022-03-18 17:04:05")
 	assert.IsNotNil(err)
 
-	tm, err := NewISO8601("2006-01-02T15:04:05.999Z")
-	t.Log("TestToIso8601", tm.ToIso8601())
+	tm, err = NewISO8601("2006-01-02T15:04:05.999Z")
 	assert.IsNil(err)
+
+	t.Log("ToIso8601 -> ", tm.ToIso8601())
 }

datetime/datetime.go

@@ -26,11 +26,11 @@
 // "hh:mm:ss"
 // "hh:mm"
 // "mm:ss"
+
 package datetime
 
 import (
 	"fmt"
-	"runtime"
 	"strings"
 	"time"
 )
@@ -64,143 +64,54 @@ func init() {
 	}
 }
 
-// AddMinute add or sub minutes to the time.
-// Play: https://go.dev/play/p/nT1heB1KUUK
-func AddMinute(t time.Time, minutes int64) time.Time {
-	return t.Add(time.Minute * time.Duration(minutes))
+// AddMinute add or sub minute to the time
+func AddMinute(t time.Time, minute int64) time.Time {
+	return t.Add(time.Minute * time.Duration(minute))
 }
 
-// AddHour add or sub hours to the time.
-// Play: https://go.dev/play/p/rcMjd7OCsi5
-func AddHour(t time.Time, hours int64) time.Time {
-	return t.Add(time.Hour * time.Duration(hours))
+// AddHour add or sub hour to the time
+func AddHour(t time.Time, hour int64) time.Time {
+	return t.Add(time.Hour * time.Duration(hour))
 }
 
-// AddDay add or sub days to the time.
-// Play: https://go.dev/play/p/dIGbs_uTdFa
-func AddDay(t time.Time, days int64) time.Time {
-	return t.Add(24 * time.Hour * time.Duration(days))
-}
-
-// AddWeek add or sub weeks to the time.
-// play: https://go.dev/play/p/M9TqdMiaA2p
-func AddWeek(t time.Time, weeks int64) time.Time {
-	return t.Add(7 * 24 * time.Hour * time.Duration(weeks))
-}
-
-// AddMonth add or sub months to the time.
-// Play: https://go.dev/play/p/DLoiOnpLvsN
-func AddMonth(t time.Time, months int64) time.Time {
-	return t.AddDate(0, int(months), 0)
+// AddDay add or sub day to the time
+func AddDay(t time.Time, day int64) time.Time {
+	return t.Add(24 * time.Hour * time.Duration(day))
 }
 
 // AddYear add or sub year to the time.
-// Play: https://go.dev/play/p/MqW2ujnBx10
 func AddYear(t time.Time, year int64) time.Time {
-	return t.AddDate(int(year), 0, 0)
+	return t.Add(365 * 24 * time.Hour * time.Duration(year))
 }
 
-// AddDaySafe add or sub days to the time and ensure that the returned date does not exceed the valid date of the target year and month.
-// Play: https://go.dev/play/p/JTohZFpoDJ3
-func AddDaySafe(t time.Time, days int) time.Time {
-	t = t.AddDate(0, 0, days)
-	year, month, day := t.Date()
-
-	lastDayOfMonth := time.Date(year, month+1, 0, 0, 0, 0, 0, t.Location()).Day()
-
-	if day > lastDayOfMonth {
-		t = time.Date(year, month, lastDayOfMonth, t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
-	}
-
-	return t
-}
-
-// AddMonthSafe add or sub months to the time and ensure that the returned date does not exceed the valid date of the target year and month.
-// Play: https://go.dev/play/p/KLw0lo6mbVW
-func AddMonthSafe(t time.Time, months int) time.Time {
-	year := t.Year()
-	month := int(t.Month()) + months
-
-	for month > 12 {
-		month -= 12
-		year++
-	}
-	for month < 1 {
-		month += 12
-		year--
-	}
-
-	daysInMonth := time.Date(year, time.Month(month+1), 0, 0, 0, 0, 0, time.UTC).Day()
-
-	day := t.Day()
-	if day > daysInMonth {
-		day = daysInMonth
-	}
-
-	return time.Date(year, time.Month(month), day, t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
-}
-
-// AddYearSafe add or sub years to the time and ensure that the returned date does not exceed the valid date of the target year and month.
-// Play: https://go.dev/play/p/KVGXWZZ54ZH
-func AddYearSafe(t time.Time, years int) time.Time {
-	year, month, day := t.Date()
-	year += years
-
-	if month == time.February && day == 29 {
-		if !IsLeapYear(year) {
-			day = 28
-		}
-	}
-
-	return time.Date(year, month, day, t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
-}
-
-// GetNowDate return format yyyy-mm-dd of current date.
-// Play: https://go.dev/play/p/PvfkPpcpBBf
+// GetNowDate return format yyyy-mm-dd of current date
 func GetNowDate() string {
 	return time.Now().Format("2006-01-02")
 }
 
-// GetNowTime return format hh-mm-ss of current time.
-// Play: https://go.dev/play/p/l7BNxCkTmJS
+// GetNowTime return format hh-mm-ss of current time
 func GetNowTime() string {
 	return time.Now().Format("15:04:05")
 }
 
-// GetNowDateTime return format yyyy-mm-dd hh-mm-ss of current datetime.
-// Play: https://go.dev/play/p/pI4AqngD0al
+// GetNowDateTime return format yyyy-mm-dd hh-mm-ss of current datetime
 func GetNowDateTime() string {
 	return time.Now().Format("2006-01-02 15:04:05")
 }
 
-// GetTodayStartTime return the start time of today, format: yyyy-mm-dd 00:00:00.
-// Play: https://go.dev/play/p/84siyYF7t99
-func GetTodayStartTime() string {
-	return time.Now().Format("2006-01-02") + " 00:00:00"
-}
-
-// GetTodayEndTime return the end time of today, format: yyyy-mm-dd 23:59:59.
-// Play: https://go.dev/play/p/jjrLnfoqgn3
-func GetTodayEndTime() string {
-	return time.Now().Format("2006-01-02") + " 23:59:59"
-}
-
-// GetZeroHourTimestamp return timestamp of zero hour (timestamp of 00:00).
-// Play: https://go.dev/play/p/QmL2oIaGE3q
+// GetZeroHourTimestamp return timestamp of zero hour (timestamp of 00:00)
 func GetZeroHourTimestamp() int64 {
 	ts := time.Now().Format("2006-01-02")
 	t, _ := time.Parse("2006-01-02", ts)
 	return t.UTC().Unix() - 8*3600
 }
 
-// GetNightTimestamp return timestamp of zero hour (timestamp of 23:59).
-// Play: https://go.dev/play/p/UolysR3MYP1
+// GetNightTimestamp return timestamp of zero hour (timestamp of 23:59)
 func GetNightTimestamp() int64 {
 	return GetZeroHourTimestamp() + 86400 - 1
 }
 
-// FormatTimeToStr convert time to string.
-// Play: https://go.dev/play/p/_Ia7M8H_OvE
+// FormatTimeToStr convert time to string
 func FormatTimeToStr(t time.Time, format string, timezone ...string) string {
 	tf, ok := timeFormat[strings.ToLower(format)]
 	if !ok {
@@ -217,8 +128,7 @@ func FormatTimeToStr(t time.Time, format string, timezone ...string) string {
 	return t.Format(tf)
 }
 
-// FormatStrToTime convert string to time.
-// Play: https://go.dev/play/p/1h9FwdU8ql4
+// FormatStrToTime convert string to time
 func FormatStrToTime(str, format string, timezone ...string) (time.Time, error) {
 	tf, ok := timeFormat[strings.ToLower(format)]
 	if !ok {
@@ -237,111 +147,88 @@ func FormatStrToTime(str, format string, timezone ...string) (time.Time, error)
 	return time.Parse(tf, str)
 }
 
-// BeginOfMinute return beginning minute time of day.
-// Play: https://go.dev/play/p/ieOLVJ9CiFT
+// BeginOfMinute return beginning minute time of day
 func BeginOfMinute(t time.Time) time.Time {
 	y, m, d := t.Date()
 	return time.Date(y, m, d, t.Hour(), t.Minute(), 0, 0, t.Location())
 }
 
-// EndOfMinute return end minute time of day.
-// Play: https://go.dev/play/p/yrL5wGzPj4z
+// EndOfMinute return end minute time of day
 func EndOfMinute(t time.Time) time.Time {
 	y, m, d := t.Date()
 	return time.Date(y, m, d, t.Hour(), t.Minute(), 59, int(time.Second-time.Nanosecond), t.Location())
 }
 
-// BeginOfHour return beginning hour time of day.
-// Play: https://go.dev/play/p/GhdGFnDWpYs
+// BeginOfHour return beginning hour time of day
 func BeginOfHour(t time.Time) time.Time {
 	y, m, d := t.Date()
 	return time.Date(y, m, d, t.Hour(), 0, 0, 0, t.Location())
 }
 
-// EndOfHour return end hour time of day.
-// Play: https://go.dev/play/p/6ce3j_6cVqN
+// EndOfHour return end hour time of day
 func EndOfHour(t time.Time) time.Time {
 	y, m, d := t.Date()
 	return time.Date(y, m, d, t.Hour(), 59, 59, int(time.Second-time.Nanosecond), t.Location())
 }
 
-// BeginOfDay return beginning hour time of day.
-// Play: https://go.dev/play/p/94m_UT6cWs9
+// BeginOfDay return beginning hour time of day
 func BeginOfDay(t time.Time) time.Time {
 	y, m, d := t.Date()
 	return time.Date(y, m, d, 0, 0, 0, 0, t.Location())
 }
 
-// EndOfDay return end time of day.
-// Play: https://go.dev/play/p/eMBOvmq5Ih1
+// EndOfDay return end time of day
 func EndOfDay(t time.Time) time.Time {
 	y, m, d := t.Date()
 	return time.Date(y, m, d, 23, 59, 59, int(time.Second-time.Nanosecond), t.Location())
 }
 
-// BeginOfWeek return beginning week, default week begin from Sunday.
-// Play: https://go.dev/play/p/DCHdcL6gnfV
-func BeginOfWeek(t time.Time, beginFrom time.Weekday) time.Time {
-	y, m, d := t.AddDate(0, 0, int(beginFrom-t.Weekday())).Date()
-	beginOfWeek := time.Date(y, m, d, 0, 0, 0, 0, t.Location())
-	if beginOfWeek.After(t) {
-		return beginOfWeek.AddDate(0, 0, -7)
-	}
-	return beginOfWeek
+// BeginOfWeek return beginning week, week begin from Sunday
+func BeginOfWeek(t time.Time) time.Time {
+	y, m, d := t.AddDate(0, 0, 0-int(BeginOfDay(t).Weekday())).Date()
+	return time.Date(y, m, d, 0, 0, 0, 0, t.Location())
 }
 
-// EndOfWeek return end week time, default week end with Saturday.
-// Play: https://go.dev/play/p/mGSA162YgX9
-func EndOfWeek(t time.Time, endWith time.Weekday) time.Time {
-	y, m, d := t.AddDate(0, 0, int(endWith-t.Weekday())).Date()
-	var endWithWeek = time.Date(y, m, d, 23, 59, 59, int(time.Second-time.Nanosecond), t.Location())
-	if endWithWeek.Before(t) {
-		endWithWeek = endWithWeek.AddDate(0, 0, 7)
-	}
-	return endWithWeek
+// EndOfWeek return end week time, week end with Saturday
+func EndOfWeek(t time.Time) time.Time {
+	y, m, d := BeginOfWeek(t).AddDate(0, 0, 7).Add(-time.Nanosecond).Date()
+	return time.Date(y, m, d, 23, 59, 59, int(time.Second-time.Nanosecond), t.Location())
 }
 
-// BeginOfMonth return beginning of month.
-// Play: https://go.dev/play/p/bWXVFsmmzwL
+// BeginOfMonth return beginning of month
 func BeginOfMonth(t time.Time) time.Time {
 	y, m, _ := t.Date()
 	return time.Date(y, m, 1, 0, 0, 0, 0, t.Location())
 }
 
-// EndOfMonth return end of month.
-// Play: https://go.dev/play/p/_GWh10B3Nqi
+// EndOfMonth return end of month
 func EndOfMonth(t time.Time) time.Time {
 	return BeginOfMonth(t).AddDate(0, 1, 0).Add(-time.Nanosecond)
 }
 
-// BeginOfYear return the date time at the begin of year.
-// Play: https://go.dev/play/p/i326DSwLnV8
+// BeginOfYear return beginning of year
 func BeginOfYear(t time.Time) time.Time {
 	y, _, _ := t.Date()
 	return time.Date(y, time.January, 1, 0, 0, 0, 0, t.Location())
 }
 
-// EndOfYear return the date time at the end of year.
-// Play: https://go.dev/play/p/G01cKlMCvNm
+// EndOfYear return end of year
 func EndOfYear(t time.Time) time.Time {
 	return BeginOfYear(t).AddDate(1, 0, 0).Add(-time.Nanosecond)
 }
 
 // IsLeapYear check if param year is leap year or not.
-// Play: https://go.dev/play/p/xS1eS2ejGew
 func IsLeapYear(year int) bool {
 	return year%4 == 0 && (year%100 != 0 || year%400 == 0)
 }
 
 // BetweenSeconds returns the number of seconds between two times.
-// Play: https://go.dev/play/p/n3YDRyfyXJu
 func BetweenSeconds(t1 time.Time, t2 time.Time) int64 {
 	index := t2.Unix() - t1.Unix()
 	return index
 }
 
 // DayOfYear returns which day of the year the parameter date `t` is.
-// Play: https://go.dev/play/p/0hjqhTwFNlH
 func DayOfYear(t time.Time) int {
 	y, m, d := t.Date()
 	firstDay := time.Date(y, 1, 1, 0, 0, 0, 0, t.Location())
@@ -351,14 +238,11 @@ func DayOfYear(t time.Time) int {
 }
 
 // IsWeekend checks if passed time is weekend or not.
-// Play: https://go.dev/play/p/cupRM5aZOIY
-// Deprecated Use '== Weekday' instead
 func IsWeekend(t time.Time) bool {
 	return time.Saturday == t.Weekday() || time.Sunday == t.Weekday()
 }
 
 // NowDateOrTime return current datetime with specific format and timezone.
-// Play: https://go.dev/play/p/EZ-begEjtT0
 func NowDateOrTime(format string, timezone ...string) string {
 	tf, ok := timeFormat[strings.ToLower(format)]
 	if !ok {
@@ -378,7 +262,6 @@ func NowDateOrTime(format string, timezone ...string) string {
 }
 
 // Timestamp return current second timestamp.
-// Play: https://go.dev/play/p/iU5b7Vvjx6x
 func Timestamp(timezone ...string) int64 {
 	t := time.Now()
 
@@ -395,7 +278,6 @@ func Timestamp(timezone ...string) int64 {
 }
 
 // TimestampMilli return current mill second timestamp.
-// Play: https://go.dev/play/p/4gvEusOTu1T
 func TimestampMilli(timezone ...string) int64 {
 	t := time.Now()
 
@@ -411,7 +293,6 @@ func TimestampMilli(timezone ...string) int64 {
 }
 
 // TimestampMicro return current micro second timestamp.
-// Play: https://go.dev/play/p/2maANglKHQE
 func TimestampMicro(timezone ...string) int64 {
 	t := time.Now()
 
@@ -427,7 +308,6 @@ func TimestampMicro(timezone ...string) int64 {
 }
 
 // TimestampNano return current nano second timestamp.
-// Play: https://go.dev/play/p/A9Oq_COrcCF
 func TimestampNano(timezone ...string) int64 {
 	t := time.Now()
 
@@ -441,111 +321,3 @@ func TimestampNano(timezone ...string) int64 {
 
 	return t.UnixNano()
 }
-
-// TrackFuncTime track the time of function execution.
-// call it at top of the func like `defer TrackFuncTime(time.Now())()`
-// Play: https://go.dev/play/p/QBSEdfXHPTp
-func TrackFuncTime(pre time.Time) func() {
-	callerName := getCallerName()
-	return func() {
-		elapsed := time.Since(pre)
-		fmt.Printf("Function %s execution time:\t %v", callerName, elapsed)
-	}
-}
-
-func getCallerName() string {
-	pc, _, _, ok := runtime.Caller(2)
-	if !ok {
-		return "Unknown"
-	}
-	fn := runtime.FuncForPC(pc)
-	if fn == nil {
-		return "Unknown"
-	}
-
-	fullName := fn.Name()
-	if lastDot := strings.LastIndex(fullName, "."); lastDot != -1 {
-		return fullName[lastDot+1:]
-	}
-
-	return fullName
-}
-
-// DaysBetween returns the number of days between two times.
-// Play: https://go.dev/play/p/qD6qGb3TbOy
-func DaysBetween(start, end time.Time) int {
-	duration := end.Sub(start)
-	days := int(duration.Hours() / 24)
-
-	return days
-}
-
-// GenerateDatetimesBetween returns a slice of strings between two times.
-// layout: the format of the datetime string
-// interval: the interval between two datetimes
-// Play: https://go.dev/play/p/6kHBpAxD9ZC
-func GenerateDatetimesBetween(start, end time.Time, layout string, interval string) ([]string, error) {
-	var result []string
-
-	if start.After(end) {
-		start, end = end, start
-	}
-
-	duration, err := time.ParseDuration(interval)
-	if err != nil {
-		return nil, err
-	}
-
-	for current := start; !current.After(end); current = current.Add(duration) {
-		result = append(result, current.Format(layout))
-	}
-
-	return result, nil
-}
-
-// Min returns the earliest time among the given times.
-// Play: https://go.dev/play/p/MCIDvHNOGGb
-func Min(t1 time.Time, times ...time.Time) time.Time {
-	minTime := t1
-
-	for _, t := range times {
-		if t.Before(minTime) {
-			minTime = t
-		}
-	}
-
-	return minTime
-}
-
-// Max returns the latest time among the given times.
-// Play: https://go.dev/play/p/9m6JMk1LB7-
-func Max(t1 time.Time, times ...time.Time) time.Time {
-	maxTime := t1
-
-	for _, t := range times {
-		if t.After(maxTime) {
-			maxTime = t
-		}
-	}
-
-	return maxTime
-}
-
-// MaxMin returns the latest and earliest time among the given times.
-// Play: https://go.dev/play/p/rbW51cDtM_2
-func MaxMin(t1 time.Time, times ...time.Time) (maxTime time.Time, minTime time.Time) {
-	maxTime = t1
-	minTime = t1
-
-	for _, t := range times {
-		if t.Before(minTime) {
-			minTime = t
-		}
-
-		if t.After(maxTime) {
-			maxTime = t
-		}
-	}
-
-	return maxTime, minTime
-}

datetime/datetime_example_test.go

@@ -1,538 +0,0 @@
-package datetime
-
-import (
-	"fmt"
-	"reflect"
-	"time"
-)
-
-func ExampleAddDay() {
-	date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")
-
-	after1Day := AddDay(date, 1)
-	before1Day := AddDay(date, -1)
-
-	fmt.Println(after1Day.Format("2006-01-02 15:04:05"))
-	fmt.Println(before1Day.Format("2006-01-02 15:04:05"))
-
-	// Output:
-	// 2021-01-02 00:00:00
-	// 2020-12-31 00:00:00
-}
-
-func ExampleAddWeek() {
-	date, _ := time.Parse("2006-01-02", "2021-01-01")
-
-	after2Weeks := AddWeek(date, 2)
-	before2Weeks := AddWeek(date, -2)
-
-	fmt.Println(after2Weeks.Format("2006-01-02"))
-	fmt.Println(before2Weeks.Format("2006-01-02"))
-
-	// Output:
-	// 2021-01-15
-	// 2020-12-18
-}
-
-func ExampleAddMonth() {
-	date, _ := time.Parse("2006-01-02", "2021-01-01")
-
-	after2Months := AddMonth(date, 2)
-	before2Months := AddMonth(date, -2)
-
-	fmt.Println(after2Months.Format("2006-01-02"))
-	fmt.Println(before2Months.Format("2006-01-02"))
-
-	// Output:
-	// 2021-03-01
-	// 2020-11-01
-}
-
-func ExampleAddHour() {
-	date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")
-
-	after2Hours := AddHour(date, 2)
-	before2Hours := AddHour(date, -2)
-
-	fmt.Println(after2Hours.Format("2006-01-02 15:04:05"))
-	fmt.Println(before2Hours.Format("2006-01-02 15:04:05"))
-
-	// Output:
-	// 2021-01-01 02:00:00
-	// 2020-12-31 22:00:00
-}
-
-func ExampleAddMinute() {
-	date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")
-
-	after2Minutes := AddMinute(date, 2)
-	before2Minutes := AddMinute(date, -2)
-
-	fmt.Println(after2Minutes.Format("2006-01-02 15:04:05"))
-	fmt.Println(before2Minutes.Format("2006-01-02 15:04:05"))
-
-	// Output:
-	// 2021-01-01 00:02:00
-	// 2020-12-31 23:58:00
-}
-
-func ExampleAddYear() {
-	date, _ := time.Parse("2006-01-02", "2021-01-01")
-
-	after2Years := AddYear(date, 2)
-	before2Years := AddYear(date, -2)
-
-	fmt.Println(after2Years.Format("2006-01-02"))
-	fmt.Println(before2Years.Format("2006-01-02"))
-
-	// Output:
-	// 2023-01-01
-	// 2019-01-01
-}
-
-func ExampleAddDaySafe() {
-	leapYearDate1, _ := time.Parse("2006-01-02", "2024-02-29")
-	result1 := AddDaySafe(leapYearDate1, 1)
-
-	leapYearDate2, _ := time.Parse("2006-01-02", "2024-03-01")
-	result2 := AddDaySafe(leapYearDate2, -1)
-
-	nonLeapYearDate1, _ := time.Parse("2006-01-02", "2025-02-28")
-	result3 := AddDaySafe(nonLeapYearDate1, 1)
-
-	nonLeaYearDate2, _ := time.Parse("2006-01-02", "2025-03-01")
-	result4 := AddDaySafe(nonLeaYearDate2, -1)
-
-	fmt.Println(result1.Format("2006-01-02"))
-	fmt.Println(result2.Format("2006-01-02"))
-	fmt.Println(result3.Format("2006-01-02"))
-	fmt.Println(result4.Format("2006-01-02"))
-
-	// Output:
-	// 2024-03-01
-	// 2024-02-29
-	// 2025-03-01
-	// 2025-02-28
-}
-
-func ExampleAddMonthSafe() {
-	date1, _ := time.Parse("2006-01-02", "2025-01-31")
-	result1 := AddMonthSafe(date1, 1)
-
-	date2, _ := time.Parse("2006-01-02", "2024-02-29")
-	result2 := AddMonthSafe(date2, -1)
-
-	fmt.Println(result1.Format("2006-01-02"))
-	fmt.Println(result2.Format("2006-01-02"))
-
-	// Output:
-	// 2025-02-28
-	// 2024-01-29
-}
-
-func ExampleAddYearSafe() {
-	date, _ := time.Parse("2006-01-02", "2020-02-29")
-
-	result1 := AddYearSafe(date, 1)
-	result2 := AddYearSafe(date, -1)
-
-	fmt.Println(result1.Format("2006-01-02"))
-	fmt.Println(result2.Format("2006-01-02"))
-
-	// Output:
-	// 2021-02-28
-	// 2019-02-28
-}
-
-func ExampleGetNowDate() {
-	result := GetNowDate()
-
-	expected := time.Now().Format("2006-01-02")
-
-	fmt.Println(result == expected)
-
-	// Output:
-	// true
-}
-
-func ExampleGetNowTime() {
-	result := GetNowTime()
-
-	expected := time.Now().Format("15:04:05")
-
-	fmt.Println(result == expected)
-
-	// Output:
-	// true
-}
-
-func ExampleGetNowDateTime() {
-	result := GetNowDateTime()
-
-	expected := time.Now().Format("2006-01-02 15:04:05")
-
-	fmt.Println(result == expected)
-
-	// Output:
-	// true
-}
-
-// func ExampleGetZeroHourTimestamp() {
-// 	ts := GetZeroHourTimestamp()
-
-// 	fmt.Println(ts)
-
-// 	// Output:
-// 	// 1673107200
-// }
-
-// func ExampleGetNightTimestamp() {
-// 	ts := GetNightTimestamp()
-
-// 	fmt.Println(ts)
-
-// 	// Output:
-// 	// 1673193599
-// }
-
-func ExampleFormatTimeToStr() {
-	datetime, _ := time.Parse("2006-01-02 15:04:05", "2021-01-02 16:04:08")
-
-	result1 := FormatTimeToStr(datetime, "yyyy-mm-dd hh:mm:ss")
-	result2 := FormatTimeToStr(datetime, "yyyy-mm-dd")
-	result3 := FormatTimeToStr(datetime, "dd-mm-yy hh:mm:ss")
-	result4 := FormatTimeToStr(datetime, "yyyy-mm-dd hh")
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
-
-	// Output:
-	// 2021-01-02 16:04:08
-	// 2021-01-02
-	// 02-01-21 16:04:08
-	// 2021-01-02 16
-}
-
-func ExampleFormatStrToTime() {
-	result1, _ := FormatStrToTime("2021-01-02 16:04:08", "yyyy-mm-dd hh:mm:ss")
-	result2, _ := FormatStrToTime("2021-01-02", "yyyy-mm-dd")
-	result3, _ := FormatStrToTime("02-01-21 16:04:08", "dd-mm-yy hh:mm:ss")
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-
-	// Output:
-	// 2021-01-02 16:04:08 +0000 UTC
-	// 2021-01-02 00:00:00 +0000 UTC
-	// 2021-01-02 16:04:08 +0000 UTC
-}
-
-func ExampleBeginOfMinute() {
-	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
-
-	result := BeginOfMinute(input)
-
-	fmt.Println(result)
-
-	// Output:
-	// 2023-01-08 18:50:00 +0000 UTC
-}
-
-func ExampleEndOfMinute() {
-	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
-
-	result := EndOfMinute(input)
-
-	fmt.Println(result)
-
-	// Output:
-	// 2023-01-08 18:50:59.999999999 +0000 UTC
-}
-
-func ExampleBeginOfHour() {
-	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
-
-	result := BeginOfHour(input)
-
-	fmt.Println(result)
-
-	// Output:
-	// 2023-01-08 18:00:00 +0000 UTC
-}
-
-func ExampleEndOfHour() {
-	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
-
-	result := EndOfHour(input)
-
-	fmt.Println(result)
-
-	// Output:
-	// 2023-01-08 18:59:59.999999999 +0000 UTC
-}
-
-func ExampleBeginOfDay() {
-	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
-
-	result := BeginOfDay(input)
-
-	fmt.Println(result)
-
-	// Output:
-	// 2023-01-08 00:00:00 +0000 UTC
-}
-
-func ExampleEndOfDay() {
-	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
-
-	result := EndOfDay(input)
-
-	fmt.Println(result)
-
-	// Output:
-	// 2023-01-08 23:59:59.999999999 +0000 UTC
-}
-
-func ExampleBeginOfWeek() {
-	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
-
-	result := BeginOfWeek(input, time.Monday)
-
-	fmt.Println(result)
-
-	// Output:
-	// 2023-01-02 00:00:00 +0000 UTC
-}
-
-func ExampleEndOfWeek() {
-	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
-
-	result := EndOfWeek(input, time.Sunday)
-
-	fmt.Println(result)
-
-	// Output:
-	// 2023-01-08 23:59:59.999999999 +0000 UTC
-}
-
-func ExampleBeginOfMonth() {
-	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
-
-	result := BeginOfMonth(input)
-
-	fmt.Println(result)
-
-	// Output:
-	// 2023-01-01 00:00:00 +0000 UTC
-}
-
-func ExampleEndOfMonth() {
-	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
-
-	result := EndOfMonth(input)
-
-	fmt.Println(result)
-
-	// Output:
-	// 2023-01-31 23:59:59.999999999 +0000 UTC
-}
-
-func ExampleBeginOfYear() {
-	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
-
-	result := BeginOfYear(input)
-
-	fmt.Println(result)
-
-	// Output:
-	// 2023-01-01 00:00:00 +0000 UTC
-}
-
-func ExampleEndOfYear() {
-	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
-
-	result := EndOfYear(input)
-
-	fmt.Println(result)
-
-	// Output:
-	// 2023-12-31 23:59:59.999999999 +0000 UTC
-}
-
-func ExampleNewUnix() {
-	result := NewUnix(1647597438)
-
-	fmt.Println(result)
-
-	// Output:
-	// &{1647597438}
-}
-
-func ExampleNewUnixNow() {
-	tm1 := NewUnixNow()
-
-	unixTimestamp := tm1.ToUnix()
-
-	tm2 := NewUnix(unixTimestamp)
-
-	fmt.Println(reflect.DeepEqual(tm1, tm2))
-
-	// Output:
-	// true
-}
-
-// func ExampleNewFormat() {
-// 	tm, err := NewFormat("2022-03-18 17:04:05")
-// 	if err != nil {
-// 		return
-// 	}
-
-// 	result := tm.ToFormat()
-
-// 	fmt.Println(result)
-
-// 	// Output:
-// 	// 2022-03-18 17:04:05
-// }
-
-// func ExampleNewISO8601() {
-// 	tm, err := NewISO8601("2006-01-02T15:04:05.999Z")
-// 	if err != nil {
-// 		return
-// 	}
-
-// 	result := tm.ToIso8601()
-
-// 	fmt.Println(result)
-
-// 	// Output:
-// 	// 2006-01-02T23:04:05+08:00
-// }
-
-func ExampleIsLeapYear() {
-	result1 := IsLeapYear(2000)
-	result2 := IsLeapYear(2001)
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-
-	// Output:
-	// true
-	// false
-}
-
-func ExampleBetweenSeconds() {
-	today := time.Now()
-	tomorrow := AddDay(today, 1)
-	yesterday := AddDay(today, -1)
-
-	result1 := BetweenSeconds(today, tomorrow)
-	result2 := BetweenSeconds(today, yesterday)
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-
-	// Output:
-	// 86400
-	// -86400
-}
-
-func ExampleDayOfYear() {
-	date1 := time.Date(2023, 02, 01, 1, 1, 1, 0, time.Local)
-	result1 := DayOfYear(date1)
-
-	date2 := time.Date(2023, 01, 02, 1, 1, 1, 0, time.Local)
-	result2 := DayOfYear(date2)
-
-	date3 := time.Date(2023, 01, 01, 1, 1, 1, 0, time.Local)
-	result3 := DayOfYear(date3)
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-
-	// Output:
-	// 31
-	// 1
-	// 0
-}
-
-func ExampleIsWeekend() {
-	date1 := time.Date(2023, 06, 03, 0, 0, 0, 0, time.Local)
-	date2 := time.Date(2023, 06, 04, 0, 0, 0, 0, time.Local)
-	date3 := time.Date(2023, 06, 02, 0, 0, 0, 0, time.Local)
-
-	result1 := IsWeekend(date1)
-	result2 := IsWeekend(date2)
-	result3 := IsWeekend(date3)
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-
-	// Output:
-	// true
-	// true
-	// false
-}
-
-func ExampleDaysBetween() {
-	start := time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC)
-	end := time.Date(2024, time.September, 10, 0, 0, 0, 0, time.UTC)
-
-	result := DaysBetween(start, end)
-
-	fmt.Println(result)
-
-	// Output:
-	// 9
-}
-
-func ExampleGenerateDatetimesBetween() {
-	start := time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC)
-	end := time.Date(2024, time.September, 1, 2, 0, 0, 0, time.UTC)
-
-	layout := "2006-01-02 15:04:05"
-	interval := "1h"
-
-	result, err := GenerateDatetimesBetween(start, end, layout, interval)
-
-	fmt.Println(result)
-	fmt.Println(err)
-
-	// Output:
-	// [2024-09-01 00:00:00 2024-09-01 01:00:00 2024-09-01 02:00:00]
-	// <nil>
-}
-
-func ExampleMin() {
-	result := Min(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC))
-
-	fmt.Println(result)
-
-	// Output:
-	// 2024-09-01 00:00:00 +0000 UTC
-}
-
-func ExampleMax() {
-	result := Max(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC))
-
-	fmt.Println(result)
-
-	// Output:
-	// 2024-09-02 00:00:00 +0000 UTC
-}
-
-func ExampleMaxMin() {
-	max, min := MaxMin(time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 2, 0, 0, 0, 0, time.UTC), time.Date(2024, time.September, 3, 0, 0, 0, 0, time.UTC))
-
-	fmt.Println(max)
-	fmt.Println(min)
-
-	// Output:
-	// 2024-09-03 00:00:00 +0000 UTC
-	// 2024-09-01 00:00:00 +0000 UTC
-}

datetime/datetime_test.go

@@ -4,506 +4,101 @@ import (
 	"testing"
 	"time"
 
-	"github.com/duke-git/lancet/v2/internal"
+	"github.com/duke-git/lancet/internal"
 )
 
-func TestAddYear(t *testing.T) {
-	t.Parallel()
-	assert := internal.NewAssert(t, "TestAddDay")
-
-	tests := []struct {
-		inputDate string
-		years     int
-		expected  string
-	}{
-		{
-			inputDate: "2021-01-01 00:00:00",
-			years:     1,
-			expected:  "2022-01-01 00:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			years:     -1,
-			expected:  "2020-01-01 00:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			years:     0,
-			expected:  "2021-01-01 00:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			years:     2,
-			expected:  "2023-01-01 00:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			years:     3,
-			expected:  "2024-01-01 00:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			years:     4,
-			expected:  "2025-01-01 00:00:00",
-		},
-	}
-
-	for _, tt := range tests {
-		date, _ := time.Parse("2006-01-02 15:04:05", tt.inputDate)
-		result := AddYear(date, int64(tt.years))
-		assert.Equal(tt.expected, result.Format("2006-01-02 15:04:05"))
-	}
-}
-
 func TestAddDay(t *testing.T) {
-	t.Parallel()
 	assert := internal.NewAssert(t, "TestAddDay")
 
-	tests := []struct {
-		inputDate string
-		days      int
-		expected  string
-	}{
-		{
-			inputDate: "2021-01-01 00:00:00",
-			days:      1,
-			expected:  "2021-01-02 00:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			days:      -1,
-			expected:  "2020-12-31 00:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			days:      0,
-			expected:  "2021-01-01 00:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			days:      2,
-			expected:  "2021-01-03 00:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			days:      3,
-			expected:  "2021-01-04 00:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			days:      4,
-			expected:  "2021-01-05 00:00:00",
-		},
-	}
+	now := time.Now()
+	after2Days := AddDay(now, 2)
+	diff1 := after2Days.Sub(now)
+	assert.Equal(float64(48), diff1.Hours())
 
-	for _, tt := range tests {
-		date, _ := time.Parse("2006-01-02 15:04:05", tt.inputDate)
-		result := AddDay(date, int64(tt.days))
-		assert.Equal(tt.expected, result.Format("2006-01-02 15:04:05"))
-	}
+	before2Days := AddDay(now, -2)
+	diff2 := before2Days.Sub(now)
+	assert.Equal(float64(-48), diff2.Hours())
 }
 
 func TestAddHour(t *testing.T) {
-	t.Parallel()
 	assert := internal.NewAssert(t, "TestAddHour")
 
-	tests := []struct {
-		inputDate string
-		hours     int
-		expected  string
-	}{
-		{
-			inputDate: "2021-01-01 00:00:00",
-			hours:     1,
-			expected:  "2021-01-01 01:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			hours:     -1,
-			expected:  "2020-12-31 23:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			hours:     0,
-			expected:  "2021-01-01 00:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			hours:     24,
-			expected:  "2021-01-02 00:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			hours:     25,
-			expected:  "2021-01-02 01:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			hours:     48,
-			expected:  "2021-01-03 00:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			hours:     49,
-			expected:  "2021-01-03 01:00:00",
-		},
-	}
-
-	for _, tt := range tests {
-		date, _ := time.Parse("2006-01-02 15:04:05", tt.inputDate)
-		result := AddHour(date, int64(tt.hours))
-		assert.Equal(tt.expected, result.Format("2006-01-02 15:04:05"))
-	}
+	now := time.Now()
+	after2Hours := AddHour(now, 2)
+	diff1 := after2Hours.Sub(now)
+	assert.Equal(float64(2), diff1.Hours())
 
+	before2Hours := AddHour(now, -2)
+	diff2 := before2Hours.Sub(now)
+	assert.Equal(float64(-2), diff2.Hours())
 }
 
 func TestAddMinute(t *testing.T) {
-	t.Parallel()
 	assert := internal.NewAssert(t, "TestAddMinute")
 
-	tests := []struct {
-		inputDate string
-		minutes   int
-		expected  string
-	}{
-		{
-			inputDate: "2021-01-01 00:00:00",
-			minutes:   1,
-			expected:  "2021-01-01 00:01:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			minutes:   -1,
-			expected:  "2020-12-31 23:59:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			minutes:   0,
-			expected:  "2021-01-01 00:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			minutes:   60,
-			expected:  "2021-01-01 01:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			minutes:   61,
-			expected:  "2021-01-01 01:01:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			minutes:   1440,
-			expected:  "2021-01-02 00:00:00",
-		},
-		{
-			inputDate: "2021-01-01 00:00:00",
-			minutes:   1441,
-			expected:  "2021-01-02 00:01:00",
-		},
-	}
+	now := time.Now()
+	after2Minutes := AddMinute(now, 2)
+	diff1 := after2Minutes.Sub(now)
+	assert.Equal(float64(2), diff1.Minutes())
 
-	for _, tt := range tests {
-		date, _ := time.Parse("2006-01-02 15:04:05", tt.inputDate)
-		result := AddMinute(date, int64(tt.minutes))
-		assert.Equal(tt.expected, result.Format("2006-01-02 15:04:05"))
-	}
+	before2Minutes := AddMinute(now, -2)
+	diff2 := before2Minutes.Sub(now)
+	assert.Equal(float64(-2), diff2.Minutes())
 }
 
-func TestAddWeek(t *testing.T) {
-	t.Parallel()
+func TestAddYear(t *testing.T) {
+	assert := internal.NewAssert(t, "TestAddDay")
 
-	assert := internal.NewAssert(t, "TestAddWeek")
+	now := time.Now()
+	after2Years := AddYear(now, 1)
+	diff1 := after2Years.Sub(now)
+	assert.Equal(float64(8760), diff1.Hours())
 
-	tests := []struct {
-		inputDate string
-		weeks     int
-		expected  string
-	}{
-		{
-			inputDate: "2021-01-01",
-			weeks:     1,
-			expected:  "2021-01-08",
-		},
-		{
-			inputDate: "2021-01-01",
-			weeks:     -1,
-			expected:  "2020-12-25",
-		},
-		{
-			inputDate: "2021-01-01",
-			weeks:     0,
-			expected:  "2021-01-01",
-		},
-		{
-			inputDate: "2021-01-01",
-			weeks:     52,
-			expected:  "2021-12-31",
-		},
-		{
-			inputDate: "2021-01-01",
-			weeks:     53,
-			expected:  "2022-01-07",
-		},
-		{
-			inputDate: "2021-01-01",
-			weeks:     104,
-			expected:  "2022-12-30",
-		},
-	}
-
-	for _, tt := range tests {
-		date, _ := time.Parse("2006-01-02", tt.inputDate)
-		result := AddWeek(date, int64(tt.weeks))
-		assert.Equal(tt.expected, result.Format("2006-01-02"))
-	}
-}
-
-func TestAddMonth(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestAddMonth")
-
-	tests := []struct {
-		inputDate string
-		months    int
-		expected  string
-	}{
-		{
-			inputDate: "2021-01-01",
-			months:    1,
-			expected:  "2021-02-01",
-		},
-		{
-			inputDate: "2021-01-01",
-			months:    -1,
-			expected:  "2020-12-01",
-		},
-		{
-			inputDate: "2021-01-01",
-			months:    0,
-			expected:  "2021-01-01",
-		},
-		{
-			inputDate: "2021-01-01",
-			months:    12,
-			expected:  "2022-01-01",
-		},
-		{
-			inputDate: "2021-01-01",
-			months:    13,
-			expected:  "2022-02-01",
-		},
-		{
-			inputDate: "2021-01-01",
-			months:    24,
-			expected:  "2023-01-01",
-		},
-	}
-
-	for _, tt := range tests {
-		date, _ := time.Parse("2006-01-02", tt.inputDate)
-		result := AddMonth(date, int64(tt.months))
-		assert.Equal(tt.expected, result.Format("2006-01-02"))
-	}
-
-}
-
-func TestAddDaySafe(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestAddDaySafe")
-
-	tests := []struct {
-		inputDate string
-		days      int
-		expected  string
-	}{
-		{"2025-01-31", 10, "2025-02-10"},
-		{"2025-01-01", 30, "2025-01-31"},
-		{"2025-01-31", 1, "2025-02-01"},
-		{"2025-02-28", 1, "2025-03-01"},
-		{"2024-02-29", 1, "2024-03-01"},
-		{"2024-02-29", 365, "2025-02-28"},
-
-		{"2025-01-31", -10, "2025-01-21"},
-		{"2025-01-01", -30, "2024-12-02"},
-		{"2025-02-01", -1, "2025-01-31"},
-		{"2025-03-01", -1, "2025-02-28"},
-		{"2024-03-01", -1, "2024-02-29"},
-
-		{"2025-01-31", -31, "2024-12-31"},
-		{"2025-12-31", 1, "2026-01-01"},
-	}
-
-	for _, tt := range tests {
-		date, _ := time.Parse("2006-01-02", tt.inputDate)
-		result := AddDaySafe(date, tt.days)
-		assert.Equal(tt.expected, result.Format("2006-01-02"))
-	}
-}
-
-func TestAddMonthSafe(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestAddMonthSafe")
-
-	tests := []struct {
-		inputDate string
-		months    int
-		expected  string
-	}{
-		{
-			inputDate: "2025-01-31",
-			months:    1,
-			expected:  "2025-02-28",
-		},
-		{
-			inputDate: "2025-01-31",
-			months:    -1,
-			expected:  "2024-12-31",
-		},
-		{
-			inputDate: "2025-12-31",
-			months:    1,
-			expected:  "2026-01-31",
-		},
-		{
-			inputDate: "2025-01-31",
-			months:    -1,
-			expected:  "2024-12-31",
-		},
-		{
-			inputDate: "2024-02-29",
-			months:    1,
-			expected:  "2024-03-29",
-		},
-		{
-			inputDate: "2024-02-29",
-			months:    -1,
-			expected:  "2024-01-29",
-		},
-	}
-
-	for _, tt := range tests {
-		date, _ := time.Parse("2006-01-02", tt.inputDate)
-		result := AddMonthSafe(date, tt.months)
-		assert.Equal(tt.expected, result.Format("2006-01-02"))
-	}
-
-}
-
-func TestAddYearSafe(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestAddYearSafe")
-
-	tests := []struct {
-		inputDate string
-		years     int
-		expected  string
-	}{
-		{
-			inputDate: "2020-02-29",
-			years:     1,
-			expected:  "2021-02-28",
-		},
-		{
-			inputDate: "2020-02-29",
-			years:     2,
-			expected:  "2022-02-28",
-		},
-		{
-			inputDate: "2020-02-29",
-			years:     -1,
-			expected:  "2019-02-28",
-		},
-		{
-			inputDate: "2020-02-29",
-			years:     -2,
-			expected:  "2018-02-28",
-		},
-	}
-
-	for _, tt := range tests {
-		date, _ := time.Parse("2006-01-02", tt.inputDate)
-		result := AddYearSafe(date, tt.years)
-		assert.Equal(tt.expected, result.Format("2006-01-02"))
-	}
+	before2Years := AddYear(now, -1)
+	diff2 := before2Years.Sub(now)
+	assert.Equal(float64(-8760), diff2.Hours())
 }
 
 func TestGetNowDate(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestGetNowDate")
 	expected := time.Now().Format("2006-01-02")
 	assert.Equal(expected, GetNowDate())
 }
 
-func TestGetNowTime(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestGetNowTime")
+func TestGetNotTime(t *testing.T) {
+	assert := internal.NewAssert(t, "TestGetNotTime")
 	expected := time.Now().Format("15:04:05")
 	assert.Equal(expected, GetNowTime())
 }
 
 func TestGetNowDateTime(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestGetNowDateTime")
 	expected := time.Now().Format("2006-01-02 15:04:05")
 	assert.Equal(expected, GetNowDateTime())
 }
 
-func TestGetTodayStartTime(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestGetTodayStartTime")
-	expected := time.Now().Format("2006-01-02") + " 00:00:00"
-	assert.Equal(expected, GetTodayStartTime())
-}
-
-func TestGetTodayEndTime(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestGetTodayEndTime")
-	expected := time.Now().Format("2006-01-02") + " 23:59:59"
-	assert.Equal(expected, GetTodayEndTime())
-}
-
 func TestFormatTimeToStr(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestFormatTimeToStr")
 
 	datetime, _ := time.Parse("2006-01-02 15:04:05", "2021-01-02 16:04:08")
 	cases := []string{
 		"yyyy-mm-dd hh:mm:ss", "yyyy-mm-dd",
 		"dd-mm-yy hh:mm:ss", "yyyy/mm/dd hh:mm:ss",
-		"hh:mm:ss", "yyyy/mm",
-		"yyyy-mm-dd hh",
-	}
+		"hh:mm:ss", "yyyy/mm"}
 
 	expected := []string{
 		"2021-01-02 16:04:08", "2021-01-02",
 		"02-01-21 16:04:08", "2021/01/02 16:04:08",
-		"16:04:08", "2021/01",
-		"2021-01-02 16",
-	}
+		"16:04:08", "2021/01"}
 
 	for i := 0; i < len(cases); i++ {
 		actual := FormatTimeToStr(datetime, cases[i])
 		assert.Equal(expected[i], actual)
-	}
 
-	ds := FormatTimeToStr(datetime, "yyyy-mm-dd hh:mm:ss", "EST")
-	t.Log(ds)
+	}
 }
 
 func TestFormatStrToTime(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestFormatStrToTime")
 
 	formats := []string{
@@ -515,28 +110,22 @@ func TestFormatStrToTime(t *testing.T) {
 		"dd-mm-yy hh:mm:ss", "yyyy/mm/dd hh:mm:ss",
 		"yyyy/mm"}
 
-	expected := []string{
+	datetimeStr := []string{
 		"2021-01-02 16:04:08", "2021-01-02",
 		"02-01-21 16:04:08", "2021/01/02 16:04:08",
 		"2021/01"}
 
 	for i := 0; i < len(cases); i++ {
-		actual, err := FormatStrToTime(expected[i], cases[i])
+		actual, err := FormatStrToTime(datetimeStr[i], cases[i])
 		if err != nil {
 			t.Fatal(err)
 		}
-		expected, _ := time.Parse(formats[i], expected[i])
+		expected, _ := time.Parse(formats[i], datetimeStr[i])
 		assert.Equal(expected, actual)
 	}
-
-	estTime, err := FormatStrToTime("2021-01-02 16:04:08", "yyyy-mm-dd hh:mm:ss", "EST")
-	t.Log(estTime)
-	assert.IsNil(err)
 }
 
 func TestBeginOfMinute(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestBeginOfMinute")
 
 	expected := time.Date(2022, 2, 15, 15, 48, 0, 0, time.Local)
@@ -547,8 +136,6 @@ func TestBeginOfMinute(t *testing.T) {
 }
 
 func TestEndOfMinute(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestEndOfMinute")
 
 	expected := time.Date(2022, 2, 15, 15, 48, 59, 999999999, time.Local)
@@ -559,8 +146,6 @@ func TestEndOfMinute(t *testing.T) {
 }
 
 func TestBeginOfHour(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestBeginOfHour")
 
 	expected := time.Date(2022, 2, 15, 15, 0, 0, 0, time.Local)
@@ -571,8 +156,6 @@ func TestBeginOfHour(t *testing.T) {
 }
 
 func TestEndOfHour(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestEndOfHour")
 
 	expected := time.Date(2022, 2, 15, 15, 59, 59, 999999999, time.Local)
@@ -583,8 +166,6 @@ func TestEndOfHour(t *testing.T) {
 }
 
 func TestBeginOfDay(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestBeginOfDay")
 
 	expected := time.Date(2022, 2, 15, 0, 0, 0, 0, time.Local)
@@ -595,8 +176,6 @@ func TestBeginOfDay(t *testing.T) {
 }
 
 func TestEndOfDay(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestEndOfDay")
 
 	expected := time.Date(2022, 2, 15, 23, 59, 59, 999999999, time.Local)
@@ -607,32 +186,26 @@ func TestEndOfDay(t *testing.T) {
 }
 
 func TestBeginOfWeek(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestBeginOfWeek")
 
-	expected := time.Date(2022, 2, 14, 0, 0, 0, 0, time.Local)
+	expected := time.Date(2022, 2, 13, 0, 0, 0, 0, time.Local)
 	td := time.Date(2022, 2, 15, 15, 48, 40, 112, time.Local)
-	actual := BeginOfWeek(td, time.Monday)
+	actual := BeginOfWeek(td)
 
 	assert.Equal(expected, actual)
 }
 
 func TestEndOfWeek(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestEndOfWeek")
 
-	expected := time.Date(2022, 2, 20, 23, 59, 59, 999999999, time.Local)
+	expected := time.Date(2022, 2, 19, 23, 59, 59, 999999999, time.Local)
 	td := time.Date(2022, 2, 15, 15, 48, 40, 112, time.Local)
-	actual := EndOfWeek(td, time.Sunday)
+	actual := EndOfWeek(td)
 
 	assert.Equal(expected, actual)
 }
 
 func TestBeginOfMonth(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestBeginOfMonth")
 
 	expected := time.Date(2022, 2, 1, 0, 0, 0, 0, time.Local)
@@ -643,8 +216,6 @@ func TestBeginOfMonth(t *testing.T) {
 }
 
 func TestEndOfMonth(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestEndOfMonth")
 
 	expected := time.Date(2022, 2, 28, 23, 59, 59, 999999999, time.Local)
@@ -655,8 +226,6 @@ func TestEndOfMonth(t *testing.T) {
 }
 
 func TestBeginOfYear(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestBeginOfYear")
 
 	expected := time.Date(2022, 1, 1, 0, 0, 0, 0, time.Local)
@@ -667,8 +236,6 @@ func TestBeginOfYear(t *testing.T) {
 }
 
 func TestEndOfYear(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestEndOfYear")
 
 	expected := time.Date(2022, 12, 31, 23, 59, 59, 999999999, time.Local)
@@ -679,8 +246,6 @@ func TestEndOfYear(t *testing.T) {
 }
 
 func TestIsLeapYear(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestEndOfYear")
 
 	result1 := IsLeapYear(2000)
@@ -690,9 +255,21 @@ func TestIsLeapYear(t *testing.T) {
 	assert.Equal(false, result2)
 }
 
-func TestDayOfYear(t *testing.T) {
-	t.Parallel()
+func TestBetweenSeconds(t *testing.T) {
+	assert := internal.NewAssert(t, "TestBetweenSeconds")
 
+	today := time.Now()
+	tomorrow := AddDay(today, 1)
+	yesterday := AddDay(today, -1)
+
+	result1 := BetweenSeconds(today, tomorrow)
+	result2 := BetweenSeconds(today, yesterday)
+
+	assert.Equal(int64(86400), result1)
+	assert.Equal(int64(-86400), result2)
+}
+
+func TestDayOfYear(t *testing.T) {
 	assert := internal.NewAssert(t, "TestDayOfYear")
 	date1 := time.Date(2023, 02, 01, 1, 1, 1, 0, time.Local)
 	result1 := DayOfYear(date1)
@@ -708,10 +285,7 @@ func TestDayOfYear(t *testing.T) {
 }
 
 func TestIsWeekend(t *testing.T) {
-	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestIsWeekend")
-
 	date := time.Date(2023, 06, 03, 0, 0, 0, 0, time.Local)
 	result := IsWeekend(date)
 	assert.Equal(true, result)
@@ -759,187 +333,3 @@ func TestTimestamp(t *testing.T) {
 	ts4 := TimestampNano()
 	t.Log(ts4)
 }
-
-func TestTrackFuncTime(t *testing.T) {
-	defer TrackFuncTime(time.Now())()
-
-	var n int
-	for i := 0; i < 5000000; i++ {
-		n++
-	}
-}
-
-func TestDaysBetween(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestDaysBetween")
-
-	tests := []struct {
-		start    time.Time
-		end      time.Time
-		expected int
-	}{
-		{
-			start:    time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC),
-			end:      time.Date(2024, time.September, 10, 0, 0, 0, 0, time.UTC),
-			expected: 9,
-		},
-		{
-			start:    time.Date(2024, time.September, 10, 0, 0, 0, 0, time.UTC),
-			end:      time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC),
-			expected: -9,
-		},
-		{
-			start:    time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC),
-			end:      time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC),
-			expected: 0,
-		},
-		{
-			start:    time.Date(2024, time.January, 1, 0, 0, 0, 0, time.UTC),
-			end:      time.Date(2024, time.December, 31, 0, 0, 0, 0, time.UTC),
-			expected: 365,
-		},
-		{
-			start:    time.Date(2024, time.March, 1, 0, 0, 0, 0, time.UTC),
-			end:      time.Date(2024, time.March, 31, 0, 0, 0, 0, time.UTC),
-			expected: 30,
-		},
-	}
-
-	for _, tt := range tests {
-		result := DaysBetween(tt.start, tt.end)
-		assert.Equal(tt.expected, result)
-	}
-}
-
-func TestGenerateDatetimesBetween(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestGenerateDatetimesBetween")
-
-	tests := []struct {
-		start    time.Time
-		end      time.Time
-		layout   string
-		interval string
-		expected []string
-	}{
-		{
-			start:    time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC),
-			end:      time.Date(2024, time.September, 1, 2, 0, 0, 0, time.UTC),
-			layout:   "2006-01-02 15:04:05",
-			interval: "30m",
-			expected: []string{
-				"2024-09-01 00:00:00",
-				"2024-09-01 00:30:00",
-				"2024-09-01 01:00:00",
-				"2024-09-01 01:30:00",
-				"2024-09-01 02:00:00",
-			},
-		},
-		{
-			start:    time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC),
-			end:      time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC),
-			layout:   "2006-01-02 15:04:05",
-			interval: "1h",
-			expected: []string{"2024-09-01 00:00:00"},
-		},
-		{
-			start:    time.Date(2024, time.September, 1, 0, 0, 0, 0, time.UTC),
-			end:      time.Date(2024, time.September, 1, 3, 0, 0, 0, time.UTC),
-			layout:   "2006-01-02 15:04:05",
-			interval: "2h",
-			expected: []string{
-				"2024-09-01 00:00:00",
-				"2024-09-01 02:00:00",
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		result, err := GenerateDatetimesBetween(tt.start, tt.end, tt.layout, tt.interval)
-
-		assert.Equal(tt.expected, result)
-		assert.IsNil(err)
-	}
-
-	t.Run("Invalid interval", func(t *testing.T) {
-		_, err := GenerateDatetimesBetween(time.Now(), time.Now(), "2006-01-02 15:04:05", "invalid")
-		if err == nil {
-			t.Fatal("Expected error, got nil")
-		}
-	})
-}
-
-func TestMin(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestMin")
-
-	zeroTime := time.Time{}
-	now := time.Now()
-	oneMinuteAgo := now.Add(-time.Minute)
-	oneMinuteAfter := now.Add(time.Minute)
-
-	assert.Equal(zeroTime, Min(zeroTime, now, oneMinuteAgo, oneMinuteAfter))
-
-	assert.Equal(zeroTime, Min(now, zeroTime))
-
-	assert.Equal(oneMinuteAgo, Min(oneMinuteAgo, now, oneMinuteAfter))
-}
-
-func TestMax(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestMax")
-
-	zeroTime := time.Time{}
-	now := time.Now()
-	oneMinuteAgo := now.Add(-time.Minute)
-	oneMinuteAfter := now.Add(time.Minute)
-
-	assert.Equal(oneMinuteAfter, Max(zeroTime, now, oneMinuteAgo, oneMinuteAfter))
-
-	assert.Equal(now, Max(now, zeroTime))
-
-	assert.Equal(oneMinuteAfter, Max(oneMinuteAgo, now, oneMinuteAfter))
-}
-
-func TestMaxMin(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestMinMax")
-
-	zeroTime := time.Time{}
-	now := time.Now()
-	oneMinuteAgo := now.Add(-time.Minute)
-	oneMinuteAfter := now.Add(time.Minute)
-
-	max, min := MaxMin(zeroTime, now, oneMinuteAgo, oneMinuteAfter)
-	assert.Equal(zeroTime, min)
-	assert.Equal(oneMinuteAfter, max)
-
-	max, min = MaxMin(now, zeroTime)
-	assert.Equal(zeroTime, min)
-	assert.Equal(now, max)
-
-	max, min = MaxMin(oneMinuteAgo, now, oneMinuteAfter)
-	assert.Equal(oneMinuteAgo, min)
-	assert.Equal(oneMinuteAfter, max)
-}
-
-func TestBetweenSeconds(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestBetweenSeconds")
-
-	today := time.Now()
-	tomorrow := AddDay(today, 1)
-	yesterday := AddDay(today, -1)
-
-	result1 := BetweenSeconds(today, tomorrow)
-	result2 := BetweenSeconds(today, yesterday)
-
-	assert.Equal(int64(86400), result1)
-	assert.Equal(int64(-86400), result2)
-}

docs/.vitepress/common.ts

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

docs/.vitepress/config.mts

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

docs/.vitepress/en.ts

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

docs/.vitepress/zh.ts

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

docs/api/overview.md

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

docs/api/packages/algorithm.md

@@ -1,636 +0,0 @@
-# Algorithm
-
-algorithm 算法包实现一些基本算法，sort，search，lrucache。
-
-<div STYLE="page-break-after: always;"></div>
-
-## 源码
-
--   [https://github.com/duke-git/lancet/blob/main/algorithm/sort.go](https://github.com/duke-git/lancet/blob/main/algorithm/sort.go)
--   [https://github.com/duke-git/lancet/blob/main/algorithm/search.go](https://github.com/duke-git/lancet/blob/main/algorithm/search.go)
--   [https://github.com/duke-git/lancet/blob/main/algorithm/lrucache.go](https://github.com/duke-git/lancet/blob/main/algorithm/lrucache.go)
-
-<div STYLE="page-break-after: always;"></div>
-
-## 用法
-
-```go
-import (
-    "github.com/duke-git/lancet/v2/algorithm"
-)
-```
-
-<div STYLE="page-break-after: always;"></div>
-
-## 目录
-
--   [BubbleSort](#BubbleSort)
--   [InsertionSort](#InsertionSort)
--   [SelectionSort](#SelectionSort)
--   [ShellSort](#ShellSort)
--   [QuickSort](#QuickSort)
--   [HeapSort](#HeapSort)
--   [MergeSort](#MergeSort)
--   [CountSort](#CountSort)
--   [BinarySearch](#BinarySearch)
--   [BinaryIterativeSearch](#BinaryIterativeSearch)
--   [LinearSearch](#LinearSearch)
--   [LRUCache](#LRUCache)
-
-<div STYLE="page-break-after: always;"></div>
-
-## 文档
-
-### <span id="BubbleSort">BubbleSort</span>
-
-<p>冒泡排序，参数comparator需要实现包constraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-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>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/algorithm"
-)
-
-type intComparator struct{}
-
-func (c *intComparator) Compare(v1 any, v2 any) int {
-    val1, _ := v1.(int)
-    val2, _ := v2.(int)
-
-    //ascending order
-    if val1 < val2 {
-        return -1
-    } else if val1 > val2 {
-        return 1
-    }
-    return 0
-}
-
-func main() {
-    numbers := []int{2, 1, 5, 3, 6, 4}
-    comparator := &intComparator{}
-
-    algorithm.BubbleSort(numbers, comparator)
-
-    fmt.Println(numbers)
-
-    // Output:
-    // [1 2 3 4 5 6]
-}
-```
-
-### <span id="InsertionSort">InsertionSort</span>
-
-<p>插入排序，参数comparator需要实现包constraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-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>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/algorithm"
-)
-
-type people struct {
-    Name string
-    Age  int
-}
-
-// PeopleAageComparator sort people slice by age field
-type peopleAgeComparator struct{}
-
-// 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)
-
-    //ascending order
-    if p1.Age < p2.Age {
-        return -1
-    } else if p1.Age > p2.Age {
-        return 1
-    }
-
-    return 0
-}
-
-func main() {
-    peoples := []people{
-        {Name: "a", Age: 20},
-        {Name: "b", Age: 10},
-        {Name: "c", Age: 17},
-        {Name: "d", Age: 8},
-        {Name: "e", Age: 28},
-    }
-
-    comparator := &peopleAgeComparator{}
-
-    algorithm.InsertionSort(peoples, comparator)
-
-    fmt.Println(peoples)
-
-    // Output:
-    // [{d 8} {b 10} {c 17} {a 20} {e 28}]
-}
-```
-
-### <span id="SelectionSort">SelectionSort</span>
-
-<p>选择排序，参数comparator需要实现包constraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-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>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/algorithm"
-)
-
-type intComparator struct{}
-
-func (c *intComparator) Compare(v1 any, v2 any) int {
-    val1, _ := v1.(int)
-    val2, _ := v2.(int)
-
-    //ascending order
-    if val1 < val2 {
-        return -1
-    } else if val1 > val2 {
-        return 1
-    }
-    return 0
-}
-
-func main() {
-    numbers := []int{2, 1, 5, 3, 6, 4}
-    comparator := &intComparator{}
-
-    algorithm.SelectionSort(numbers, comparator)
-
-    fmt.Println(numbers)
-
-    // Output:
-    // [1 2 3 4 5 6]
-}
-```
-
-### <span id="ShellSort">ShellSort</span>
-
-<p>希尔排序，参数comparator需要实现包constraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-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>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/algorithm"
-)
-
-type intComparator struct{}
-
-func (c *intComparator) Compare(v1 any, v2 any) int {
-    val1, _ := v1.(int)
-    val2, _ := v2.(int)
-
-    //ascending order
-    if val1 < val2 {
-        return -1
-    } else if val1 > val2 {
-        return 1
-    }
-    return 0
-}
-
-func main() {
-    numbers := []int{2, 1, 5, 3, 6, 4}
-    comparator := &intComparator{}
-
-    algorithm.ShellSort(numbers, comparator)
-
-    fmt.Println(numbers)
-
-    // Output:
-    // [1 2 3 4 5 6]
-}
-```
-
-### <span id="QuickSort">QuickSort</span>
-
-<p>快速排序，参数comparator需要实现包constraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-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>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/algorithm"
-)
-
-type intComparator struct{}
-
-func (c *intComparator) Compare(v1 any, v2 any) int {
-    val1, _ := v1.(int)
-    val2, _ := v2.(int)
-
-    //ascending order
-    if val1 < val2 {
-        return -1
-    } else if val1 > val2 {
-        return 1
-    }
-    return 0
-}
-
-func main() {
-    numbers := []int{2, 1, 5, 3, 6, 4}
-    comparator := &intComparator{}
-
-    algorithm.QuickSort(numbers, comparator)
-
-    fmt.Println(numbers)
-
-    // Output:
-    // [1 2 3 4 5 6]
-}
-```
-
-### <span id="HeapSort">HeapSort</span>
-
-<p>堆排序，参数comparator需要实现包constraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-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>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/algorithm"
-)
-
-type intComparator struct{}
-
-func (c *intComparator) Compare(v1 any, v2 any) int {
-    val1, _ := v1.(int)
-    val2, _ := v2.(int)
-
-    //ascending order
-    if val1 < val2 {
-        return -1
-    } else if val1 > val2 {
-        return 1
-    }
-    return 0
-}
-
-func main() {
-    numbers := []int{2, 1, 5, 3, 6, 4}
-    comparator := &intComparator{}
-
-    algorithm.HeapSort(numbers, comparator)
-
-    fmt.Println(numbers)
-
-    // Output:
-    // [1 2 3 4 5 6]
-}
-```
-
-### <span id="MergeSort">MergeSort</span>
-
-<p>归并排序，参数comparator需要实现包constraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-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>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/algorithm"
-)
-
-type intComparator struct{}
-
-func (c *intComparator) Compare(v1 any, v2 any) int {
-    val1, _ := v1.(int)
-    val2, _ := v2.(int)
-
-    //ascending order
-    if val1 < val2 {
-        return -1
-    } else if val1 > val2 {
-        return 1
-    }
-    return 0
-}
-
-func main() {
-    numbers := []int{2, 1, 5, 3, 6, 4}
-    comparator := &intComparator{}
-
-    algorithm.MergeSort(numbers, comparator)
-
-    fmt.Println(numbers)
-
-    // Output:
-    // [1 2 3 4 5 6]
-}
-```
-
-### <span id="CountSort">CountSort</span>
-
-<p>计数排序，参数comparator需要实现包constraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-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>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/algorithm"
-)
-
-
-type intComparator struct{}
-
-func (c *intComparator) Compare(v1 any, v2 any) int {
-    val1, _ := v1.(int)
-    val2, _ := v2.(int)
-
-    //ascending order
-    if val1 < val2 {
-        return -1
-    } else if val1 > val2 {
-        return 1
-    }
-    return 0
-}
-
-func main() {
-    numbers := []int{2, 1, 5, 3, 6, 4}
-    comparator := &intComparator{}
-
-    sortedNums := algorithm.CountSort(numbers, comparator)
-
-    fmt.Println(sortedNums)
-
-    // Output:
-    // [1 2 3 4 5 6]
-}
-```
-
-### <span id="BinarySearch">BinarySearch</span>
-
-<p>二分递归查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包constraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-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>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/algorithm"
-)
-
-type intComparator struct{}
-
-func (c *intComparator) Compare(v1 any, v2 any) int {
-    val1, _ := v1.(int)
-    val2, _ := v2.(int)
-
-    //ascending order
-    if val1 < val2 {
-        return -1
-    } else if val1 > val2 {
-        return 1
-    }
-    return 0
-}
-
-func main() {
-    numbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
-    comparator := &intComparator{}
-
-    result1 := algorithm.BinarySearch(numbers, 5, 0, len(numbers)-1, comparator)
-    result2 := algorithm.BinarySearch(numbers, 9, 0, len(numbers)-1, comparator)
-
-    fmt.Println(result1)
-    fmt.Println(result2)
-
-    // Output:
-    // 4
-    // -1
-}
-```
-
-### <span id="BinaryIterativeSearch">BinaryIterativeSearch</span>
-
-<p>二分迭代查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包constraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-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>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/algorithm"
-)
-
-type intComparator struct{}
-
-func (c *intComparator) Compare(v1 any, v2 any) int {
-    val1, _ := v1.(int)
-    val2, _ := v2.(int)
-
-    //ascending order
-    if val1 < val2 {
-        return -1
-    } else if val1 > val2 {
-        return 1
-    }
-    return 0
-}
-
-func main() {
-    numbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
-    comparator := &intComparator{}
-
-    result1 := algorithm.BinaryIterativeSearch(numbers, 5, 0, len(numbers)-1, comparator)
-    result2 := algorithm.BinaryIterativeSearch(numbers, 9, 0, len(numbers)-1, comparator)
-
-    fmt.Println(result1)
-    fmt.Println(result2)
-
-    // Output:
-    // 4
-    // -1
-}
-```
-
-### <span id="LinearSearch">LinearSearch</span>
-
-<p>基于传入的相等函数线性查找元素，返回元素索引，未找到元素返回-1。</p>
-
-<b>函数签名:</b>
-
-```go
-func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int
-```
-
-<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/IsS7rgn5s3x)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/algorithm"
-)
-
-func main() {
-    numbers := []int{3, 4, 5, 3, 2, 1}
-
-    equalFunc := func(a, b int) bool {
-        return a == b
-    }
-
-    result1 := algorithm.LinearSearch(numbers, 3, equalFunc)
-    result2 := algorithm.LinearSearch(numbers, 6, equalFunc)
-
-    fmt.Println(result1)
-    fmt.Println(result2)
-
-    // Output:
-    // 0
-    // -1
-}
-```
-
-### <span id="LRUCache">LRUCache</span>
-
-<p>lru算法实现缓存。</p>
-
-<b>函数签名:</b>
-
-```go
-func NewLRUCache[K comparable, V any](capacity int) *LRUCache[K, V]
-func (l *LRUCache[K, V]) Get(key K) (V, bool)
-func (l *LRUCache[K, V]) Put(key K, value V)
-func (l *LRUCache[K, V]) Delete(key K) bool
-func (l *LRUCache[K, V]) Len() int
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/-EZjgOURufP)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/algorithm"
-)
-
-func main() {
-    cache := algorithm.NewLRUCache[int, int](2)
-
-    cache.Put(1, 1)
-    cache.Put(2, 2)
-
-    result1, ok1 := cache.Get(1)
-    result2, ok2 := cache.Get(2)
-    result3, ok3 := cache.Get(3)
-
-    fmt.Println(result1, ok1)
-    fmt.Println(result2, ok2)
-    fmt.Println(result3, ok3)
-
-    fmt.Println(cache.Len())
-
-    ok := cache.Delete(2)
-    fmt.Println(ok)
-
-
-    // Output:
-    // 1 true
-    // 2 true
-    // 0 false
-    // 2
-    // true
-}
-```

docs/api/packages/concurrency.md

@@ -1,852 +0,0 @@
-# Concurrency
-
-并发包包含一些支持并发编程的功能。例如：goroutine, channel 等。
-
-<div STYLE="page-break-after: always;"></div>
-
-## 源码:
-
--   [https://github.com/duke-git/lancet/blob/main/concurrency/channel.go](https://github.com/duke-git/lancet/blob/main/concurrency/channel.go)
--   [https://github.com/duke-git/lancet/blob/main/concurrency/keyed_locker.go](https://github.com/duke-git/lancet/blob/main/concurrency/keyed_locker.go)
-
-<div STYLE="page-break-after: always;"></div>
-
-## 用法:
-
-```go
-import (
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-```
-
-<div STYLE="page-break-after: always;"></div>
-
-## 目录
-
-### Channel
-
--   [NewChannel](#NewChannel)
--   [Bridge](#Bridge)
--   [FanIn](#FanIn)
--   [Generate](#Generate)
--   [Or](#Or)
--   [OrDone](#OrDone)
--   [Repeat](#Repeat)
--   [RepeatFn](#RepeatFn)
--   [Take](#Take)
--   [Tee](#Tee)
-
-### KeyedLocker
-
--   [NewKeyedLocker](#NewKeyedLocker)
--   [KeyedLocker_Do](#Do)
--   [NewRWKeyedLocker](#NewRWKeyedLocker)
--   [RLock](#RLock)
--   [Lock](#Lock)
--   [NewTryKeyedLocker](#NewTryKeyedLocker)
--   [TryLock](#TryLock)
--   [Unlock](#Unlock)
-
-<div STYLE="page-break-after: always;"></div>
-
-## 文档
-
-### Channel
-
-### <span id="NewChannel">NewChannel</span>
-
-<p>返回一个Channel指针实例</p>
-
-<b>函数签名:</b>
-
-```go
-type Channel[T any] struct
-func NewChannel[T any]() *Channel[T]
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/7aB4KyMMp9A)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    c := concurrency.NewChannel[int]()
-}
-```
-
-### <span id="Bridge">Bridge</span>
-
-<p>将多个channel链接到一个channel，直到取消上下文。</p>
-
-<b>函数签名:</b>
-
-```go
-func (c *Channel[T]) Bridge(ctx context.Context, chanStream <-chan <-chan T) <-chan T
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qmWSy1NVF-Y)</span></b>
-
-```go
-package main
-
-import (
-    "context"
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    ctx, cancel := context.WithCancel(context.Background())
-    defer cancel()
-
-    c := concurrency.NewChannel[int]()
-    genVals := func() <-chan <-chan int {
-        out := make(chan (<-chan int))
-        go func() {
-            defer close(out)
-            for i := 1; i <= 5; i++ {
-                stream := make(chan int, 1)
-                stream <- i
-                close(stream)
-                out <- stream
-            }
-        }()
-        return out
-    }
-
-    for v := range c.Bridge(ctx, genVals()) {
-        fmt.Println(v)
-    }
-
-    // Output:
-    // 1
-    // 2
-    // 3
-    // 4
-    // 5
-}
-```
-
-### <span id="FanIn">FanIn</span>
-
-<p>将多个channel合并为一个channel，直到取消上下文。</p>
-
-<b>函数签名:</b>
-
-```go
-func (c *Channel[T]) FanIn(ctx context.Context, channels ...<-chan T) <-chan T
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2VYFMexEvTm)</span></b>
-
-```go
-package main
-
-import (
-    "context"
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    ctx, cancel := context.WithCancel(context.Background())
-    defer cancel()
-
-    c := concurrency.NewChannel[int]()
-    channels := make([]<-chan int, 2)
-
-    for i := 0; i < 2; i++ {
-        channels[i] = c.Take(ctx, c.Repeat(ctx, i), 2)
-    }
-
-    chs := c.FanIn(ctx, channels...)
-
-    for v := range chs {
-        fmt.Println(v) //1 1 0 0 or 0 0 1 1
-    }
-}
-```
-
-### <span id="Generate">Generate</span>
-
-<p>根据传入的值，生成channel.</p>
-
-<b>函数签名:</b>
-
-```go
-func (c *Channel[T]) Generate(ctx context.Context, values ...T) <-chan T
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/7aB4KyMMp9A)</span></b>
-
-```go
-package main
-
-import (
-    "context"
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    ctx, cancel := context.WithCancel(context.Background())
-    defer cancel()
-
-    c := concurrency.NewChannel[int]()
-    intStream := c.Generate(ctx, 1, 2, 3)
-
-    fmt.Println(<-intStream)
-    fmt.Println(<-intStream)
-    fmt.Println(<-intStream)
-
-    // Output:
-    // 1
-    // 2
-    // 3
-}
-```
-
-### <span id="Repeat">Repeat</span>
-
-<p>返回一个channel，将参数`values`重复放入channel，直到取消上下文。</p>
-
-<b>函数签名:</b>
-
-```go
-func (c *Channel[T]) Repeat(ctx context.Context, values ...T) <-chan T
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/k5N_ALVmYjE)</span></b>
-
-```go
-package main
-
-import (
-    "context"
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    ctx, cancel := context.WithCancel(context.Background())
-    defer cancel()
-
-    c := concurrency.NewChannel[int]()
-    intStream := c.Take(ctx, c.Repeat(ctx, 1, 2), 4)
-
-    for v := range intStream {
-        fmt.Println(v)
-    }
-
-    // Output:
-    // 1
-    // 2
-    // 1
-    // 2
-}
-```
-
-### <span id="RepeatFn">RepeatFn</span>
-
-<p>返回一个channel，重复执行函数fn，并将结果放入返回的channel，直到取消上下文。</p>
-
-<b>函数签名:</b>
-
-```go
-func (c *Channel[T]) RepeatFn(ctx context.Context, fn func() T) <-chan T
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4J1zAWttP85)</span></b>
-
-```go
-package main
-
-import (
-    "context"
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    ctx, cancel := context.WithCancel(context.Background())
-    defer cancel()
-
-    fn := func() string {
-        return "hello"
-    }
-
-    c := concurrency.NewChannel[string]()
-    intStream := c.Take(ctx, c.RepeatFn(ctx, fn), 3)
-
-    for v := range intStream {
-        fmt.Println(v)
-    }
-    // Output:
-    // hello
-    // hello
-    // hello
-}
-```
-
-### <span id="Or">Or</span>
-
-<p>将一个或多个channel读取到一个channel中，当任何读取channel关闭时将结束读取。</p>
-
-<b>函数签名:</b>
-
-```go
-func (c *Channel[T]) Or(channels ...<-chan T) <-chan T
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Wqz9rwioPww)</span></b>
-
-```go
-package main
-
-import (
-    "context"
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    sig := func(after time.Duration) <-chan any {
-        c := make(chan any)
-        go func() {
-            defer close(c)
-            time.Sleep(after)
-        }()
-        return c
-    }
-
-    start := time.Now()
-
-    c := concurrency.NewChannel[any]()
-    <-c.Or(
-        sig(1*time.Second),
-        sig(2*time.Second),
-        sig(3*time.Second),
-    )
-
-    fmt.Println("done after %v", time.Since(start)) //1.003s
-}
-```
-
-### <span id="OrDone">OrDone</span>
-
-<p>将一个channel读入另一个channel，直到取消上下文。</p>
-
-<b>函数签名:</b>
-
-```go
-func (c *Channel[T]) OrDone(ctx context.Context, channel <-chan T) <-chan T
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/lm_GoS6aDjo)</span></b>
-
-```go
-package main
-
-import (
-    "context"
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    ctx, cancel := context.WithCancel(context.Background())
-    defer cancel()
-
-    c := concurrency.NewChannel[int]()
-    intStream := c.Take(ctx, c.Repeat(ctx, 1), 3)
-
-    for v := range c.OrDone(ctx, intStream) {
-        fmt.Println(v)
-    }
-
-    // Output:
-    // 1
-    // 1
-    // 1
-}
-```
-
-### <span id="Take">Take</span>
-
-<p>返回一个channel，其值从另一个channel获取，直到取消上下文。</p>
-
-<b>函数签名:</b>
-
-```go
-func (c *Channel[T]) Take(ctx context.Context, valueStream <-chan T, number int) <-chan T
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9Utt-1pDr2J)</span></b>
-
-```go
-package main
-
-import (
-    "context"
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    ctx, cancel := context.WithCancel(context.Background())
-    defer cancel()
-
-    numbers := make(chan int, 5)
-    numbers <- 1
-    numbers <- 2
-    numbers <- 3
-    numbers <- 4
-    numbers <- 5
-    defer close(numbers)
-
-    c := concurrency.NewChannel[int]()
-    intStream := c.Take(ctx, numbers, 3)
-
-    for v := range intStream {
-        fmt.Println(v)
-    }
-
-    // Output:
-    // 1
-    // 2
-    // 3
-}
-```
-
-### <span id="Tee">Tee</span>
-
-<p>将一个channel分成两个channel，直到取消上下文。</p>
-
-<b>函数签名:</b>
-
-```go
-func (c *Channel[T]) Tee(ctx context.Context, in <-chan T) (<-chan T, <-chan T)
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3TQPKnCirrP)</span></b>
-
-```go
-package main
-
-import (
-    "context"
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    ctx, cancel := context.WithCancel(context.Background())
-    defer cancel()
-
-    c := concurrency.NewChannel[int]()
-    intStream := c.Take(ctx, c.Repeat(ctx, 1), 2)
-
-    ch1, ch2 := c.Tee(ctx, intStream)
-
-    for v := range ch1 {
-        fmt.Println(v)
-        fmt.Println(<-ch2)
-    }
-    // Output:
-    // 1
-    // 1
-    // 1
-    // 1
-}
-```
-
-### KeyedLocker
-
-### <span id="NewKeyedLocker">NewKeyedLocker</span>
-
-<p>NewKeyedLocker创建一个新的KeyedLocker，并为锁的过期设置指定的 TTL。KeyedLocker 是一个简单的键值锁实现，允许非阻塞的锁获取。</p>
-
-<b>函数签名:</b>
-
-```go
-func NewKeyedLocker[K comparable](ttl time.Duration) *KeyedLocker[K]
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GzeyC33T5rw)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    locker := concurrency.NewKeyedLocker[string](2 * time.Second)
-
-    task := func() {
-        fmt.Println("Executing task...")
-        time.Sleep(1 * time.Second)
-        fmt.Println("Task completed.")
-    }
-
-    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
-    defer cancel()
-
-    if err := locker.Do(ctx, "mykey", task); err != nil {
-        log.Fatalf("Error executing task: %v\n", err)
-    } else {
-        fmt.Println("Task successfully executed.")
-    }
-
-    ctx2, cancel2 := context.WithTimeout(context.Background(), 3*time.Second)
-    defer cancel2()
-
-    if err := locker.Do(ctx2, "mykey", task); err != nil {
-        log.Fatalf("Error executing task: %v\n", err)
-    } else {
-        fmt.Println("Task successfully executed.")
-    }
-
-    // Output:
-    // Executing task...
-    // Task completed.
-    // Task successfully executed.
-    // Executing task...
-    // Task completed.
-    // Task successfully executed.
-}
-```
-
-### <span id="Do">Do</span>
-
-<p>为指定的键获取锁并执行提供的函数。</p>
-
-<b>函数签名:</b>
-
-```go
-func (l *KeyedLocker[K]) Do(ctx context.Context, key K, fn func()) error
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GzeyC33T5rw)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    locker := concurrency.NewKeyedLocker[string](2 * time.Second)
-
-    task := func() {
-        fmt.Println("Executing task...")
-        time.Sleep(1 * time.Second)
-        fmt.Println("Task completed.")
-    }
-
-    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
-    defer cancel()
-
-    if err := locker.Do(ctx, "mykey", task); err != nil {
-        log.Fatalf("Error executing task: %v\n", err)
-    } else {
-        fmt.Println("Task successfully executed.")
-    }
-
-    ctx2, cancel2 := context.WithTimeout(context.Background(), 3*time.Second)
-    defer cancel2()
-
-    if err := locker.Do(ctx2, "mykey", task); err != nil {
-        log.Fatalf("Error executing task: %v\n", err)
-    } else {
-        fmt.Println("Task successfully executed.")
-    }
-
-    // Output:
-    // Executing task...
-    // Task completed.
-    // Task successfully executed.
-    // Executing task...
-    // Task completed.
-    // Task successfully executed.
-}
-```
-
-### <span id="NewRWKeyedLocker">NewRWKeyedLocker</span>
-
-<p>NewRWKeyedLocker创建一个新的RWKeyedLocker，并为锁的过期设置指定的 TTL。RWKeyedLocker 是一个简单的键值读写锁实现，允许非阻塞的锁获取。</p>
-
-<b>函数签名:</b>
-
-```go
-func NewRWKeyedLocker[K comparable](ttl time.Duration) *RWKeyedLocker[K]
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/CkaJWWwZm9)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    locker := concurrency.NewRWKeyedLocker[string](2 * time.Second)
-
-    // Simulate a key
-    key := "resource_key"
-
-    fn := func() {
-        fmt.Println("Starting write operation...")
-        // Simulate write operation, assuming it takes 2 seconds
-        time.Sleep(200 * time.Millisecond)
-        fmt.Println("Write operation completed!")
-    }
-
-    // Acquire the write lock and execute the operation
-    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-    defer cancel()
-
-    // Execute the lock operation with a 3-second timeout
-    err := locker.Lock(ctx, key, fn)
-    if err != nil {
-        return
-    }
-
-    //output:
-    //Starting write operation...
-    //Write operation completed!
-}
-```
-
-### <span id="RLock">RLock</span>
-
-<p>RLock为指定的键获取读锁并执行提供的函数。</p>
-
-<b>函数签名:</b>
-
-```go
-func (l *RWKeyedLocker[K]) RLock(ctx context.Context, key K, fn func()) error
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ZrCr8sMo77T)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    locker := concurrency.NewRWKeyedLocker[string](2 * time.Second)
-
-    // Simulate a key
-    key := "resource_key"
-
-    fn := func() {
-        fmt.Println("Starting write operation...")
-        // Simulate write operation, assuming it takes 2 seconds
-        time.Sleep(200 * time.Millisecond)
-        fmt.Println("Write operation completed!")
-    }
-
-    // Acquire the write lock and execute the operation
-    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-    defer cancel()
-
-    // Execute the lock operation with a 3-second timeout
-    err := locker.RLock(ctx, key, fn)
-    if err != nil {
-        return
-    }
-
-    //output:
-    //Starting write operation...
-    //Write operation completed!
-}
-```
-
-### <span id="Lock">Lock</span>
-
-<p>Lock为指定的键获取锁并执行提供的函数。</p>
-
-<b>函数签名:</b>
-
-```go
-func (l *RWKeyedLocker[K]) Lock(ctx context.Context, key K, fn func()) error
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/WgAcXbOPKGk)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    locker := NewRWKeyedLocker[string](2 * time.Second)
-
-    // Simulate a key
-    key := "resource_key"
-
-    fn := func() {
-        fmt.Println("Starting write operation...")
-        // Simulate write operation, assuming it takes 2 seconds
-        time.Sleep(200 * time.Millisecond)
-        fmt.Println("Write operation completed!")
-    }
-
-    // Acquire the write lock and execute the operation
-    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-    defer cancel()
-
-    // Execute the lock operation with a 3-second timeout
-    err := locker.Lock(ctx, key, fn)
-    if err != nil {
-        return
-    }
-
-    //output:
-    //Starting write operation...
-    //Write operation completed!
-}
-```
-
-### <span id="NewTryKeyedLocker">NewTryKeyedLocker</span>
-
-<p>创建一个TryKeyedLocker实例，TryKeyedLocker是KeyedLocker的非阻塞版本。</p>
-
-<b>函数签名:</b>
-
-```go
-func NewTryKeyedLocker[K comparable]() *TryKeyedLocker[K]
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VG9qLvyetE2)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    locker := concurrency.NewTryKeyedLocker[string]()
-
-    key := "resource_key"
-
-    if locker.TryLock(key) {
-        fmt.Println("Lock acquired")
-        time.Sleep(1 * time.Second)
-        // Unlock after work is done
-        locker.Unlock(key)
-        fmt.Println("Lock released")
-    } else {
-        fmt.Println("Lock failed")
-    }
-
-    //output:
-    //Lock acquired
-    //Lock released
-}
-```
-
-### <span id="TryLock">TryLock</span>
-
-<p>TryLock尝试获取指定键的锁。如果锁成功获取，则返回true，否则返回false。</p>
-
-<b>函数签名:</b>
-
-```go
-func (l *TryKeyedLocker[K]) TryLock(key K) bool
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VG9qLvyetE2)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    locker := concurrency.NewTryKeyedLocker[string]()
-
-    key := "resource_key"
-
-    if locker.TryLock(key) {
-        fmt.Println("Lock acquired")
-        time.Sleep(1 * time.Second)
-        // Unlock after work is done
-        locker.Unlock(key)
-        fmt.Println("Lock released")
-    } else {
-        fmt.Println("Lock failed")
-    }
-
-    //output:
-    //Lock acquired
-    //Lock released
-}
-```
-
-### <span id="Unlock">Unlock</span>
-
-<p>释放指定键的锁。</p>
-
-<b>函数签名:</b>
-
-```go
-func (l *TryKeyedLocker[K]) Unlock(key K)
-```
-
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VG9qLvyetE2)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-
-func main() {
-    locker := concurrency.NewTryKeyedLocker[string]()
-
-    key := "resource_key"
-
-    if locker.TryLock(key) {
-        fmt.Println("Lock acquired")
-        time.Sleep(1 * time.Second)
-        // Unlock after work is done
-        locker.Unlock(key)
-        fmt.Println("Lock released")
-    } else {
-        fmt.Println("Lock failed")
-    }
-
-    //output:
-    //Lock acquired
-    //Lock released
-}
-```

docs/api/packages/condition.md

@@ -1,335 +0,0 @@
-# Condition
-condition包含一些用于条件判断的函数。这个包的实现参考了carlmjohnson的truthy包的实现，更多有用的信息可以在[truthy](https://github.com/carlmjohnson/truthy)中找到，感谢carlmjohnson。
-
-<div STYLE="page-break-after: always;"></div>
-
-## 源码:
-
-- [https://github.com/duke-git/lancet/blob/main/condition/condition.go](https://github.com/duke-git/lancet/blob/main/condition/condition.go)
-
-<div STYLE="page-break-after: always;"></div>
-
-## 用法:
-```go
-import (
-    "github.com/duke-git/lancet/v2/condition"
-)
-```
-
-<div STYLE="page-break-after: always;"></div>
-
-## 目录
-
-- [Bool](#Bool)
-- [And](#And)
-- [Or](#Or)
-- [Xor](#Generate)
-- [Nor](#Nor)
-- [Xnor](#Xnor)
-- [Nand](#Nand)
-- [Ternary](#Ternary)
-- [TernaryOperator<sup>deprecated</sup>](#TernaryOperator)
-
-<div STYLE="page-break-after: always;"></div>
-
-## 文档
-
-### <span id="Bool">Bool</span>
-<p>返回传入参数的bool值.<br/>
-如果出入类型参数含有Bool方法, 会调用该方法并返回<br/>
-如果传入类型参数有IsZero方法, 返回IsZero方法返回值的取反<br/>
-slices和map的length大于0时，返回true，否则返回false<br/>
-其他类型会判断是否是零值</p>
-
-<b>函数签名:</b>
-
-```go
-func Bool[T any](value T) bool
-```
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ETzeDJRSvhm)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/condition"
-)
-
-func main() {
-    // bool
-    result1 := condition.Bool(false)
-    result2 := condition.Bool(true)
-    fmt.Println(result1) // false
-    fmt.Println(result2) // true
-
-    // integer
-    result3 := condition.Bool(0) 
-    result4 := condition.Bool(1)
-    fmt.Println(result3) // false
-    fmt.Println(result4) // true
-
-    // string
-    result5 := condition.Bool("")
-    result6 := condition.Bool(" ")
-    fmt.Println(result5) // false
-    fmt.Println(result6) // true
-
-    // slice
-    nums := []int{}
-    result7 := condition.Bool(nums)
-
-    nums = append(nums, 1, 2)
-    result8 := condition.Bool(nums)
-    fmt.Println(result7) // false
-    fmt.Println(result8) // true
-
-    // struct
-    result9 = condition.Bool(struct{}{})
-    fmt.Println(result8) // false
-
-
-    // Output:
-    // false
-    // true
-    // false
-    // true
-    // false
-    // true
-    // false
-    // true
-    // false
-}
-```
-
-### <span id="And">And</span>
-<p>逻辑且操作，当切仅当a和b都为true时返回true</p>
-
-<b>函数签名:</b>
-
-```go
-func And[T, U any](a T, b U) bool
-```
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/W1SSUmt6pvr)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/condition"
-)
-
-func main() {
-    fmt.Println(condition.And(0, 1)) // false
-    fmt.Println(condition.And(0, "")) // false
-    fmt.Println(condition.And(0, "0")) // false
-    fmt.Println(condition.And(1, "0")) // true
-}
-```
-
-### <span id="Or">Or</span>
-<p>逻辑或操作，当切仅当a和b都为false时返回false</p>
-
-<b>函数签名:</b>
-
-```go
-func Or[T, U any](a T, b U) bool
-```
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UlQTxHaeEkq)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/condition"
-)
-
-func main() {
-    fmt.Println(condition.Or(0, "")) // false
-    fmt.Println(condition.Or(0, 1)) // true
-    fmt.Println(condition.Or(0, "0")) // true
-    fmt.Println(condition.Or(1, "0")) // true
-}
-```
-
-### <span id="Xor">Xor</span>
-<p>逻辑异或操作，a和b相同返回false，a和b不相同返回true</p>
-
-<b>函数签名:</b>
-
-```go
-func Xor[T, U any](a T, b U) bool
-```
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/gObZrW7ZbG8)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/condition"
-)
-
-func main() {
-    fmt.Println(condition.Xor(0, 0)) // false
-    fmt.Println(condition.Xor(0, 1)) // true
-    fmt.Println(condition.Xor(1, 0)) // true
-    fmt.Println(condition.Xor(1, 1)) // false
-}
-```
-
-### <span id="Nor">Nor</span>
-<p>异或的取反操作</p>
-
-<b>函数签名:</b>
-
-```go
-func Nor[T, U any](a T, b U) bool
-```
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/g2j08F_zZky)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/condition"
-)
-
-func main() {
-    fmt.Println(condition.Nor(0, 0)) // true
-    fmt.Println(condition.Nor(0, 1)) // false
-    fmt.Println(condition.Nor(1, 0)) // false
-    fmt.Println(condition.Nor(1, 1)) // false
-}
-```
-
-### <span id="Xnor">Xnor</span>
-<p>如果a和b都是真的或a和b均是假的，则返回true。</p>
-
-<b>函数签名:</b>
-
-```go
-func Xnor[T, U any](a T, b U) bool
-```
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OuDB9g51643)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/condition"
-)
-
-func main() {
-    fmt.Println(condition.Xnor(0, 0)) // true
-    fmt.Println(condition.Xnor(0, 1)) // false
-    fmt.Println(condition.Xnor(1, 0)) // false
-    fmt.Println(condition.Xnor(1, 1)) // true
-}
-```
-
-### <span id="Nand">Nand</span>
-<p>如果a和b都为真，返回false，否则返回true</p>
-
-<b>函数签名:</b>
-
-```go
-func Nand[T, U any](a T, b U) bool
-```
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/vSRMLxLIbq8)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/condition"
-)
-
-func main() {
-    fmt.Println(condition.Nand(0, 0)) // true
-    fmt.Println(condition.Nand(0, 1)) // true
-    fmt.Println(condition.Nand(1, 0)) // true
-    fmt.Println(condition.Nand(1, 1)) // false
-}
-```
-
-### <span id="Ternary">Ternary</span>
-<p>三元运算符。</p>
-
-<b>函数签名:</b>
-
-```go
-func Ternary[T, U any](isTrue T, ifValue U, elseValue U) U
-```
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ElllPZY0guT)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/condition"
-)
-
-func main() {
-    conditionTrue := 2 > 1
-    result1 := condition.Ternary(conditionTrue, 0, 1)
-
-    conditionFalse := 2 > 3
-    result2 := condition.Ternary(conditionFalse, 0, 1)
-    
-    fmt.Println(result1)
-    fmt.Println(result2)
-
-    // Output:
-    // 0
-    // 1
-}
-```
-
-### <span id="TernaryOperator">TernaryOperator</span>
-<p>三元运算符</p>
-
-> ⚠️ 本函数已弃用，使用`Ternary`代替。
-
-<b>函数签名:</b>
-
-```go
-func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U
-```
-<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ElllPZY0guT)</span></b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/condition"
-)
-
-func main() {
-    conditionTrue := 2 > 1
-    result1 := condition.TernaryOperator(conditionTrue, 0, 1)
-
-    conditionFalse := 2 > 3
-    result2 := condition.TernaryOperator(conditionFalse, 0, 1)
-    
-    fmt.Println(result1)
-    fmt.Println(result2)
-
-    // Output:
-    // 0
-    // 1
-}
-```
-
-
-
-
-
-

docs/api/packages/datastructure/copyonwritelist.md

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

docs/api/packages/datastructure/hashmap.md

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

docs/api/packages/datastructure/heap.md

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