release v1.2.7

.github/workflows/codecov.yml

@@ -17,7 +17,7 @@ jobs:
           fetch-depth: 2
       - uses: actions/setup-go@v2
         with:
-          go-version: "1.18"
+          go-version: "1.16"
       - name: Run coverage
         run: go test -v ./... -coverprofile=coverage.txt -covermode=atomic
       - name: Upload coverage to Codecov

.gitignore

@@ -6,6 +6,4 @@ fileutil/*.txt
 fileutil/*.zip
 fileutil/*.link
 fileutil/unzip/*
-slice/testdata/*
-cryptor/*.pem
-test
+cryptor/*.pem

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.moveToHead(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.moveToHead(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
-	}
-
-	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]) moveToHead(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,33 +0,0 @@
-package algorithm
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestLRUCache(t *testing.T) {
-	asssert := internal.NewAssert(t, "TestLRUCache")
-
-	cache := NewLRUCache[int, int](3)
-
-	cache.Put(1, 1)
-	cache.Put(2, 2)
-	cache.Put(3, 3)
-
-	asssert.Equal(3, cache.Len())
-
-	v, ok := cache.Get(1)
-	asssert.Equal(true, ok)
-	asssert.Equal(1, v)
-
-	v, ok = cache.Get(2)
-	asssert.Equal(true, ok)
-	asssert.Equal(2, v)
-
-	ok = cache.Delete(2)
-	asssert.Equal(true, ok)
-
-	_, ok = cache.Get(2)
-	asssert.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/lancetconstraints"
-
-// 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 lancetconstraints.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 lancetconstraints.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,39 +0,0 @@
-package algorithm
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestLinearSearch(t *testing.T) {
-	asssert := internal.NewAssert(t, "TestLinearSearch")
-
-	numbers := []int{3, 4, 5, 3, 2, 1}
-	equalFunc := func(a, b int) bool {
-		return a == b
-	}
-
-	asssert.Equal(0, LinearSearch(numbers, 3, equalFunc))
-	asssert.Equal(-1, LinearSearch(numbers, 6, equalFunc))
-}
-
-func TestBinarySearch(t *testing.T) {
-	asssert := internal.NewAssert(t, "TestBinarySearch")
-
-	sortedNumbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
-	comparator := &intComparator{}
-
-	asssert.Equal(4, BinarySearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator))
-	asssert.Equal(-1, BinarySearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator))
-}
-
-func TestBinaryIterativeSearch(t *testing.T) {
-	asssert := internal.NewAssert(t, "TestBinaryIterativeSearch")
-
-	sortedNumbers := []int{1, 2, 3, 4, 5, 6, 7, 8}
-	comparator := &intComparator{}
-
-	asssert.Equal(4, BinaryIterativeSearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator))
-	asssert.Equal(-1, BinaryIterativeSearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator))
-}

algorithm/sort.go

@@ -1,199 +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/lancetconstraints"
-
-// BubbleSort applys the bubble sort algorithm to sort the collection, will change the original collection data.
-// Play: https://go.dev/play/p/GNdv7Jg2Taj
-func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator) {
-	for i := 0; i < len(slice); i++ {
-		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)
-			}
-		}
-	}
-}
-
-// InsertionSort applys the insertion sort algorithm to sort the collection, will change the original collection data.
-// Play: https://go.dev/play/p/G5LJiWgJJW6
-func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator) {
-	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 lancetconstraints.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 lancetconstraints.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 lancetconstraints.Comparator) {
-	quickSort(slice, 0, len(slice)-1, comparator)
-}
-
-func quickSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.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 lancetconstraints.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 lancetconstraints.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 lancetconstraints.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 lancetconstraints.Comparator) {
-	mergeSort(slice, 0, len(slice)-1, comparator)
-}
-
-func mergeSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.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 lancetconstraints.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 lancetconstraints.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,208 +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/lancetconstraints/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) {
-	asssert := 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)
-
-	asssert.Equal(expected, actual)
-}
-
-func TestBubbleSortForIntSlice(t *testing.T) {
-	asssert := internal.NewAssert(t, "TestBubbleSortForIntSlice")
-
-	numbers := []int{2, 1, 5, 3, 6, 4}
-	comparator := &intComparator{}
-	BubbleSort(numbers, comparator)
-
-	asssert.Equal([]int{1, 2, 3, 4, 5, 6}, numbers)
-}
-
-func TestInsertionSort(t *testing.T) {
-	asssert := 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)
-
-	asssert.Equal(expected, actual)
-}
-
-func TestSelectionSort(t *testing.T) {
-	asssert := 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)
-
-	asssert.Equal(expected, actual)
-}
-
-func TestShellSort(t *testing.T) {
-	asssert := 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)
-
-	asssert.Equal(expected, actual)
-}
-
-func TestQuickSort(t *testing.T) {
-	asssert := 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)
-
-	asssert.Equal(expected, actual)
-}
-
-func TestHeapSort(t *testing.T) {
-	asssert := 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)
-
-	asssert.Equal(expected, actual)
-}
-
-func TestMergeSort(t *testing.T) {
-	asssert := 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)
-
-	asssert.Equal(expected, actual)
-}
-
-func TestCountSort(t *testing.T) {
-	asssert := 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)
-
-	asssert.Equal(expected, actual)
-}

compare/compare.go

@@ -1,64 +0,0 @@
-// 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.
-// reference: https://github.com/stretchr/testify
-package compare
-
-import (
-	"reflect"
-	"time"
-
-	"github.com/duke-git/lancet/v2/convertor"
-)
-
-// operator type
-const (
-	equal          = "eq"
-	lessThan       = "lt"
-	greaterThan    = "gt"
-	lessOrEqual    = "le"
-	greaterOrEqual = "ge"
-)
-
-var (
-	timeType  = reflect.TypeOf(time.Time{})
-	bytesType = reflect.TypeOf([]byte{})
-)
-
-// 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 {
-	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 {
-	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 {
-	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 {
-	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 {
-	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 {
-	return compareValue(greaterOrEqual, left, right)
-}

compare/compare_example_test.go

@@ -1,170 +0,0 @@
-package compare
-
-import (
-	"fmt"
-	"time"
-)
-
-func ExampleEqual() {
-	result1 := Equal(1, 1)
-	result2 := Equal("1", "1")
-	result3 := Equal([]int{1, 2, 3}, []int{1, 2, 3})
-	result4 := Equal(map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "b"})
-
-	result5 := Equal(1, "1")
-	result6 := Equal(1, int64(1))
-	result7 := Equal([]int{1, 2}, []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:
-	// true
-	// true
-	// true
-	// true
-	// false
-	// false
-	// false
-}
-
-func ExampleEqualValue() {
-	result1 := EqualValue(1, 1)
-	result2 := EqualValue(int(1), int64(1))
-	result3 := EqualValue(1, "1")
-	result4 := EqualValue(1, "2")
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
-
-	// Output:
-	// true
-	// true
-	// true
-	// false
-}
-
-func ExampleLessThan() {
-	result1 := LessThan(1, 2)
-	result2 := LessThan(1.1, 2.2)
-	result3 := LessThan("a", "b")
-
-	time1 := time.Now()
-	time2 := time1.Add(time.Second)
-	result4 := LessThan(time1, time2)
-
-	result5 := LessThan(2, 1)
-	result6 := LessThan(1, int64(2))
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
-	fmt.Println(result5)
-	fmt.Println(result6)
-
-	// Output:
-	// true
-	// true
-	// true
-	// true
-	// false
-	// false
-}
-
-func ExampleGreaterThan() {
-	result1 := GreaterThan(2, 1)
-	result2 := GreaterThan(2.2, 1.1)
-	result3 := GreaterThan("b", "a")
-
-	time1 := time.Now()
-	time2 := time1.Add(time.Second)
-	result4 := GreaterThan(time2, time1)
-
-	result5 := GreaterThan(1, 2)
-	result6 := GreaterThan(int64(2), 1)
-	result7 := GreaterThan("b", "c")
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
-	fmt.Println(result5)
-	fmt.Println(result6)
-	fmt.Println(result7)
-
-	// Output:
-	// true
-	// true
-	// true
-	// true
-	// false
-	// false
-	// false
-}
-
-func ExampleLessOrEqual() {
-	result1 := LessOrEqual(1, 1)
-	result2 := LessOrEqual(1.1, 2.2)
-	result3 := LessOrEqual("a", "b")
-
-	time1 := time.Now()
-	time2 := time1.Add(time.Second)
-	result4 := LessOrEqual(time1, time2)
-
-	result5 := LessOrEqual(2, 1)
-	result6 := LessOrEqual(1, int64(2))
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
-	fmt.Println(result5)
-	fmt.Println(result6)
-
-	// Output:
-	// true
-	// true
-	// true
-	// true
-	// false
-	// false
-}
-
-func ExampleGreaterOrEqual() {
-	result1 := GreaterOrEqual(1, 1)
-	result2 := GreaterOrEqual(2.2, 1.1)
-	result3 := GreaterOrEqual("b", "b")
-
-	time1 := time.Now()
-	time2 := time1.Add(time.Second)
-	result4 := GreaterOrEqual(time2, time1)
-
-	result5 := GreaterOrEqual(1, 2)
-	result6 := GreaterOrEqual(int64(2), 1)
-	result7 := GreaterOrEqual("b", "c")
-
-	fmt.Println(result1)
-	fmt.Println(result2)
-	fmt.Println(result3)
-	fmt.Println(result4)
-	fmt.Println(result5)
-	fmt.Println(result6)
-	fmt.Println(result7)
-
-	// Output:
-	// true
-	// true
-	// true
-	// true
-	// false
-	// false
-	// false
-}

compare/compare_internal.go

@@ -1,323 +0,0 @@
-package compare
-
-import (
-	"bytes"
-	"encoding/json"
-	"reflect"
-	"time"
-
-	"github.com/duke-git/lancet/v2/convertor"
-)
-
-func compareValue(operator string, left, right any) bool {
-	leftType, rightType := reflect.TypeOf(left), reflect.TypeOf(right)
-
-	if leftType.Kind() != rightType.Kind() {
-		return false
-	}
-
-	switch leftType.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
-		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
-		reflect.Float32, reflect.Float64, reflect.Bool, reflect.String:
-		return compareBasicValue(operator, left, right)
-
-	case reflect.Struct, reflect.Slice, reflect.Map:
-		return compareRefValue(operator, left, right, leftType.Kind())
-	}
-
-	return false
-}
-
-func compareRefValue(operator string, leftObj, rightObj any, kind reflect.Kind) bool {
-	leftVal, rightVal := reflect.ValueOf(leftObj), reflect.ValueOf(rightObj)
-
-	switch kind {
-	case reflect.Struct:
-
-		// compare time
-		if leftVal.CanConvert(timeType) {
-			timeObj1, ok := leftObj.(time.Time)
-			if !ok {
-				timeObj1 = leftVal.Convert(timeType).Interface().(time.Time)
-			}
-
-			timeObj2, ok := rightObj.(time.Time)
-			if !ok {
-				timeObj2 = rightVal.Convert(timeType).Interface().(time.Time)
-			}
-
-			return compareBasicValue(operator, timeObj1.UnixNano(), timeObj2.UnixNano())
-		}
-
-		// for other struct type, only process equal operator
-		switch operator {
-		case equal:
-			return objectsAreEqualValues(leftObj, rightObj)
-		}
-
-	case reflect.Slice:
-		// compare []byte
-		if leftVal.CanConvert(bytesType) {
-			bytesObj1, ok := leftObj.([]byte)
-			if !ok {
-				bytesObj1 = leftVal.Convert(bytesType).Interface().([]byte)
-			}
-			bytesObj2, ok := rightObj.([]byte)
-			if !ok {
-				bytesObj2 = rightVal.Convert(bytesType).Interface().([]byte)
-			}
-
-			switch operator {
-			case equal:
-				if bytes.Compare(bytesObj1, bytesObj2) == 0 {
-					return true
-				}
-			case lessThan:
-				if bytes.Compare(bytesObj1, bytesObj2) == -1 {
-					return true
-				}
-			case greaterThan:
-				if bytes.Compare(bytesObj1, bytesObj2) == 1 {
-					return true
-				}
-			case lessOrEqual:
-				if bytes.Compare(bytesObj1, bytesObj2) <= 0 {
-					return true
-				}
-			case greaterOrEqual:
-				if bytes.Compare(bytesObj1, bytesObj2) >= 0 {
-					return true
-				}
-			}
-
-		}
-
-		// for other type slice, only process equal operator
-		switch operator {
-		case equal:
-			return reflect.DeepEqual(leftObj, rightObj)
-		}
-
-	case reflect.Map:
-		// only process equal operator
-		switch operator {
-		case equal:
-			return reflect.DeepEqual(leftObj, rightObj)
-		}
-	}
-
-	return false
-}
-
-func objectsAreEqualValues(expected, actual interface{}) bool {
-	if objectsAreEqual(expected, actual) {
-		return true
-	}
-
-	actualType := reflect.TypeOf(actual)
-	if actualType == nil {
-		return false
-	}
-	expectedValue := reflect.ValueOf(expected)
-	if expectedValue.IsValid() && expectedValue.Type().ConvertibleTo(actualType) {
-		// Attempt comparison after type conversion
-		return reflect.DeepEqual(expectedValue.Convert(actualType).Interface(), actual)
-	}
-
-	return false
-}
-
-func objectsAreEqual(expected, actual interface{}) bool {
-	if expected == nil || actual == nil {
-		return expected == actual
-	}
-
-	exp, ok := expected.([]byte)
-	if !ok {
-		return reflect.DeepEqual(expected, actual)
-	}
-
-	act, ok := actual.([]byte)
-	if !ok {
-		return false
-	}
-	if exp == nil || act == nil {
-		return exp == nil && act == nil
-	}
-	return bytes.Equal(exp, act)
-}
-
-// compareBasic compare basic value: integer, float, string, bool
-func compareBasicValue(operator string, leftValue, rightValue any) bool {
-	if leftValue == nil && rightValue == nil && operator == equal {
-		return true
-	}
-
-	switch leftVal := leftValue.(type) {
-	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
-					}
-				}
-			}
-
-		}
-
-	case float32, float64, int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
-		left, err := convertor.ToFloat(leftValue)
-		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
-			}
-
-			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:
-			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:
-			switch operator {
-			case equal:
-				if left == right {
-					return true
-				}
-			}
-		}
-
-	}
-
-	return false
-}

compare/compare_test.go

@@ -1,134 +0,0 @@
-package compare
-
-import (
-	"testing"
-	"time"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestEqual(t *testing.T) {
-	assert := internal.NewAssert(t, "TestEqual")
-
-	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
-	}{
-		A: "a",
-		B: "b",
-	}
-
-	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) {
-	assert := internal.NewAssert(t, "TestEqualValue")
-
-	assert.Equal(true, EqualValue(1, 1))
-	assert.Equal(true, EqualValue(int(1), int64(1)))
-	assert.Equal(true, EqualValue(1, "1"))
-
-	assert.Equal(false, EqualValue(1, "2"))
-}
-
-func TestLessThan(t *testing.T) {
-	assert := internal.NewAssert(t, "TestLessThan")
-
-	assert.Equal(true, LessThan(1, 2))
-	assert.Equal(true, LessThan(1.1, 2.2))
-	assert.Equal(true, LessThan("a", "b"))
-
-	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) {
-	assert := internal.NewAssert(t, "TestGreaterThan")
-
-	assert.Equal(true, GreaterThan(2, 1))
-	assert.Equal(true, GreaterThan(2.2, 1.1))
-	assert.Equal(true, GreaterThan("b", "a"))
-
-	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) {
-	assert := internal.NewAssert(t, "TestLessOrEqual")
-
-	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"))
-
-	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) {
-	assert := internal.NewAssert(t, "TestGreaterThan")
-
-	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"))
-
-	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,247 +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)
-
-		for {
-			var stream <-chan T
-			select {
-			case maybeStream, ok := <-chanStream:
-				if !ok {
-					return
-				}
-				stream = maybeStream
-			case <-ctx.Done():
-				return
-			}
-
-			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,196 +0,0 @@
-package concurrency
-
-import (
-	"context"
-	"fmt"
-	"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()
-
-	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
-				close(stream)
-				out <- stream
-			}
-		}()
-		return out
-	}
-
-	for v := range c.Bridge(ctx, genVals()) {
-		fmt.Println(v)
-	}
-	// Output:
-	// 1
-	// 2
-	// 3
-	// 4
-	// 5
-}

concurrency/channel_test.go

@@ -1,187 +0,0 @@
-package concurrency
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestGenerate(t *testing.T) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	assert := internal.NewAssert(t, "TestBridge")
-
-	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
-				close(stream)
-				chanStream <- stream
-			}
-		}()
-		return chanStream
-	}
-
-	index := 0
-	for val := range c.Bridge(ctx, genVals()) {
-		assert.Equal(index, val)
-		index++
-	}
-}

condition/condition.go

@@ -1,85 +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 {
-	valA := Bool(a)
-	valB := Bool(b)
-	return (valA || valB) && valA != valB
-}
-
-// 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 {
-	valA := Bool(a)
-	valB := Bool(b)
-	return (valA && valB) || (!valA && !valB)
-}
-
-// 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 TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U {
-	if Bool(isTrue) {
-		return ifValue
-	} else {
-		return 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 ExampleTernaryOperator() {
-	conditionTrue := 2 > 1
-	result1 := TernaryOperator(conditionTrue, 0, 1)
-	fmt.Println(result1)
-
-	conditionFalse := 2 > 3
-	result2 := TernaryOperator(conditionFalse, 0, 1)
-	fmt.Println(result2)
-
-	// Output:
-	// 0
-	// 1
-}

condition/condition_test.go

@@ -1,119 +0,0 @@
-package condition
-
-import (
-	"errors"
-	"testing"
-	"time"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-type TestStruct struct{}
-
-func TestBool(t *testing.T) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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 TestTernaryOperator(t *testing.T) {
-	assert := internal.NewAssert(t, "TernaryOperator")
-	trueValue := "1"
-	falseValue := "0"
-
-	assert.Equal(trueValue, TernaryOperator(true, trueValue, falseValue))
-}

convertor/convertor.go

@@ -7,30 +7,22 @@ package convertor
 import (
 	"bytes"
 	"encoding/binary"
-	"encoding/gob"
 	"encoding/json"
-	"errors"
 	"fmt"
-	"io"
 	"math"
 	"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) {
@@ -70,8 +62,7 @@ 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)
 	if len(s) == 0 {
@@ -83,179 +74,133 @@ 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 {
+	res := ""
 	if value == nil {
-		return ""
+		return res
 	}
 
-	switch val := value.(type) {
-	case float32:
-		return strconv.FormatFloat(float64(val), 'f', -1, 32)
-	case float64:
-		return strconv.FormatFloat(val, 'f', -1, 64)
-	case int:
-		return strconv.FormatInt(int64(val), 10)
-	case int8:
-		return strconv.FormatInt(int64(val), 10)
-	case int16:
-		return strconv.FormatInt(int64(val), 10)
-	case int32:
-		return strconv.FormatInt(int64(val), 10)
-	case int64:
-		return strconv.FormatInt(val, 10)
-	case uint:
-		return strconv.FormatUint(uint64(val), 10)
-	case uint8:
-		return strconv.FormatUint(uint64(val), 10)
-	case uint16:
-		return strconv.FormatUint(uint64(val), 10)
-	case uint32:
-		return strconv.FormatUint(uint64(val), 10)
-	case uint64:
-		return strconv.FormatUint(val, 10)
-	case string:
-		return val
-	case []byte:
-		return string(val)
-	default:
-		b, err := json.Marshal(val)
-		if err != nil {
-			return ""
-		}
-		return string(b)
+	v := reflect.ValueOf(value)
 
-		// todo: maybe we should't supprt other type conversion
-		// v := reflect.ValueOf(value)
-		// log.Panicf("Unsupported data type: %s ", v.String())
-		// return ""
+	switch value.(type) {
+	case float32, float64:
+		res = strconv.FormatFloat(v.Float(), 'f', -1, 64)
+		return res
+	case int, int8, int16, int32, int64:
+		res = strconv.FormatInt(v.Int(), 10)
+		return res
+	case uint, uint8, uint16, uint32, uint64:
+		res = strconv.FormatUint(v.Uint(), 10)
+		return res
+	case string:
+		res = v.String()
+		return res
+	case []byte:
+		res = string(v.Bytes())
+		return res
+	default:
+		newValue, _ := json.Marshal(value)
+		res = string(newValue)
+		return res
 	}
 }
 
-// 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
-}
-
-// 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)
@@ -266,8 +211,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)
@@ -285,112 +229,3 @@ 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) {
-	buffer := bytes.NewBuffer(nil)
-	encoder := gob.NewEncoder(buffer)
-	err := encoder.Encode(data)
-	if err != nil {
-		return nil, err
-	}
-	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 {
-	buffer := bytes.NewBuffer(data)
-	decoder := gob.NewDecoder(buffer)
-	return decoder.Decode(target)
-}
-
-// 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 {
-	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 result.Interface().(T)
-}
-
-// 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 {
-	dstType, srcType := reflect.TypeOf(dst), reflect.TypeOf(src)
-
-	if dstType.Kind() != reflect.Ptr || dstType.Elem().Kind() != reflect.Struct {
-		return errors.New("CopyProperties: parameter dst should be struct pointer")
-	}
-
-	if srcType.Kind() == reflect.Ptr {
-		srcType = srcType.Elem()
-	}
-	if srcType.Kind() != reflect.Struct {
-		return errors.New("CopyProperties: parameter src should be a struct or struct pointer")
-	}
-
-	bytes, err := json.Marshal(src)
-	if err != nil {
-		return fmt.Errorf("CopyProperties: unable to marshal src: %s", err)
-	}
-	err = json.Unmarshal(bytes, dst)
-	if err != nil {
-		return fmt.Errorf("CopyProperties: unable to unmarshal into dst: %s", err)
-	}
-
-	return nil
-}
-
-// 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
-	}
-	switch v.Kind() {
-	case reflect.Bool:
-		return v.Bool(), true
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return v.Int(), true
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		return v.Uint(), true
-	case reflect.Float32, reflect.Float64:
-		return v.Float(), true
-	case reflect.Complex64, reflect.Complex128:
-		return v.Complex(), true
-	case reflect.String:
-		return v.String(), true
-	case reflect.Ptr:
-		return ToInterface(v.Elem())
-	case reflect.Interface:
-		return ToInterface(v.Elem())
-	default:
-		return nil, false
-	}
-}
-
-// Utf8ToGbk convert utf8 encoding data to GBK encoding data.
-// Play: todo
-func Utf8ToGbk(bs []byte) ([]byte, error) {
-	r := transform.NewReader(bytes.NewReader(bs), simplifiedchinese.GBK.NewEncoder())
-	b, err := io.ReadAll(r)
-	return b, err
-}
-
-// GbkToUtf8 convert GBK encoding data to utf8 encoding data.
-// Play: todo
-func GbkToUtf8(bs []byte) ([]byte, error) {
-	r := transform.NewReader(bytes.NewReader(bs), simplifiedchinese.GBK.NewDecoder())
-	b, err := io.ReadAll(r)
-	return b, err
-}

convertor/convertor_example_test.go

@@ -1,393 +0,0 @@
-package convertor
-
-import (
-	"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 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
-}

convertor/convertor_internal.go

@@ -1,216 +0,0 @@
-// Copyright 2023 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package convertor implements some functions to convert data.
-package convertor
-
-import "reflect"
-
-type cloner struct {
-	ptrs map[reflect.Type]map[uintptr]reflect.Value
-}
-
-// clone return a duplicate of passed item.
-func (c *cloner) clone(v reflect.Value) reflect.Value {
-	switch v.Kind() {
-	case reflect.Invalid:
-		return reflect.ValueOf(nil)
-
-	// bool
-	case reflect.Bool:
-		return reflect.ValueOf(v.Bool())
-
-	//int
-	case reflect.Int:
-		return reflect.ValueOf(int(v.Int()))
-	case reflect.Int8:
-		return reflect.ValueOf(int8(v.Int()))
-	case reflect.Int16:
-		return reflect.ValueOf(int16(v.Int()))
-	case reflect.Int32:
-		return reflect.ValueOf(int32(v.Int()))
-	case reflect.Int64:
-		return reflect.ValueOf(v.Int())
-
-	// uint
-	case reflect.Uint:
-		return reflect.ValueOf(uint(v.Uint()))
-	case reflect.Uint8:
-		return reflect.ValueOf(uint8(v.Uint()))
-	case reflect.Uint16:
-		return reflect.ValueOf(uint16(v.Uint()))
-	case reflect.Uint32:
-		return reflect.ValueOf(uint32(v.Uint()))
-	case reflect.Uint64:
-		return reflect.ValueOf(v.Uint())
-
-	// float
-	case reflect.Float32:
-		return reflect.ValueOf(float32(v.Float()))
-	case reflect.Float64:
-		return reflect.ValueOf(v.Float())
-
-	// complex
-	case reflect.Complex64:
-		return reflect.ValueOf(complex64(v.Complex()))
-	case reflect.Complex128:
-		return reflect.ValueOf(v.Complex())
-
-	// string
-	case reflect.String:
-		return reflect.ValueOf(v.String())
-
-	// array
-	case reflect.Array, reflect.Slice:
-		return c.cloneArray(v)
-
-	// map
-	case reflect.Map:
-		return c.cloneMap(v)
-
-	// Ptr
-	case reflect.Ptr:
-		return c.clonePtr(v)
-
-	// struct
-	case reflect.Struct:
-		return c.cloneStruct(v)
-
-	// func
-	case reflect.Func:
-		return v
-
-	// interface
-	case reflect.Interface:
-		return c.clone(v.Elem())
-
-	}
-
-	return reflect.Zero(v.Type())
-}
-
-func (c *cloner) cloneArray(v reflect.Value) reflect.Value {
-	if v.IsNil() {
-		return reflect.Zero(v.Type())
-	}
-
-	arr := reflect.MakeSlice(v.Type(), v.Len(), v.Len())
-
-	for i := 0; i < v.Len(); i++ {
-		val := c.clone(v.Index(i))
-
-		if val.IsValid() {
-			continue
-		}
-
-		item := arr.Index(i)
-		if !item.CanSet() {
-			continue
-		}
-
-		item.Set(val.Convert(item.Type()))
-	}
-
-	return arr
-}
-
-func (c *cloner) cloneMap(v reflect.Value) reflect.Value {
-	if v.IsNil() {
-		return reflect.Zero(v.Type())
-	}
-
-	clonedMap := reflect.MakeMap(v.Type())
-
-	for _, key := range v.MapKeys() {
-		value := v.MapIndex(key)
-		clonedKey := c.clone(key)
-		clonedValue := c.clone(value)
-
-		if !isNillable(clonedKey) || !clonedKey.IsNil() {
-			clonedKey = clonedKey.Convert(key.Type())
-		}
-
-		if (!isNillable(clonedValue) || !clonedValue.IsNil()) && clonedValue.IsValid() {
-			clonedValue = clonedValue.Convert(value.Type())
-		}
-
-		if !clonedValue.IsValid() {
-			clonedValue = reflect.Zero(clonedMap.Type().Elem())
-		}
-
-		clonedMap.SetMapIndex(clonedKey, clonedValue)
-	}
-
-	return clonedMap
-}
-
-func isNillable(v reflect.Value) bool {
-	switch v.Kind() {
-	case reflect.Chan, reflect.Interface, reflect.Ptr, reflect.Func:
-		return true
-	}
-	return false
-}
-
-func (c *cloner) clonePtr(v reflect.Value) reflect.Value {
-	if v.IsNil() {
-		return reflect.Zero(v.Type())
-	}
-
-	var newVal reflect.Value
-
-	if v.Elem().CanAddr() {
-		ptrs, exists := c.ptrs[v.Type()]
-		if exists {
-			if newVal, exists := ptrs[v.Elem().UnsafeAddr()]; exists {
-				return newVal
-			}
-		}
-	}
-
-	newVal = c.clone(v.Elem())
-
-	if v.Elem().CanAddr() {
-		ptrs, exists := c.ptrs[v.Type()]
-		if exists {
-			if newVal, exists := ptrs[v.Elem().UnsafeAddr()]; exists {
-				return newVal
-			}
-		}
-	}
-
-	clonedPtr := reflect.New(newVal.Type())
-	clonedPtr.Elem().Set(newVal)
-
-	return clonedPtr
-}
-
-func (c *cloner) cloneStruct(v reflect.Value) reflect.Value {
-	clonedStructPtr := reflect.New(v.Type())
-	clonedStruct := clonedStructPtr.Elem()
-
-	if v.CanAddr() {
-		ptrs := c.ptrs[clonedStructPtr.Type()]
-		if ptrs == nil {
-			ptrs = make(map[uintptr]reflect.Value)
-			c.ptrs[clonedStructPtr.Type()] = ptrs
-		}
-		ptrs[v.UnsafeAddr()] = clonedStructPtr
-	}
-
-	for i := 0; i < v.NumField(); i++ {
-		newStructValue := clonedStruct.Field(i)
-		if !newStructValue.CanSet() {
-			continue
-		}
-
-		clonedVal := c.clone(v.Field(i))
-		if !clonedVal.IsValid() {
-			continue
-		}
-
-		newStructValue.Set(clonedVal.Convert(newStructValue.Type()))
-	}
-
-	return clonedStruct
-}

convertor/convertor_test.go

@@ -2,14 +2,9 @@ package convertor
 
 import (
 	"fmt"
-	"reflect"
-	"strconv"
 	"testing"
-	"unicode/utf8"
 
-	"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"
 )
 
 func TestToChar(t *testing.T) {
@@ -26,18 +21,6 @@ func TestToChar(t *testing.T) {
 	}
 }
 
-func TestToChannel(t *testing.T) {
-	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) {
 	assert := internal.NewAssert(t, "TestToBool")
 
@@ -53,7 +36,7 @@ func TestToBool(t *testing.T) {
 func TestToBytes(t *testing.T) {
 	assert := internal.NewAssert(t, "TestToBytes")
 
-	cases := []any{
+	cases := []interface{}{
 		0,
 		false,
 		"1",
@@ -79,7 +62,7 @@ func TestToBytes(t *testing.T) {
 func TestToInt(t *testing.T) {
 	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"}
@@ -95,7 +78,7 @@ func TestToInt(t *testing.T) {
 func TestToFloat(t *testing.T) {
 	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),
@@ -123,7 +106,7 @@ func TestToString(t *testing.T) {
 	}
 	aStruct := TestStruct{Name: "TestStruct"}
 
-	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),
@@ -135,10 +118,9 @@ func TestToString(t *testing.T) {
 		"", "",
 		"0", "1", "-1",
 		"123", "123", "123", "123", "123", "123", "123",
-		"12.3", "12.3",
+		"12.3", "12.300000190734863",
 		"true", "false",
-		"[1,2,3]", "{\"a\":1,\"b\":2,\"c\":3}", "{\"Name\":\"TestStruct\"}", "hello",
-	}
+		"[1,2,3]", "{\"a\":1,\"b\":2,\"c\":3}", "{\"Name\":\"TestStruct\"}", "hello"}
 
 	for i := 0; i < len(cases); i++ {
 		actual := ToString(cases[i])
@@ -160,72 +142,20 @@ func TestToJson(t *testing.T) {
 	assert.Equal("{\"Name\":\"TestStruct\"}", structJsonStr)
 }
 
-func TestToMap(t *testing.T) {
-	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) {
 	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) {
-	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) {
@@ -248,175 +178,3 @@ func TestColorRGBToHex(t *testing.T) {
 	assert := internal.NewAssert(t, "TestColorRGBToHex")
 	assert.Equal(expected, colorHex)
 }
-
-func TestToPointer(t *testing.T) {
-	assert := internal.NewAssert(t, "TestToPointer")
-	result := ToPointer(123)
-
-	assert.Equal(*result, 123)
-}
-
-func TestEncodeByte(t *testing.T) {
-	assert := internal.NewAssert(t, "TestEncodeByte")
-
-	byteData, _ := EncodeByte("abc")
-	expected := []byte{6, 12, 0, 3, 97, 98, 99}
-
-	assert.Equal(expected, byteData)
-}
-
-func TestDecodeByte(t *testing.T) {
-	assert := internal.NewAssert(t, "TestDecodeByte")
-
-	var obj string
-	byteData := []byte{6, 12, 0, 3, 97, 98, 99}
-	err := DecodeByte(byteData, &obj)
-	assert.IsNil(err)
-	assert.Equal("abc", obj)
-}
-
-func TestDeepClone(t *testing.T) {
-	// assert := internal.NewAssert(t, "TestDeepClone")
-
-	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 i, item := range cases {
-		cloned := DeepClone(item)
-
-		if &cloned == &item {
-			t.Fatalf("[TestDeepClone case #%d failed]: equal pointer", i)
-		}
-
-		if !reflect.DeepEqual(item, cloned) {
-			t.Fatalf("[TestDeepClone case #%d failed] unequal objects", i)
-		}
-	}
-}
-
-func TestCopyProperties(t *testing.T) {
-	assert := internal.NewAssert(t, "TestCopyProperties")
-
-	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{}
-
-	err := CopyProperties(&indicatorVO, indicator)
-
-	assert.IsNil(err)
-	assert.Equal("001", indicatorVO.Id)
-	assert.Equal("127.0.0.1", indicatorVO.Ip)
-	assert.Equal(3, len(indicatorVO.Disk))
-}
-
-func TestToInterface(t *testing.T) {
-	assert := internal.NewAssert(t, "TestToInterface")
-
-	cases := []reflect.Value{
-		reflect.ValueOf("abc"),
-		reflect.ValueOf(int(0)), reflect.ValueOf(int8(1)), reflect.ValueOf(int16(-1)), reflect.ValueOf(int32(123)), reflect.ValueOf(int64(123)),
-		reflect.ValueOf(uint(123)), reflect.ValueOf(uint8(123)), reflect.ValueOf(uint16(123)), reflect.ValueOf(uint32(123)), reflect.ValueOf(uint64(123)),
-		reflect.ValueOf(float64(12.3)), reflect.ValueOf(float32(12.3)),
-		reflect.ValueOf(true), reflect.ValueOf(false),
-	}
-
-	expected := []interface{}{
-		"abc",
-		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,
-	}
-
-	for i := 0; i < len(cases); i++ {
-		actual, _ := ToInterface(cases[i])
-		assert.Equal(expected[i], actual)
-	}
-
-	nilVal, ok := ToInterface(reflect.ValueOf(nil))
-	assert.EqualValues(nil, nilVal)
-	assert.Equal(false, ok)
-}
-
-func TestUtf8ToGbk(t *testing.T) {
-	assert := internal.NewAssert(t, "TestUtf8ToGbk")
-
-	utf8Data := []byte("hello")
-	gbkData, err := Utf8ToGbk(utf8Data)
-
-	assert.Equal(true, utf8.Valid(utf8Data))
-	assert.Equal(true, validator.IsGBK(gbkData))
-	assert.IsNil(err)
-}
-
-func TestGbkToUtf8(t *testing.T) {
-	assert := internal.NewAssert(t, "TestGbkToUtf8")
-
-	gbkData, err := Utf8ToGbk([]byte("hello"))
-	utf8Data, err := GbkToUtf8(gbkData)
-
-	assert.IsNil(err)
-	assert.Equal(true, utf8.Valid(utf8Data))
-	assert.Equal("hello", string(utf8Data))
-}

cryptor/aes.go

@@ -0,0 +1,168 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package cryptor implements some util functions to encrypt and decrypt.
+// Note:
+// 1. for aes crypt function, the `key` param length should be 16, 24 or 32. if not, will panic.
+package cryptor
+
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"io"
+)
+
+// AesEcbEncrypt encrypt data with key use AES ECB algorithm
+// len(key) should be 16, 24 or 32
+func AesEcbEncrypt(data, key []byte) []byte {
+	cipher, _ := aes.NewCipher(generateAesKey(key))
+	length := (len(data) + aes.BlockSize) / aes.BlockSize
+	plain := make([]byte, length*aes.BlockSize)
+	copy(plain, data)
+	pad := byte(len(plain) - len(data))
+	for i := len(data); i < len(plain); i++ {
+		plain[i] = pad
+	}
+	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
+func AesEcbDecrypt(encrypted, key []byte) []byte {
+	cipher, _ := aes.NewCipher(generateAesKey(key))
+	decrypted := make([]byte, len(encrypted))
+	//
+	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])
+	}
+
+	trim := 0
+	if len(decrypted) > 0 {
+		trim = len(decrypted) - int(decrypted[len(decrypted)-1])
+	}
+
+	return decrypted[:trim]
+}
+
+// AesCbcEncrypt encrypt data with key use AES CBC algorithm
+// len(key) should be 16, 24 or 32
+func AesCbcEncrypt(data, key []byte) []byte {
+	// len(key) should be 16, 24 or 32
+	block, _ := aes.NewCipher(key)
+	blockSize := block.BlockSize()
+	data = pkcs7Padding(data, blockSize)
+	blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])
+
+	encrypted := make([]byte, len(data))
+	blockMode.CryptBlocks(encrypted, data)
+	return encrypted
+}
+
+// AesCbcDecrypt decrypt data with key use AES CBC algorithm
+// len(key) should be 16, 24 or 32
+func AesCbcDecrypt(encrypted, key []byte) []byte {
+	block, _ := aes.NewCipher(key)
+	blockSize := block.BlockSize()
+	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])
+
+	decrypted := make([]byte, len(encrypted))
+	blockMode.CryptBlocks(decrypted, encrypted)
+	decrypted = pkcs7UnPadding(decrypted)
+	return decrypted
+}
+
+// AesCtrCrypt encrypt data with key use AES CTR algorithm
+// len(key) should be 16, 24 or 32
+func AesCtrCrypt(data, key []byte) []byte {
+	block, _ := aes.NewCipher(key)
+
+	iv := bytes.Repeat([]byte("1"), block.BlockSize())
+	stream := cipher.NewCTR(block, iv)
+
+	dst := make([]byte, len(data))
+	stream.XORKeyStream(dst, data)
+
+	return dst
+}
+
+// AesCfbEncrypt encrypt data with key use AES CFB algorithm
+// len(key) should be 16, 24 or 32
+func AesCfbEncrypt(data, key []byte) []byte {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+
+	encrypted := make([]byte, aes.BlockSize+len(data))
+	iv := encrypted[:aes.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic(err)
+	}
+
+	stream := cipher.NewCFBEncrypter(block, iv)
+	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
+func AesCfbDecrypt(encrypted, key []byte) []byte {
+	block, _ := aes.NewCipher(key)
+	if len(encrypted) < aes.BlockSize {
+		panic("encrypted data is too short")
+	}
+	iv := encrypted[:aes.BlockSize]
+	encrypted = encrypted[aes.BlockSize:]
+
+	stream := cipher.NewCFBDecrypter(block, iv)
+	stream.XORKeyStream(encrypted, encrypted)
+	return encrypted
+}
+
+// AesOfbEncrypt encrypt data with key use AES OFB algorithm
+// len(key) should be 16, 24 or 32
+func AesOfbEncrypt(data, key []byte) []byte {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+	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(err)
+	}
+
+	stream := cipher.NewOFB(block, iv)
+	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
+func AesOfbDecrypt(data, key []byte) []byte {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+
+	iv := data[:aes.BlockSize]
+	data = data[aes.BlockSize:]
+	if len(data)%aes.BlockSize != 0 {
+		return nil
+	}
+
+	decrypted := make([]byte, len(data))
+	mode := cipher.NewOFB(block, iv)
+	mode.XORKeyStream(decrypted, data)
+
+	decrypted = pkcs7UnPadding(decrypted)
+	return decrypted
+}

cryptor/aes_test.go

@@ -0,0 +1,62 @@
+package cryptor
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/internal"
+)
+
+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, "TestAesEcbEncrypt")
+	assert.Equal(data, string(aesEcbDecrypt))
+}
+
+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, "TestAesCbcEncrypt")
+	assert.Equal(data, string(aesCbcDecrypt))
+}
+
+func TestAesCtrCrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefghijklmnop"
+
+	aesCtrCrypt := AesCtrCrypt([]byte(data), []byte(key))
+	aesCtrDeCrypt := AesCtrCrypt(aesCtrCrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestAesCtrCrypt")
+	assert.Equal(data, string(aesCtrDeCrypt))
+}
+
+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, "TestAesCfbEncrypt")
+	assert.Equal(data, string(aesCfbDecrypt))
+}
+
+func TestAesOfbEncrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefghijklmnop"
+
+	aesOfbEncrypt := AesOfbEncrypt([]byte(data), []byte(key))
+	aesOfbDecrypt := AesOfbDecrypt(aesOfbEncrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestAesOfbEncrypt")
+	assert.Equal(data, string(aesOfbDecrypt))
+}

cryptor/basic.go

@@ -19,28 +19,25 @@ 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))
 	return hex.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
@@ -72,56 +69,49 @@ func Md5File(filename string) (string, error) {
 	return checksum, nil
 }
 
-// HmacMd5 return the hmac hash of string use md5.
-// Play: https://go.dev/play/p/uef0q1fz53I
+// 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(data))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
-// HmacSha1 return the hmac hash of string use sha1.
-// Play: https://go.dev/play/p/1UI4oQ4WXKM
+// 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(data))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
-// HmacSha256 return the hmac hash of string use sha256.
-// Play: https://go.dev/play/p/HhpwXxFhhC0
+// 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(data))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
-// HmacSha512 return the hmac hash of string use sha512.
-// Play: https://go.dev/play/p/59Od6m4A0Ud
+// 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(data))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
-// Sha1 return the sha1 value (SHA-1 hash algorithm) of string.
-// Play: https://go.dev/play/p/_m_uoD1deMT
+// Sha1 return the sha1 value (SHA-1 hash algorithm) of string
 func Sha1(data string) string {
 	sha1 := sha1.New()
 	sha1.Write([]byte(data))
 	return hex.EncodeToString(sha1.Sum([]byte("")))
 }
 
-// Sha256 return the sha256 value (SHA256 hash algorithm) of string.
-// Play: https://go.dev/play/p/tU9tfBMIAr1
+// Sha256 return the sha256 value (SHA256 hash algorithm) of string
 func Sha256(data string) string {
 	sha256 := sha256.New()
 	sha256.Write([]byte(data))
 	return hex.EncodeToString(sha256.Sum([]byte("")))
 }
 
-// Sha512 return the sha512 value (SHA512 hash algorithm) of string.
-// Play: https://go.dev/play/p/3WsvLYZxsHa
+// Sha512 return the sha512 value (SHA512 hash algorithm) of string
 func Sha512(data string) string {
 	sha512 := sha512.New()
 	sha512.Write([]byte(data))

cryptor/basic_test.go

@@ -3,7 +3,7 @@ package cryptor
 import (
 	"testing"
 
-	"github.com/duke-git/lancet/v2/internal"
+	"github.com/duke-git/lancet/internal"
 )
 
 func TestBase64StdEncode(t *testing.T) {

cryptor/crypto_example_test.go

@@ -1,410 +0,0 @@
-package cryptor
-
-import "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 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 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 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.pem", "rsa_public.pem")
-	if err != nil {
-		return
-	}
-
-	fmt.Println("foo")
-
-	// Output:
-	// foo
-}
-
-func ExampleRsaEncrypt() {
-	// Create ras private and public pem file
-	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
-	if err != nil {
-		return
-	}
-
-	data := []byte("hello")
-	encrypted := RsaEncrypt(data, "rsa_public.pem")
-	decrypted := RsaDecrypt(encrypted, "rsa_private.pem")
-
-	fmt.Println(string(decrypted))
-
-	// Output:
-	// hello
-}
-
-func ExampleRsaDecrypt() {
-	// Create ras private and public pem file
-	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
-	if err != nil {
-		return
-	}
-
-	data := []byte("hello")
-	encrypted := RsaEncrypt(data, "rsa_public.pem")
-	decrypted := RsaDecrypt(encrypted, "rsa_private.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 ExampleHmacSha1() {
-	str := "hello"
-	key := "12345"
-
-	hms := HmacSha1(str, key)
-
-	fmt.Println(hms)
-
-	// Output:
-	// 5c6a9db0cccb92e36ed0323fd09b7f936de9ace0
-}
-
-func ExampleHmacSha256() {
-	str := "hello"
-	key := "12345"
-
-	hms := HmacSha256(str, key)
-
-	fmt.Println(hms)
-
-	// Output:
-	// 315bb93c4e989862ba09cb62e05d73a5f376cb36f0d786edab0c320d059fde75
-}
-
-func ExampleHmacSha512() {
-	str := "hello"
-	key := "12345"
-
-	hms := HmacSha512(str, key)
-
-	fmt.Println(hms)
-
-	// Output:
-	// dd8f1290a9dd23d354e2526d9a2e9ce8cffffdd37cb320800d1c6c13d2efc363288376a196c5458daf53f8e1aa6b45a6d856303d5c0a2064bff9785861d48cfc
-}
-
-func ExampleMd5String() {
-	str := "hello"
-
-	md5Str := Md5String(str)
-
-	fmt.Println(md5Str)
-
-	// Output:
-	// 5d41402abc4b2a76b9719d911017c592
-}
-
-func ExampleSha1() {
-	str := "hello"
-
-	result := Sha1(str)
-
-	fmt.Println(result)
-
-	// Output:
-	// aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
-}
-
-func ExampleSha256() {
-	str := "hello"
-
-	result := Sha256(str)
-
-	fmt.Println(result)
-
-	// Output:
-	// 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
-}
-
-func ExampleSha512() {
-	str := "hello"
-
-	result := Sha512(str)
-
-	fmt.Println(result)
-
-	// Output:
-	// 9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043
-}

cryptor/crypto_internal.go

@@ -2,11 +2,11 @@ package cryptor
 
 import "bytes"
 
-func generateAesKey(key []byte, size int) []byte {
-	genKey := make([]byte, size)
+func generateAesKey(key []byte) []byte {
+	genKey := make([]byte, 16)
 	copy(genKey, key)
-	for i := size; i < len(key); {
-		for j := 0; j < size && i < len(key); j, i = j+1, i+1 {
+	for i := 16; i < len(key); {
+		for j := 0; j < 16 && i < len(key); j, i = j+1, i+1 {
 			genKey[j] ^= key[i]
 		}
 	}

cryptor/des.go

@@ -0,0 +1,173 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package cryptor implements some util functions to encrypt and decrypt.
+package cryptor
+
+import (
+	"bytes"
+	"crypto/cipher"
+	"crypto/des"
+	"crypto/rand"
+	"io"
+)
+
+// DesEcbEncrypt encrypt data with key use DES ECB algorithm
+// len(key) should be 8
+func DesEcbEncrypt(data, key []byte) []byte {
+	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
+	}
+
+	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
+func DesEcbDecrypt(encrypted, key []byte) []byte {
+	cipher, _ := des.NewCipher(generateDesKey(key))
+	decrypted := make([]byte, len(encrypted))
+
+	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])
+	}
+
+	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
+func DesCbcEncrypt(data, key []byte) []byte {
+	block, _ := des.NewCipher(key)
+	blockSize := block.BlockSize()
+	data = pkcs7Padding(data, blockSize)
+	blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])
+
+	encrypted := make([]byte, len(data))
+	blockMode.CryptBlocks(encrypted, data)
+
+	return encrypted
+}
+
+// DesCbcDecrypt decrypt data with key use DES CBC algorithm
+// len(key) should be 8
+func DesCbcDecrypt(encrypted, key []byte) []byte {
+	block, _ := des.NewCipher(key)
+	blockSize := block.BlockSize()
+	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])
+
+	decrypted := make([]byte, len(encrypted))
+	blockMode.CryptBlocks(decrypted, encrypted)
+	decrypted = pkcs7UnPadding(decrypted)
+
+	return decrypted
+}
+
+// DesCtrCrypt encrypt data with key use DES CTR algorithm
+// len(key) should be 8
+func DesCtrCrypt(data, key []byte) []byte {
+	block, _ := des.NewCipher(key)
+
+	iv := bytes.Repeat([]byte("1"), block.BlockSize())
+	stream := cipher.NewCTR(block, iv)
+
+	dst := make([]byte, len(data))
+	stream.XORKeyStream(dst, data)
+
+	return dst
+}
+
+// DesCfbEncrypt encrypt data with key use DES CFB algorithm
+// len(key) should be 8
+func DesCfbEncrypt(data, key []byte) []byte {
+	block, err := des.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+
+	encrypted := make([]byte, des.BlockSize+len(data))
+	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)
+
+	return encrypted
+}
+
+// DesCfbDecrypt decrypt data with key use DES CFB algorithm
+// len(encrypted) should be great than 16, len(key) should be 8
+func DesCfbDecrypt(encrypted, key []byte) []byte {
+	block, _ := des.NewCipher(key)
+	if len(encrypted) < des.BlockSize {
+		panic("encrypted data is too short")
+	}
+	iv := encrypted[:des.BlockSize]
+	encrypted = encrypted[des.BlockSize:]
+
+	stream := cipher.NewCFBDecrypter(block, iv)
+	stream.XORKeyStream(encrypted, encrypted)
+
+	return encrypted
+}
+
+// DesOfbEncrypt encrypt data with key use DES OFB algorithm
+// len(key) should be 16, 24 or 32
+func DesOfbEncrypt(data, key []byte) []byte {
+	block, err := des.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+	data = pkcs7Padding(data, des.BlockSize)
+	encrypted := make([]byte, des.BlockSize+len(data))
+	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)
+
+	return encrypted
+}
+
+// DesOfbDecrypt decrypt data with key use DES OFB algorithm
+// len(key) should be 8
+func DesOfbDecrypt(data, key []byte) []byte {
+	block, err := des.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+
+	iv := data[:des.BlockSize]
+	data = data[des.BlockSize:]
+	if len(data)%des.BlockSize != 0 {
+		return nil
+	}
+
+	decrypted := make([]byte, len(data))
+	mode := cipher.NewOFB(block, iv)
+	mode.XORKeyStream(decrypted, data)
+
+	decrypted = pkcs7UnPadding(decrypted)
+
+	return decrypted
+}

cryptor/des_test.go

@@ -0,0 +1,62 @@
+package cryptor
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/internal"
+)
+
+func TestDesEcbEncrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefgh"
+
+	desEcbEncrypt := DesEcbEncrypt([]byte(data), []byte(key))
+	desEcbDecrypt := DesEcbDecrypt(desEcbEncrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestDesEcbEncrypt")
+	assert.Equal(data, string(desEcbDecrypt))
+}
+
+func TestDesCbcEncrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefgh"
+
+	desCbcEncrypt := DesCbcEncrypt([]byte(data), []byte(key))
+	desCbcDecrypt := DesCbcDecrypt(desCbcEncrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestDesCbcEncrypt")
+	assert.Equal(data, string(desCbcDecrypt))
+}
+
+func TestDesCtrCrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefgh"
+
+	desCtrCrypt := DesCtrCrypt([]byte(data), []byte(key))
+	desCtrDeCrypt := DesCtrCrypt(desCtrCrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestDesCtrCrypt")
+	assert.Equal(data, string(desCtrDeCrypt))
+}
+
+func TestDesCfbEncrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefgh"
+
+	desCfbEncrypt := DesCfbEncrypt([]byte(data), []byte(key))
+	desCfbDecrypt := DesCfbDecrypt(desCfbEncrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestDesCfbEncrypt")
+	assert.Equal(data, string(desCfbDecrypt))
+}
+
+func TestDesOfbEncrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefgh"
+
+	desOfbEncrypt := DesOfbEncrypt([]byte(data), []byte(key))
+	desOfbDecrypt := DesOfbDecrypt(desOfbEncrypt, []byte(key))
+
+	assert := internal.NewAssert(t, "TestDesOfbEncrypt")
+	assert.Equal(data, string(desOfbDecrypt))
+}

cryptor/encrypt.go

@@ -1,507 +0,0 @@
-// Copyright 2021 dudaodong@gmail.com. All rights reserved.
-// Use of this source code is governed by MIT license
-
-// Package cryptor implements some util functions to encrypt and decrypt.
-// Note:
-// 1. for aes crypt function, the `key` param length should be 16, 24 or 32. if not, will panic.
-package cryptor
-
-import (
-	"bytes"
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/des"
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/x509"
-	"encoding/pem"
-	"io"
-	"os"
-)
-
-// 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
-func AesEcbEncrypt(data, key []byte) []byte {
-	size := len(key)
-	if size != 16 && size != 24 && size != 32 {
-		panic("key length shoud be 16 or 24 or 32")
-	}
-
-	length := (len(data) + aes.BlockSize) / aes.BlockSize
-	plain := make([]byte, length*aes.BlockSize)
-
-	copy(plain, data)
-
-	pad := byte(len(plain) - len(data))
-	for i := len(data); i < len(plain); i++ {
-		plain[i] = pad
-	}
-
-	encrypted := make([]byte, len(plain))
-	cipher, _ := aes.NewCipher(generateAesKey(key, size))
-
-	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
-func AesEcbDecrypt(encrypted, key []byte) []byte {
-	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 bs, be := 0, cipher.BlockSize(); bs < len(encrypted); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
-		cipher.Decrypt(decrypted[bs:be], encrypted[bs:be])
-	}
-
-	trim := 0
-	if len(decrypted) > 0 {
-		trim = len(decrypted) - int(decrypted[len(decrypted)-1])
-	}
-
-	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
-func AesCbcEncrypt(data, key []byte) []byte {
-	block, _ := aes.NewCipher(key)
-	data = pkcs7Padding(data, block.BlockSize())
-
-	encrypted := make([]byte, aes.BlockSize+len(data))
-	iv := encrypted[:aes.BlockSize]
-	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic(err)
-	}
-
-	mode := cipher.NewCBCEncrypter(block, iv)
-	mode.CryptBlocks(encrypted[aes.BlockSize:], data)
-
-	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
-func AesCbcDecrypt(encrypted, key []byte) []byte {
-	block, _ := aes.NewCipher(key)
-
-	iv := encrypted[:aes.BlockSize]
-	encrypted = encrypted[aes.BlockSize:]
-
-	mode := cipher.NewCBCDecrypter(block, iv)
-	mode.CryptBlocks(encrypted, encrypted)
-
-	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
-func AesCtrCrypt(data, key []byte) []byte {
-	block, _ := aes.NewCipher(key)
-
-	iv := bytes.Repeat([]byte("1"), block.BlockSize())
-	stream := cipher.NewCTR(block, iv)
-
-	dst := make([]byte, len(data))
-	stream.XORKeyStream(dst, data)
-
-	return dst
-}
-
-// AesCfbEncrypt encrypt data with key use AES CFB algorithm
-// len(key) should be 16, 24 or 32.
-// Play: https://go.dev/play/p/tfkF10B13kH
-func AesCfbEncrypt(data, key []byte) []byte {
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		panic(err)
-	}
-
-	encrypted := make([]byte, aes.BlockSize+len(data))
-	iv := encrypted[:aes.BlockSize]
-
-	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-		panic(err)
-	}
-
-	stream := cipher.NewCFBEncrypter(block, iv)
-	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
-func AesCfbDecrypt(encrypted, key []byte) []byte {
-	if len(encrypted) < aes.BlockSize {
-		panic("encrypted data is too short")
-	}
-
-	block, _ := aes.NewCipher(key)
-	iv := encrypted[:aes.BlockSize]
-	encrypted = encrypted[aes.BlockSize:]
-
-	stream := cipher.NewCFBDecrypter(block, iv)
-
-	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
-func AesOfbEncrypt(data, key []byte) []byte {
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		panic(err)
-	}
-
-	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(err)
-	}
-
-	stream := cipher.NewOFB(block, iv)
-	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
-func AesOfbDecrypt(data, key []byte) []byte {
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		panic(err)
-	}
-
-	iv := data[:aes.BlockSize]
-	data = data[aes.BlockSize:]
-	if len(data)%aes.BlockSize != 0 {
-		return nil
-	}
-
-	decrypted := make([]byte, len(data))
-	mode := cipher.NewOFB(block, iv)
-	mode.XORKeyStream(decrypted, data)
-
-	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
-func DesEcbEncrypt(data, key []byte) []byte {
-	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
-	}
-
-	encrypted := make([]byte, len(plain))
-	cipher, _ := des.NewCipher(generateDesKey(key))
-
-	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
-func DesEcbDecrypt(encrypted, key []byte) []byte {
-	cipher, _ := des.NewCipher(generateDesKey(key))
-	decrypted := make([]byte, len(encrypted))
-
-	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])
-	}
-
-	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
-func DesCbcEncrypt(data, key []byte) []byte {
-	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(err)
-	}
-
-	mode := cipher.NewCBCEncrypter(block, iv)
-	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
-func DesCbcDecrypt(encrypted, key []byte) []byte {
-	block, _ := des.NewCipher(key)
-
-	iv := encrypted[:des.BlockSize]
-	encrypted = encrypted[des.BlockSize:]
-
-	mode := cipher.NewCBCDecrypter(block, iv)
-	mode.CryptBlocks(encrypted, encrypted)
-
-	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
-func DesCtrCrypt(data, key []byte) []byte {
-	block, _ := des.NewCipher(key)
-
-	iv := bytes.Repeat([]byte("1"), block.BlockSize())
-	stream := cipher.NewCTR(block, iv)
-
-	dst := make([]byte, len(data))
-	stream.XORKeyStream(dst, data)
-
-	return dst
-}
-
-// DesCfbEncrypt encrypt data with key use DES CFB algorithm
-// len(key) should be 8.
-// Play: https://go.dev/play/p/y-eNxcFBlxL
-func DesCfbEncrypt(data, key []byte) []byte {
-	block, err := des.NewCipher(key)
-	if err != nil {
-		panic(err)
-	}
-
-	encrypted := make([]byte, des.BlockSize+len(data))
-	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)
-
-	return encrypted
-}
-
-// 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
-func DesCfbDecrypt(encrypted, key []byte) []byte {
-	block, _ := des.NewCipher(key)
-	if len(encrypted) < des.BlockSize {
-		panic("encrypted data is too short")
-	}
-	iv := encrypted[:des.BlockSize]
-	encrypted = encrypted[des.BlockSize:]
-
-	stream := cipher.NewCFBDecrypter(block, iv)
-	stream.XORKeyStream(encrypted, encrypted)
-
-	return encrypted
-}
-
-// DesOfbEncrypt encrypt data with key use DES OFB algorithm
-// len(key) should be 16, 24 or 32.
-// Play: https://go.dev/play/p/74KmNadjN1J
-func DesOfbEncrypt(data, key []byte) []byte {
-	block, err := des.NewCipher(key)
-	if err != nil {
-		panic(err)
-	}
-	data = pkcs7Padding(data, des.BlockSize)
-	encrypted := make([]byte, des.BlockSize+len(data))
-	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)
-
-	return encrypted
-}
-
-// DesOfbDecrypt decrypt data with key use DES OFB algorithm
-// len(key) should be 8.
-// Play: https://go.dev/play/p/74KmNadjN1J
-func DesOfbDecrypt(data, key []byte) []byte {
-	block, err := des.NewCipher(key)
-	if err != nil {
-		panic(err)
-	}
-
-	iv := data[:des.BlockSize]
-	data = data[des.BlockSize:]
-	if len(data)%des.BlockSize != 0 {
-		return nil
-	}
-
-	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
-func GenerateRsaKey(keySize int, priKeyFile, pubKeyFile string) error {
-	// private key
-	privateKey, err := rsa.GenerateKey(rand.Reader, keySize)
-	if err != nil {
-		return err
-	}
-
-	derText := x509.MarshalPKCS1PrivateKey(privateKey)
-
-	block := pem.Block{
-		Type:  "rsa private key",
-		Bytes: derText,
-	}
-
-	file, err := os.Create(priKeyFile)
-	if err != nil {
-		panic(err)
-	}
-	err = pem.Encode(file, &block)
-	if err != nil {
-		return err
-	}
-
-	file.Close()
-
-	// public key
-	publicKey := privateKey.PublicKey
-
-	derpText, err := x509.MarshalPKIXPublicKey(&publicKey)
-	if err != nil {
-		return err
-	}
-
-	block = pem.Block{
-		Type:  "rsa public key",
-		Bytes: derpText,
-	}
-
-	file, err = os.Create(pubKeyFile)
-	if err != nil {
-		return err
-	}
-
-	err = pem.Encode(file, &block)
-	if err != nil {
-		return err
-	}
-
-	file.Close()
-
-	return nil
-}
-
-// RsaEncrypt encrypt data with ras algorithm.
-// Play: https://go.dev/play/p/rDqTT01SPkZ
-func RsaEncrypt(data []byte, pubKeyFileName string) []byte {
-	file, err := os.Open(pubKeyFileName)
-	if err != nil {
-		panic(err)
-	}
-	fileInfo, err := file.Stat()
-	if err != nil {
-		panic(err)
-	}
-	defer file.Close()
-	buf := make([]byte, fileInfo.Size())
-
-	_, err = file.Read(buf)
-	if err != nil {
-		panic(err)
-	}
-
-	block, _ := pem.Decode(buf)
-
-	pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
-	if err != nil {
-		panic(err)
-	}
-	pubKey := pubInterface.(*rsa.PublicKey)
-
-	cipherText, err := rsa.EncryptPKCS1v15(rand.Reader, pubKey, data)
-	if err != nil {
-		panic(err)
-	}
-	return cipherText
-}
-
-// RsaDecrypt decrypt data with ras algorithm.
-// Play: https://go.dev/play/p/rDqTT01SPkZ
-func RsaDecrypt(data []byte, privateKeyFileName string) []byte {
-	file, err := os.Open(privateKeyFileName)
-	if err != nil {
-		panic(err)
-	}
-	fileInfo, err := file.Stat()
-	if err != nil {
-		panic(err)
-	}
-	buf := make([]byte, fileInfo.Size())
-	defer file.Close()
-
-	_, err = file.Read(buf)
-	if err != nil {
-		panic(err)
-	}
-
-	block, _ := pem.Decode(buf)
-
-	priKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
-	if err != nil {
-		panic(err)
-	}
-
-	plainText, err := rsa.DecryptPKCS1v15(rand.Reader, priKey, data)
-	if err != nil {
-		panic(err)
-	}
-	return plainText
-}

cryptor/encrypt_test.go

@@ -1,130 +0,0 @@
-package cryptor
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-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, "TestAesEcbEncrypt")
-	assert.Equal(data, string(aesEcbDecrypt))
-}
-
-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, "TestAesCbcEncrypt")
-	assert.Equal(data, string(aesCbcDecrypt))
-}
-
-func TestAesCtrCrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefghijklmnop"
-
-	aesCtrCrypt := AesCtrCrypt([]byte(data), []byte(key))
-	aesCtrDeCrypt := AesCtrCrypt(aesCtrCrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestAesCtrCrypt")
-	assert.Equal(data, string(aesCtrDeCrypt))
-}
-
-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, "TestAesCfbEncrypt")
-	assert.Equal(data, string(aesCfbDecrypt))
-}
-
-func TestAesOfbEncrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefghijklmnop"
-
-	aesOfbEncrypt := AesOfbEncrypt([]byte(data), []byte(key))
-	aesOfbDecrypt := AesOfbDecrypt(aesOfbEncrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestAesOfbEncrypt")
-	assert.Equal(data, string(aesOfbDecrypt))
-}
-
-func TestDesEcbEncrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefgh"
-
-	desEcbEncrypt := DesEcbEncrypt([]byte(data), []byte(key))
-	desEcbDecrypt := DesEcbDecrypt(desEcbEncrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestDesEcbEncrypt")
-	assert.Equal(data, string(desEcbDecrypt))
-}
-
-func TestDesCbcEncrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefgh"
-
-	desCbcEncrypt := DesCbcEncrypt([]byte(data), []byte(key))
-	desCbcDecrypt := DesCbcDecrypt(desCbcEncrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestDesCbcEncrypt")
-	assert.Equal(data, string(desCbcDecrypt))
-}
-
-func TestDesCtrCrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefgh"
-
-	desCtrCrypt := DesCtrCrypt([]byte(data), []byte(key))
-	desCtrDeCrypt := DesCtrCrypt(desCtrCrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestDesCtrCrypt")
-	assert.Equal(data, string(desCtrDeCrypt))
-}
-
-func TestDesCfbEncrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefgh"
-
-	desCfbEncrypt := DesCfbEncrypt([]byte(data), []byte(key))
-	desCfbDecrypt := DesCfbDecrypt(desCfbEncrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestDesCfbEncrypt")
-	assert.Equal(data, string(desCfbDecrypt))
-}
-
-func TestDesOfbEncrypt(t *testing.T) {
-	data := "hello world"
-	key := "abcdefgh"
-
-	desOfbEncrypt := DesOfbEncrypt([]byte(data), []byte(key))
-	desOfbDecrypt := DesOfbDecrypt(desOfbEncrypt, []byte(key))
-
-	assert := internal.NewAssert(t, "TestDesOfbEncrypt")
-	assert.Equal(data, string(desOfbDecrypt))
-}
-
-func TestRsaEncrypt(t *testing.T) {
-	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
-	if err != nil {
-		t.FailNow()
-	}
-	data := []byte("hello world")
-	encrypted := RsaEncrypt(data, "rsa_public.pem")
-	decrypted := RsaDecrypt(encrypted, "rsa_private.pem")
-
-	assert := internal.NewAssert(t, "TestRsaEncrypt")
-	assert.Equal(string(data), string(decrypted))
-}

cryptor/rsa.go

@@ -0,0 +1,118 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package cryptor implements some util functions to encrypt and decrypt.
+package cryptor
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/pem"
+	"os"
+)
+
+// 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)
+	if err != nil {
+		return err
+	}
+
+	derText := x509.MarshalPKCS1PrivateKey(privateKey)
+
+	block := pem.Block{
+		Type:  "rsa private key",
+		Bytes: derText,
+	}
+
+	//file,err := os.Create("rsa_private.pem")
+	file, err := os.Create(priKeyFile)
+	if err != nil {
+		panic(err)
+	}
+	pem.Encode(file, &block)
+	file.Close()
+
+	// public key
+	publicKey := privateKey.PublicKey
+
+	derpText, err := x509.MarshalPKIXPublicKey(&publicKey)
+	if err != nil {
+		return err
+	}
+
+	block = pem.Block{
+		Type:  "rsa public key",
+		Bytes: derpText,
+	}
+
+	//file,err = os.Create("rsa_public.pem")
+	file, err = os.Create(pubKeyFile)
+	if err != nil {
+		return err
+	}
+	pem.Encode(file, &block)
+	file.Close()
+
+	return nil
+}
+
+// RsaEncrypt encrypt data with ras algorithm
+func RsaEncrypt(data []byte, pubKeyFileName string) []byte {
+	file, err := os.Open(pubKeyFileName)
+	if err != nil {
+		panic(err)
+	}
+	fileInfo, err := file.Stat()
+	if err != nil {
+		panic(err)
+	}
+	defer file.Close()
+	buf := make([]byte, fileInfo.Size())
+	file.Read(buf)
+
+	block, _ := pem.Decode(buf)
+
+	pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
+	if err != nil {
+		panic(err)
+	}
+	pubKey := pubInterface.(*rsa.PublicKey)
+
+	cipherText, err := rsa.EncryptPKCS1v15(rand.Reader, pubKey, data)
+	if err != nil {
+		panic(err)
+	}
+	return cipherText
+}
+
+// RsaDecrypt decrypt data with ras algorithm
+func RsaDecrypt(data []byte, privateKeyFileName string) []byte {
+	file, err := os.Open(privateKeyFileName)
+	if err != nil {
+		panic(err)
+	}
+	fileInfo, err := file.Stat()
+	if err != nil {
+		panic(err)
+	}
+	buf := make([]byte, fileInfo.Size())
+	defer file.Close()
+	file.Read(buf)
+
+	block, _ := pem.Decode(buf)
+
+	priKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
+	if err != nil {
+		panic(err)
+	}
+
+	plainText, err := rsa.DecryptPKCS1v15(rand.Reader, priKey, data)
+	if err != nil {
+		panic(err)
+	}
+	return plainText
+}

cryptor/rsa_test.go

@@ -0,0 +1,20 @@
+package cryptor
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/internal"
+)
+
+func TestRsaEncrypt(t *testing.T) {
+	err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+	if err != nil {
+		t.FailNow()
+	}
+	data := []byte("hello world")
+	encrypted := RsaEncrypt(data, "rsa_public.pem")
+	decrypted := RsaDecrypt(encrypted, "rsa_private.pem")
+
+	assert := internal.NewAssert(t, "TestRsaEncrypt")
+	assert.Equal(string(data), string(decrypted))
+}

datastructure/hashmap/hashmap.go

@@ -1,175 +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"
-)
-
-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]
-	if node != nil {
-		return node.value
-	}
-
-	return nil
-}
-
-// 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)]
-	return node != nil
-}
-
-// 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)
-			}
-		}
-	}
-}
-
-// 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
-	}
-}
-
-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,70 +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) {
-	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) {
-	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) {
-	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))
-}

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/lancetconstraints"
-)
-
-// MaxHeap implements a binary max heap
-// type T should implements Compare function in lancetconstraints.Comparator interface.
-type MaxHeap[T any] struct {
-	data       []T
-	comparator lancetconstraints.Comparator
-}
-
-// NewMaxHeap returns a MaxHeap instance with the given comparator.
-func NewMaxHeap[T any](comparator lancetconstraints.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 lancetconstraints.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,90 +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) {
-	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) {
-	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) {
-	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) {
-	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 := []T{}
-	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,166 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestDoublyLink_InsertAtFirst(t *testing.T) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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 := []T{}
-	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,185 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestSinglyLink_InsertAtFirst(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSinglyLink_InsertAtFirst")
-
-	link := NewSinglyLink[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 TestSinglyLink_InsertAtTail(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSinglyLink_InsertAtTail")
-
-	link := NewSinglyLink[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 TestSinglyLink_InsertAt(t *testing.T) {
-	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) {
-	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()
-	link.Print()
-
-	expected := []int{2, 3, 4}
-	values := link.Values()
-
-	assert.Equal(expected, values)
-}
-
-func TestSinglyLink_DeleteAtTail(t *testing.T) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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/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 remove 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, remove 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,462 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestListData(t *testing.T) {
-	assert := internal.NewAssert(t, "TestListData")
-
-	list := NewList([]int{1, 2, 3})
-	assert.Equal([]int{1, 2, 3}, list.Data())
-}
-
-func TestValueOf(t *testing.T) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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/queue/arrayqueue.go

@@ -1,124 +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 {
-	items    []T
-	head     int
-	tail     int
-	capacity int
-	size     int
-}
-
-func NewArrayQueue[T any](capacity int) *ArrayQueue[T] {
-	return &ArrayQueue[T]{
-		items:    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 := []T{}
-	for i := q.head; i < q.tail; i++ {
-		items = append(items, q.items[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.items[0]
-}
-
-// Back return back value of queue
-func (q *ArrayQueue[T]) Back() T {
-	return q.items[q.size-1]
-}
-
-// EnQueue put element into queue
-func (q *ArrayQueue[T]) Enqueue(item T) bool {
-	if q.head == 0 && q.tail == q.capacity {
-		return false
-	} else if q.head != 0 && q.tail == q.capacity {
-		for i := q.head; i < q.tail; i++ {
-			q.items[i-q.head] = q.items[i]
-		}
-		q.tail = q.tail - q.head
-		q.head = 0
-	}
-
-	q.items = append(q.items, item)
-	q.tail++
-	q.size++
-	return true
-}
-
-// DeQueue remove head element of queue and return it, if queue is empty, return nil and error
-func (q *ArrayQueue[T]) Dequeue() (T, bool) {
-	var item T
-	if q.head == q.tail {
-		return item, false
-	}
-	item = q.items[q.head]
-	q.head++
-	q.size--
-	return item, true
-}
-
-// Clear the queue data
-func (q *ArrayQueue[T]) Clear() {
-	capacity := q.capacity
-	q.items = 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.items {
-		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.items[i])
-	}
-	info += "]"
-	fmt.Println(info)
-}

datastructure/queue/arrayqueue_test.go

@@ -1,106 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestArrayQueue_Enqueue(t *testing.T) {
-	assert := internal.NewAssert(t, "TestArrayQueue_Enqueue")
-
-	queue := NewArrayQueue[int](5)
-	queue.Enqueue(1)
-	queue.Enqueue(2)
-	queue.Enqueue(3)
-
-	expected := []int{1, 2, 3}
-	data := queue.Data()
-	size := queue.Size()
-
-	assert.Equal(expected, data)
-	assert.Equal(3, size)
-}
-
-func TestArrayQueue_Dequeue(t *testing.T) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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,145 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestCircularQueue_Enqueue(t *testing.T) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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 := []T{}
-	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,95 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestLinkedQueue_Enqueue(t *testing.T) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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/lancetconstraints"
-)
-
-// PriorityQueue is a priority queue implemented by binary heap tree
-// type T should implements Compare function in lancetconstraints.Comparator interface.
-type PriorityQueue[T any] struct {
-	items      []T
-	size       int
-	comparator lancetconstraints.Comparator
-}
-
-// NewPriorityQueue return a pointer of PriorityQueue
-// param `comparator` is used to compare values in the queue
-func NewPriorityQueue[T any](capacity int, comparator lancetconstraints.Comparator) *PriorityQueue[T] {
-	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,70 +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) {
-	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) {
-	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,199 +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
-
-// Set is a data container, like slice, but element of set is not duplicate.
-type Set[T comparable] map[T]struct{}
-
-// NewSet return a instance of set
-func NewSet[T comparable](items ...T) Set[T] {
-	set := make(Set[T])
-	set.Add(items...)
-	return set
-}
-
-// NewSetFromSlice create a set from slice
-func NewSetFromSlice[T comparable](items []T) Set[T] {
-	set := make(Set[T])
-	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 := NewSet[T]()
-	set.Add(s.Values()...)
-	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
-func (s Set[T]) Values() []T {
-	result := make([]T, 0, len(s))
-
-	s.Iterate(func(value T) {
-		result = append(result, value)
-	})
-
-	return result
-}
-
-// 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 := NewSet[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 := NewSet[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 an set of whose element in origin set but not in compared set
-func (s Set[T]) Minus(comparedSet Set[T]) Set[T] {
-	set := NewSet[T]()
-
-	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 {
-		items := s.Values()
-		item := items[len(s)-1]
-		delete(s, item)
-		return item, true
-	}
-
-	return v, false
-}

datastructure/set/set_test.go

@@ -1,231 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestSet_NewSetFromSlice(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSet_NewSetFromSlice")
-
-	s1 := NewSetFromSlice([]int{1, 2, 2, 3})
-	assert.Equal(3, s1.Size())
-	assert.Equal(true, s1.Contain(1))
-	assert.Equal(true, s1.Contain(2))
-	assert.Equal(true, s1.Contain(3))
-
-	s2 := NewSetFromSlice([]int{})
-	assert.Equal(0, s2.Size())
-}
-
-func TestSet_Add(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSet_Add")
-
-	set := NewSet[int]()
-	set.Add(1, 2, 3)
-
-	expected := NewSet(1, 2, 3)
-
-	assert.Equal(true, set.Equal(expected))
-}
-
-func TestSet_AddIfNotExist(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSet_AddIfNotExist")
-
-	set := NewSet[int]()
-	set.Add(1, 2, 3)
-
-	assert.Equal(false, set.AddIfNotExist(1))
-	assert.Equal(true, set.AddIfNotExist(4))
-	assert.Equal(NewSet(1, 2, 3, 4), set)
-}
-
-func TestSet_AddIfNotExistBy(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSet_AddIfNotExistBy")
-
-	set := NewSet[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) {
-	assert := internal.NewAssert(t, "TestSet_Contain")
-
-	set := NewSet[int]()
-	set.Add(1, 2, 3)
-
-	assert.Equal(true, set.Contain(1))
-	assert.Equal(false, set.Contain(4))
-}
-
-func TestSet_ContainAll(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSet_ContainAll")
-
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(1, 2)
-	set3 := NewSet(1, 2, 3, 4)
-
-	assert.Equal(true, set1.ContainAll(set2))
-	assert.Equal(false, set1.ContainAll(set3))
-}
-
-func TestSet_Clone(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSet_Clone")
-
-	set1 := NewSet(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) {
-	assert := internal.NewAssert(t, "TestSet_Delete")
-
-	set := NewSet[int]()
-	set.Add(1, 2, 3)
-	set.Delete(3)
-
-	expected := NewSet(1, 2)
-
-	assert.Equal(true, set.Equal(expected))
-}
-
-func TestSet_Equal(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSet_Equal")
-
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(1, 2, 3)
-	set3 := NewSet(1, 2, 3, 4)
-
-	assert.Equal(true, set1.Equal(set2))
-	assert.Equal(false, set1.Equal(set3))
-}
-
-func TestSet_Iterate(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSet_Iterate")
-
-	set := NewSet(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) {
-	assert := internal.NewAssert(t, "TestSet_IsEmpty")
-
-	set := NewSet[int]()
-	assert.Equal(true, set.IsEmpty())
-}
-
-func TestSet_Size(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSet_Size")
-
-	set := NewSet(1, 2, 3)
-	assert.Equal(3, set.Size())
-}
-
-func TestSet_Values(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSet_Values")
-
-	set := NewSet(1, 2, 3)
-	values := set.Values()
-
-	assert.Equal(3, len(values))
-}
-
-func TestSet_Union(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSet_Union")
-
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
-	expected := NewSet(1, 2, 3, 4, 5)
-	unionSet := set1.Union(set2)
-
-	assert.Equal(expected, unionSet)
-}
-
-func TestSet_Intersection(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSet_Intersection")
-
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
-	expected := NewSet(2, 3)
-	intersectionSet := set1.Intersection(set2)
-
-	assert.Equal(expected, intersectionSet)
-}
-
-func TestSet_SymmetricDifference(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSet_SymmetricDifference")
-
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
-
-	assert.Equal(NewSet(1, 4, 5), set1.SymmetricDifference(set2))
-}
-
-func TestSet_Minus(t *testing.T) {
-	assert := internal.NewAssert(t, "TestSet_Minus")
-
-	set1 := NewSet(1, 2, 3)
-	set2 := NewSet(2, 3, 4, 5)
-	set3 := NewSet(2, 3)
-
-	assert.Equal(NewSet(1), set1.Minus(set2))
-	assert.Equal(NewSet(4, 5), set2.Minus(set3))
-}
-
-func TestEachWithBreak(t *testing.T) {
-	// s := NewSet(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) {
-// 	assert := internal.NewAssert(t, "TestPop")
-
-// 	s := NewSet[int]()
-
-// 	val, ok := s.Pop()
-// 	assert.Equal(0, val)
-// 	assert.Equal(false, ok)
-
-// 	s.Add(1)
-// 	s.Add(2)
-// 	s.Add(3)
-
-// 	// s = NewSet(1, 2, 3, 4, 5)
-
-// 	val, ok = s.Pop()
-// 	assert.Equal(3, val)
-// 	assert.Equal(true, ok)
-// }

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,77 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestArrayStack_Push(t *testing.T) {
-	assert := internal.NewAssert(t, "TestArrayStack_Push")
-
-	stack := NewArrayStack[int]()
-	stack.Push(1)
-	stack.Push(2)
-	stack.Push(3)
-
-	expected := []int{3, 2, 1}
-	values := stack.Data()
-	length := stack.Size()
-
-	assert.Equal(expected, values)
-	assert.Equal(3, length)
-}
-
-func TestArrayStack_Pop(t *testing.T) {
-	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)
-
-	expected := []int{2, 1}
-	assert.Equal(expected, stack.Data())
-}
-
-func TestArrayStack_Peak(t *testing.T) {
-	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)
-
-	expected := []int{3, 2, 1}
-	assert.Equal(expected, stack.Data())
-}
-
-func TestArrayStack_Clear(t *testing.T) {
-	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 := []T{}
-	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,78 +0,0 @@
-package datastructure
-
-import (
-	"testing"
-
-	"github.com/duke-git/lancet/v2/internal"
-)
-
-func TestLinkedStack_Push(t *testing.T) {
-	assert := internal.NewAssert(t, "TestLinkedStack_Push")
-
-	stack := NewLinkedStack[int]()
-	stack.Push(1)
-	stack.Push(2)
-	stack.Push(3)
-
-	expected := []int{3, 2, 1}
-	values := stack.Data()
-	size := stack.Size()
-
-	assert.Equal(expected, values)
-	assert.Equal(3, size)
-}
-
-func TestLinkedStack_Pop(t *testing.T) {
-	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)
-
-	expected := []int{2, 1}
-	stack.Print()
-	assert.Equal(expected, stack.Data())
-}
-
-func TestLinkedStack_Peak(t *testing.T) {
-	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)
-
-	expected := []int{3, 2, 1}
-	assert.Equal(expected, stack.Data())
-}
-
-func TestLinkedStack_Empty(t *testing.T) {
-	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/datastructure"
-	"github.com/duke-git/lancet/v2/lancetconstraints"
-)
-
-// BSTree is a binary search tree data structure in which each node has at most two children,
-// which are referred to as the left child and the right child.
-// In BSTree: leftNode < rootNode < rightNode
-// type T should implements Compare function in lancetconstraints.Comparator interface.
-type BSTree[T any] struct {
-	root       *datastructure.TreeNode[T]
-	comparator lancetconstraints.Comparator
-}
-
-// NewBSTree create a BSTree pointer
-// param `comparator` is used to compare values in the tree
-func NewBSTree[T any](rootData T, comparator lancetconstraints.Comparator) *BSTree[T] {
-	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 lancetconstraints.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,141 +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_Insert(t *testing.T) {
-	bstree := NewBSTree(6, &intComparator{})
-
-	bstree.Insert(7)
-	bstree.Insert(5)
-	bstree.Insert(2)
-	bstree.Insert(4)
-}
-
-func TestBSTree_PreOrderTraverse(t *testing.T) {
-	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) {
-	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) {
-	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) {
-	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) {
-	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)
-
-	//todo
-	// bstree.DeletetNode(6, comparator)
-	// bstree.Print()
-	// acturl2 := bstree.InOrderTraverse()
-	// assert.Equal([]int{2, 5, 7}, acturl2)
-}
-
-func TestBSTree_Depth(t *testing.T) {
-	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) {
-	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/datastructure"
-	"github.com/duke-git/lancet/v2/lancetconstraints"
-)
-
-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 lancetconstraints.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 lancetconstraints.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 := []*datastructure.TreeNode[T]{}
-	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 lancetconstraints.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,7 +3,7 @@ package datetime
 import (
 	"testing"
 
-	"github.com/duke-git/lancet/v2/internal"
+	"github.com/duke-git/lancet/internal"
 )
 
 func TestToUnix(t *testing.T) {
@@ -19,31 +19,36 @@ func TestToUnix(t *testing.T) {
 func TestToFormat(t *testing.T) {
 	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) {
 	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")
-	// assert.Equal("2022/03/18 17:04:05", tm.ToFormatForTpl("2006/01/02 15: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) {
 	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())
-	// assert.Equal("2006-01-02T23:04:05+08:00", tm.ToIso8601())
+	tm, err = NewISO8601("2006-01-02T15:04:05.999Z")
 	assert.IsNil(err)
+
+	t.Log("ToIso8601 -> ", tm.ToIso8601())
 }

datetime/datetime.go

@@ -4,24 +4,24 @@
 // Package datetime implements some functions to format date and time.
 // Note:
 // 1. `format` param in FormatTimeToStr function should be as flow:
-// "yyyy-mm-dd hh:mm:ss"
-// "yyyy-mm-dd hh:mm"
-// "yyyy-mm-dd hh"
-// "yyyy-mm-dd"
-// "yyyy-mm"
-// "mm-dd"
-// "dd-mm-yy hh:mm:ss"
-// "yyyy/mm/dd hh:mm:ss"
-// "yyyy/mm/dd hh:mm"
-// "yyyy/mm/dd hh"
-// "yyyy/mm/dd"
-// "yyyy/mm"
-// "mm/dd"
-// "dd/mm/yy hh:mm:ss"
-// "yyyy"
-// "mm"
-// "hh:mm:ss"
-// "mm:ss"
+//"yyyy-mm-dd hh:mm:ss"
+//"yyyy-mm-dd hh:mm"
+//"yyyy-mm-dd hh"
+//"yyyy-mm-dd"
+//"yyyy-mm"
+//"mm-dd"
+//"dd-mm-yy hh:mm:ss"
+//"yyyy/mm/dd hh:mm:ss"
+//"yyyy/mm/dd hh:mm"
+//"yyyy/mm/dd hh"
+//"yyyy/mm/dd"
+//"yyyy/mm"
+//"mm/dd"
+//"dd/mm/yy hh:mm:ss"
+//"yyyy"
+//"mm"
+//"hh:mm:ss"
+//"mm:ss"
 package datetime
 
 import (
@@ -35,7 +35,7 @@ func init() {
 	timeFormat = map[string]string{
 		"yyyy-mm-dd hh:mm:ss": "2006-01-02 15:04:05",
 		"yyyy-mm-dd hh:mm":    "2006-01-02 15:04",
-		"yyyy-mm-dd hh":       "2006-01-02 15",
+		"yyyy-mm-dd hh":       "2006-01-02 15:04",
 		"yyyy-mm-dd":          "2006-01-02",
 		"yyyy-mm":             "2006-01",
 		"mm-dd":               "01-02",
@@ -54,70 +54,54 @@ func init() {
 	}
 }
 
-// AddMinute add or sub minute to the time.
-// Play: https://go.dev/play/p/nT1heB1KUUK
+// 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 hour to the time.
-// Play: https://go.dev/play/p/rcMjd7OCsi5
+// 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 day to the time.
-// Play: https://go.dev/play/p/dIGbs_uTdFa
+// 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.Add(365 * 24 * time.Hour * time.Duration(year))
-}
-
-// 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")
 }
 
-// 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) string {
 	return t.Format(timeFormat[format])
 }
 
-// FormatStrToTime convert string to time.
-// Play: https://go.dev/play/p/1h9FwdU8ql4
+// FormatStrToTime convert string to time
 func FormatStrToTime(str, format string) (time.Time, error) {
 	v, ok := timeFormat[format]
 	if !ok {
@@ -127,129 +111,72 @@ func FormatStrToTime(str, format string) (time.Time, error) {
 	return time.Parse(v, 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/ynjoJPz7VNV
-func BeginOfWeek(t time.Time, beginFrom ...time.Weekday) time.Time {
-	var beginFromWeekday = time.Sunday
-	if len(beginFrom) > 0 {
-		beginFromWeekday = beginFrom[0]
-	}
-	y, m, d := t.AddDate(0, 0, int(beginFromWeekday-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/i08qKXD9flf
-func EndOfWeek(t time.Time, endWith ...time.Weekday) time.Time {
-	var endWithWeekday = time.Saturday
-	if len(endWith) > 0 {
-		endWithWeekday = endWith[0]
-	}
-	y, m, d := t.AddDate(0, 0, int(endWithWeekday-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())
-	nowDate := time.Date(y, m, d, 0, 0, 0, 0, t.Location())
-
-	return int(nowDate.Sub(firstDay).Hours() / 24)
-}
-
-// IsWeekend checks if passed time is weekend or not.
-// Play: https://go.dev/play/p/cupRM5aZOIY
-func IsWeekend(t time.Time) bool {
-	return time.Saturday == t.Weekday() || time.Sunday == t.Weekday()
-}

datetime/datetime_example_test.go

@@ -1,410 +0,0 @@
-package datetime
-
-import (
-	"fmt"
-	"reflect"
-	"time"
-)
-
-func ExampleAddDay() {
-	now := time.Now()
-
-	tomorrow := AddDay(now, 1)
-	diff1 := tomorrow.Sub(now)
-
-	yesterday := AddDay(now, -1)
-	diff2 := yesterday.Sub(now)
-
-	fmt.Println(diff1)
-	fmt.Println(diff2)
-
-	// Output:
-	// 24h0m0s
-	// -24h0m0s
-}
-
-func ExampleAddHour() {
-	now := time.Now()
-
-	after2Hours := AddHour(now, 2)
-	diff1 := after2Hours.Sub(now)
-
-	before2Hours := AddHour(now, -2)
-	diff2 := before2Hours.Sub(now)
-
-	fmt.Println(diff1)
-	fmt.Println(diff2)
-
-	// Output:
-	// 2h0m0s
-	// -2h0m0s
-}
-
-func ExampleAddMinute() {
-	now := time.Now()
-
-	after2Minutes := AddMinute(now, 2)
-	diff1 := after2Minutes.Sub(now)
-
-	before2Minutes := AddMinute(now, -2)
-	diff2 := before2Minutes.Sub(now)
-
-	fmt.Println(diff1)
-	fmt.Println(diff2)
-
-	// Output:
-	// 2m0s
-	// -2m0s
-}
-
-func ExampleAddYear() {
-	now := time.Now()
-
-	after1Year := AddYear(now, 1)
-	diff1 := after1Year.Sub(now)
-
-	before1Year := AddYear(now, -1)
-	diff2 := before1Year.Sub(now)
-
-	fmt.Println(diff1)
-	fmt.Println(diff2)
-
-	// Output:
-	// 8760h0m0s
-	// -8760h0m0s
-}
-
-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)
-
-	fmt.Println(result)
-
-	// Output:
-	// 2023-01-08 00:00:00 +0000 UTC
-}
-
-func ExampleEndOfWeek() {
-	input := time.Date(2023, 1, 8, 18, 50, 10, 100, time.UTC)
-
-	result := EndOfWeek(input)
-
-	fmt.Println(result)
-
-	// Output:
-	// 2023-01-14 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
-}

datetime/datetime_test.go

@@ -4,36 +4,9 @@ import (
 	"testing"
 	"time"
 
-	"github.com/duke-git/lancet/v2/internal"
+	"github.com/duke-git/lancet/internal"
 )
 
-func TestAddYear(t *testing.T) {
-	assert := internal.NewAssert(t, "TestAddDay")
-
-	now := time.Now()
-	after2Years := AddYear(now, 1)
-	diff1 := after2Years.Sub(now)
-	assert.Equal(float64(8760), diff1.Hours())
-
-	before2Years := AddYear(now, -1)
-	diff2 := before2Years.Sub(now)
-	assert.Equal(float64(-8760), diff2.Hours())
-}
-
-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 TestAddDay(t *testing.T) {
 	assert := internal.NewAssert(t, "TestAddDay")
 
@@ -79,8 +52,8 @@ func TestGetNowDate(t *testing.T) {
 	assert.Equal(expected, GetNowDate())
 }
 
-func TestGetNowTime(t *testing.T) {
-	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())
 }
@@ -98,20 +71,17 @@ func TestFormatTimeToStr(t *testing.T) {
 	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)
+
 	}
 }
 
@@ -261,44 +231,3 @@ func TestEndOfYear(t *testing.T) {
 
 	assert.Equal(expected, actual)
 }
-
-func TestIsLeapYear(t *testing.T) {
-	assert := internal.NewAssert(t, "TestEndOfYear")
-
-	result1 := IsLeapYear(2000)
-	result2 := IsLeapYear(2001)
-
-	assert.Equal(true, result1)
-	assert.Equal(false, 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)
-	assert.Equal(31, result1)
-
-	date2 := time.Date(2023, 01, 02, 1, 1, 1, 0, time.Local)
-	result2 := DayOfYear(date2)
-	assert.Equal(1, result2)
-
-	date3 := time.Date(2023, 01, 01, 1, 1, 1, 0, time.Local)
-	result3 := DayOfYear(date3)
-	assert.Equal(0, result3)
-}
-
-func TestIsWeekend(t *testing.T) {
-	assert := internal.NewAssert(t, "TestIsWeekend")
-	date := time.Date(2023, 06, 03, 0, 0, 0, 0, time.Local)
-	result := IsWeekend(date)
-	assert.Equal(true, result)
-
-	date1 := time.Date(2023, 06, 04, 0, 0, 0, 0, time.Local)
-	result1 := IsWeekend(date1)
-	assert.Equal(true, result1)
-
-	date2 := time.Date(2023, 06, 02, 0, 0, 0, 0, time.Local)
-	result2 := IsWeekend(date2)
-	assert.Equal(false, result2)
-
-}

docs/algorithm.md

@@ -1,636 +0,0 @@
-# Algorithm
-
-Package algorithm implements some basic algorithm. eg. sort, search.
-
-<div STYLE="page-break-after: always;"></div>
-
-## Source
-
--   [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/lru_cache.go](https://github.com/duke-git/lancet/blob/main/algorithm/lru_cache.go)
-
-<div STYLE="page-break-after: always;"></div>
-
-## Usage
-
-```go
-import (
-    "github.com/duke-git/lancet/v2/algorithm"
-)
-```
-
-<div STYLE="page-break-after: always;"></div>
-
-## Index
-
--   [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>
-
-## Documentation
-
-### <span id="BubbleSort">BubbleSort</span>
-
-<p>Sort slice with bubble sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
-
-<b>Signature:</b>
-
-```go
-func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator)
-```
-
-<b>Example:</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>Sort slice with insertion sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
-
-<b>Signature:</b>
-
-```go
-func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator)
-```
-
-<b>Example:</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/lancetconstraints/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>Sort slice with selection sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
-
-<b>Signature:</b>
-
-```go
-func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator)
-```
-
-<b>Example:</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>Sort slice with shell sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
-
-<b>Signature:</b>
-
-```go
-func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator)
-```
-
-<b>Example:</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>Sort slice with quick sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
-
-<b>Signature:</b>
-
-```go
-func QuickSort[T any](slice []T comparator lancetconstraints.Comparator)
-```
-
-<b>Example:</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>Sort slice with heap sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
-
-<b>Signature:</b>
-
-```go
-func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator)
-```
-
-<b>Example:</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>Sort slice with merge sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
-
-<b>Signature:</b>
-
-```go
-func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator)
-```
-
-<b>Example:</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>Sort slice with count sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
-
-<b>Signature:</b>
-
-```go
-func CountSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
-```
-
-<b>Example:</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>BinarySearch search for target within a sorted slice, recursive call itself. If a target is found, the index of the target is returned. Else the function return -1.</p>
-
-<b>Signature:</b>
-
-```go
-func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
-```
-
-<b>Example:</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>BinaryIterativeSearch search for target within a sorted slice, recursive call itself. If a target is found, the index of the target is returned. Else the function return -1.</p>
-
-<b>Signature:</b>
-
-```go
-func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
-```
-
-<b>Example:</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>return the index of target in slice base on equal function.If a target is found, the index of the target is returned. Else the function return -1.</p>
-
-<b>Signature:</b>
-
-```go
-func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int
-```
-
-<b>Example:</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>LRUCache implements mem cache with lru.</p>
-
-<b>Signature:</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>Example:</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/algorithm_zh-CN.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/lru_cache.go](https://github.com/duke-git/lancet/blob/main/algorithm/lru_cache.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需要实现包lancetconstraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator)
-```
-
-<b>示例:</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需要实现包lancetconstraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator)
-```
-
-<b>示例:</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/lancetconstraints/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需要实现包lancetconstraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator)
-```
-
-<b>示例:</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需要实现包lancetconstraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator)
-```
-
-<b>示例:</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需要实现包lancetconstraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-func QuickSort[T any](slice []T comparator lancetconstraints.Comparator)
-```
-
-<b>示例:</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需要实现包lancetconstraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator)
-```
-
-<b>示例:</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需要实现包lancetconstraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator)
-```
-
-<b>示例:</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需要实现包lancetconstraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-func CountSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
-```
-
-<b>示例:</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需要实现包lancetconstraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
-```
-
-<b>示例:</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需要实现包lancetconstraints.Comparator。</p>
-
-<b>函数签名:</b>
-
-```go
-func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
-```
-
-<b>示例:</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>示例:</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>示例:</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/compare.md

@@ -1,326 +0,0 @@
-# Compare
-
-Package compare provides a lightweight comparison function on any type.
-
-<div STYLE="page-break-after: always;"></div>
-
-## Source:
-
--   [https://github.com/duke-git/lancet/blob/main/compare/compare.go](https://github.com/duke-git/lancet/blob/main/compare/compare.go)
-
--   [https://github.com/duke-git/lancet/blob/main/compare/compare_internal.go](https://github.com/duke-git/lancet/blob/main/compare/compare_internal.go)
-
-<div STYLE="page-break-after: always;"></div>
-
-## Usage:
-
-```go
-import (
-    "github.com/duke-git/lancet/v2/condition"
-)
-```
-
-<div STYLE="page-break-after: always;"></div>
-
-## Index
-
--   [Equal](#Equal)
--   [EqualValue](#EqualValue)
--   [LessThan](#LessThan)
--   [GreaterThan](#GreaterThan)
--   [LessOrEqual](#LessOrEqual)
--   [GreaterOrEqual](#GreaterOrEqual)
-
-<div STYLE="page-break-after: always;"></div>
-
-## Documentation
-
-### <span id="Equal">Equal</span>
-
-<p>Checks if two values are equal or not. (check both type and value)</p>
-
-<b>Signature:</b>
-
-```go
-func Equal(left, right any) bool
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/compare"
-)
-
-func main() {
-    result1 := compare.Equal(1, 1)
-    result2 := compare.Equal("1", "1")
-    result3 := compare.Equal([]int{1, 2, 3}, []int{1, 2, 3})
-    result4 := compare.Equal(map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "b"})
-
-    result5 := compare.Equal(1, "1")
-    result6 := compare.Equal(1, int64(1))
-    result7 := compare.Equal([]int{1, 2}, []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:
-    // true
-    // true
-    // true
-    // true
-    // false
-    // false
-    // false
-}
-```
-
-### <span id="EqualValue">EqualValue</span>
-
-<p>Checks if two values are equal or not. (check value only)</p>
-
-<b>Signature:</b>
-
-```go
-func EqualValue(left, right any) bool
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/compare"
-)
-
-func main() {
-    result1 := compare.EqualValue(1, 1)
-    result2 := compare.EqualValue(int(1), int64(1))
-    result3 := compare.EqualValue(1, "1")
-    result4 := compare.EqualValue(1, "2")
-
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
-    fmt.Println(result4)
-
-    // Output:
-    // true
-    // true
-    // true
-    // false
-}
-```
-
-### <span id="LessThan">LessThan</span>
-
-<p>Checks if value `left` less than value `right`.</p>
-
-<b>Signature:</b>
-
-```go
-func LessThan(left, right any) bool
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/compare"
-)
-
-func main() {
-    result1 := compare.LessThan(1, 2)
-    result2 := compare.LessThan(1.1, 2.2)
-    result3 := compare.LessThan("a", "b")
-
-    time1 := time.Now()
-    time2 := time1.Add(time.Second)
-    result4 := compare.LessThan(time1, time2)
-
-    result5 := compare.LessThan(2, 1)
-    result6 := compare.LessThan(1, int64(2))
-
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
-    fmt.Println(result4)
-    fmt.Println(result5)
-    fmt.Println(result6)
-
-    // Output:
-    // true
-    // true
-    // true
-    // true
-    // false
-    // false
-}
-```
-
-### <span id="GreaterThan">GreaterThan</span>
-
-<p>Checks if value `left` greater than value `right`.</p>
-
-<b>Signature:</b>
-
-```go
-func GreaterThan(left, right any) bool
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/compare"
-)
-
-func main() {
-    result1 := compare.GreaterThan(2, 1)
-    result2 := compare.GreaterThan(2.2, 1.1)
-    result3 := compare.GreaterThan("b", "a")
-
-    time1 := time.Now()
-    time2 := time1.Add(time.Second)
-    result4 := compare.GreaterThan(time2, time1)
-
-    result5 := compare.GreaterThan(1, 2)
-    result6 := compare.GreaterThan(int64(2), 1)
-    result7 := compare.GreaterThan("b", "c")
-
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
-    fmt.Println(result4)
-    fmt.Println(result5)
-    fmt.Println(result6)
-    fmt.Println(result7)
-
-    // Output:
-    // true
-    // true
-    // true
-    // true
-    // false
-    // false
-    // false
-}
-```
-
-### <span id="LessOrEqual">LessOrEqual</span>
-
-<p>Checks if value `left` less than or equal than value `right`.</p>
-
-<b>Signature:</b>
-
-```go
-func LessOrEqual(left, right any) bool
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/compare"
-)
-
-func main() {
-    result1 := compare.LessOrEqual(1, 1)
-    result2 := compare.LessOrEqual(1.1, 2.2)
-    result3 := compare.LessOrEqual("a", "b")
-
-    time1 := time.Now()
-    time2 := time1.Add(time.Second)
-    result4 := compare.LessOrEqual(time1, time2)
-
-    result5 := compare.LessOrEqual(2, 1)
-    result6 := compare.LessOrEqual(1, int64(2))
-
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
-    fmt.Println(result4)
-    fmt.Println(result5)
-    fmt.Println(result6)
-
-    // Output:
-    // true
-    // true
-    // true
-    // true
-    // false
-    // false
-}
-```
-
-### <span id="GreaterOrEqual">GreaterOrEqual</span>
-
-<p>Checks if value `left` less greater or equal than value `right`.</p>
-
-<b>Signature:</b>
-
-```go
-func GreaterOrEqual(left, right any) bool
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/compare"
-)
-
-func main() {
-    result1 := compare.GreaterOrEqual(1, 1)
-    result2 := compare.GreaterOrEqual(2.2, 1.1)
-    result3 := compare.GreaterOrEqual("b", "b")
-
-    time1 := time.Now()
-    time2 := time1.Add(time.Second)
-    result4 := compare.GreaterOrEqual(time2, time1)
-
-    result5 := compare.GreaterOrEqual(1, 2)
-    result6 := compare.GreaterOrEqual(int64(2), 1)
-    result7 := compare.GreaterOrEqual("b", "c")
-
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
-    fmt.Println(result4)
-    fmt.Println(result5)
-    fmt.Println(result6)
-    fmt.Println(result7)
-
-    // Output:
-    // true
-    // true
-    // true
-    // true
-    // false
-    // false
-    // false
-}
-```

docs/compare_zh-CN.md

@@ -1,326 +0,0 @@
-# Compare
-
-compare包提供几个轻量级的类型比较函数。
-
-<div STYLE="page-break-after: always;"></div>
-
-## 源码:
-
--   [https://github.com/duke-git/lancet/blob/main/compare/compare.go](https://github.com/duke-git/lancet/blob/main/compare/compare.go)
-
--   [https://github.com/duke-git/lancet/blob/main/compare/compare_internal.go](https://github.com/duke-git/lancet/blob/main/compare/compare_internal.go)
-
-<div STYLE="page-break-after: always;"></div>
-
-## 用法:
-
-```go
-import (
-    "github.com/duke-git/lancet/v2/condition"
-)
-```
-
-<div STYLE="page-break-after: always;"></div>
-
-## 目录
-
--   [Equal](#Equal)
--   [EqualValue](#EqualValue)
--   [LessThan](#LessThan)
--   [GreaterThan](#GreaterThan)
--   [LessOrEqual](#LessOrEqual)
--   [GreaterOrEqual](#GreaterOrEqual)
-
-<div STYLE="page-break-after: always;"></div>
-
-## Documentation
-
-### <span id="Equal">Equal</span>
-
-<p>检查两个值是否相等(检查类型和值)</p>
-
-<b>函数签名:</b>
-
-```go
-func Equal(left, right any) bool
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/compare"
-)
-
-func main() {
-    result1 := compare.Equal(1, 1)
-    result2 := compare.Equal("1", "1")
-    result3 := compare.Equal([]int{1, 2, 3}, []int{1, 2, 3})
-    result4 := compare.Equal(map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "b"})
-
-    result5 := compare.Equal(1, "1")
-    result6 := compare.Equal(1, int64(1))
-    result7 := compare.Equal([]int{1, 2}, []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:
-    // true
-    // true
-    // true
-    // true
-    // false
-    // false
-    // false
-}
-```
-
-### <span id="EqualValue">EqualValue</span>
-
-<p>检查两个值是否相等(只检查值)</p>
-
-<b>函数签名:</b>
-
-```go
-func EqualValue(left, right any) bool
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/compare"
-)
-
-func main() {
-    result1 := compare.EqualValue(1, 1)
-    result2 := compare.EqualValue(int(1), int64(1))
-    result3 := compare.EqualValue(1, "1")
-    result4 := compare.EqualValue(1, "2")
-
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
-    fmt.Println(result4)
-
-    // Output:
-    // true
-    // true
-    // true
-    // false
-}
-```
-
-### <span id="LessThan">LessThan</span>
-
-<p>验证参数`left`的值是否小于参数`right`的值。</p>
-
-<b>函数签名:</b>
-
-```go
-func LessThan(left, right any) bool
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/compare"
-)
-
-func main() {
-    result1 := compare.LessThan(1, 2)
-    result2 := compare.LessThan(1.1, 2.2)
-    result3 := compare.LessThan("a", "b")
-
-    time1 := time.Now()
-    time2 := time1.Add(time.Second)
-    result4 := compare.LessThan(time1, time2)
-
-    result5 := compare.LessThan(2, 1)
-    result6 := compare.LessThan(1, int64(2))
-
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
-    fmt.Println(result4)
-    fmt.Println(result5)
-    fmt.Println(result6)
-
-    // Output:
-    // true
-    // true
-    // true
-    // true
-    // false
-    // false
-}
-```
-
-### <span id="GreaterThan">GreaterThan</span>
-
-<p>验证参数`left`的值是否大于参数`right`的值。</p>
-
-<b>函数签名:</b>
-
-```go
-func GreaterThan(left, right any) bool
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/compare"
-)
-
-func main() {
-    result1 := compare.GreaterThan(2, 1)
-    result2 := compare.GreaterThan(2.2, 1.1)
-    result3 := compare.GreaterThan("b", "a")
-
-    time1 := time.Now()
-    time2 := time1.Add(time.Second)
-    result4 := compare.GreaterThan(time2, time1)
-
-    result5 := compare.GreaterThan(1, 2)
-    result6 := compare.GreaterThan(int64(2), 1)
-    result7 := compare.GreaterThan("b", "c")
-
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
-    fmt.Println(result4)
-    fmt.Println(result5)
-    fmt.Println(result6)
-    fmt.Println(result7)
-
-    // Output:
-    // true
-    // true
-    // true
-    // true
-    // false
-    // false
-    // false
-}
-```
-
-### <span id="LessOrEqual">LessOrEqual</span>
-
-<p>验证参数`left`的值是否小于或等于参数`right`的值。</p>
-
-<b>函数签名:</b>
-
-```go
-func LessOrEqual(left, right any) bool
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/compare"
-)
-
-func main() {
-    result1 := compare.LessOrEqual(1, 1)
-    result2 := compare.LessOrEqual(1.1, 2.2)
-    result3 := compare.LessOrEqual("a", "b")
-
-    time1 := time.Now()
-    time2 := time1.Add(time.Second)
-    result4 := compare.LessOrEqual(time1, time2)
-
-    result5 := compare.LessOrEqual(2, 1)
-    result6 := compare.LessOrEqual(1, int64(2))
-
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
-    fmt.Println(result4)
-    fmt.Println(result5)
-    fmt.Println(result6)
-
-    // Output:
-    // true
-    // true
-    // true
-    // true
-    // false
-    // false
-}
-```
-
-### <span id="GreaterOrEqual">GreaterOrEqual</span>
-
-<p>验证参数`left`的值是否大于或参数`right`的值。</p>
-
-<b>函数签名:</b>
-
-```go
-func GreaterOrEqual(left, right any) bool
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/compare"
-)
-
-func main() {
-    result1 := compare.GreaterOrEqual(1, 1)
-    result2 := compare.GreaterOrEqual(2.2, 1.1)
-    result3 := compare.GreaterOrEqual("b", "b")
-
-    time1 := time.Now()
-    time2 := time1.Add(time.Second)
-    result4 := compare.GreaterOrEqual(time2, time1)
-
-    result5 := compare.GreaterOrEqual(1, 2)
-    result6 := compare.GreaterOrEqual(int64(2), 1)
-    result7 := compare.GreaterOrEqual("b", "c")
-
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
-    fmt.Println(result4)
-    fmt.Println(result5)
-    fmt.Println(result6)
-    fmt.Println(result7)
-
-    // Output:
-    // true
-    // true
-    // true
-    // true
-    // false
-    // false
-    // false
-}
-```

docs/concurrency.md

@@ -1,441 +0,0 @@
-# Concurrency
-Package concurrency contain some functions to support concurrent programming. eg, goroutine, channel.
-
-<div STYLE="page-break-after: always;"></div>
-
-## Source:
-
-- [https://github.com/duke-git/lancet/blob/main/concurrency/channel.go](https://github.com/duke-git/lancet/blob/main/concurrency/channel.go)
-
-<div STYLE="page-break-after: always;"></div>
-
-## Usage:
-```go
-import (
-    "github.com/duke-git/lancet/v2/concurrency"
-)
-```
-
-<div STYLE="page-break-after: always;"></div>
-
-## Index
-### Channel
-- [NewChannel](#NewChannel)
-- [Bridge](#Bridge)
-- [FanIn](#FanIn)
-- [Generate](#Generate)
-- [Or](#Or)
-- [OrDone](#OrDone)
-- [Repeat](#Repeat)
-- [RepeatFn](#RepeatFn)
-- [Take](#Take)
-- [Tee](#Tee)
-
-<div STYLE="page-break-after: always;"></div>
-
-## Documentation
-
-
-## Channel
-### <span id="NewChannel">NewChannel</span>
-<p>Create a Channel pointer instance.</p>
-
-<b>Signature:</b>
-
-```go
-type Channel[T any] struct
-func NewChannel[T any]() *Channel[T]
-```
-<b>Example:</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>Link multiple channels into one channel until cancel the context.</p>
-
-<b>Signature:</b>
-
-```go
-func (c *Channel[T]) Bridge(ctx context.Context, chanStream <-chan <-chan T) <-chan T
-```
-<b>Example:</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>Merge multiple channels into one channel until cancel the context.</p>
-
-<b>Signature:</b>
-
-```go
-func (c *Channel[T]) FanIn(ctx context.Context, channels ...<-chan T) <-chan T
-```
-<b>Example:</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="Repeat">Repeat</span>
-
-<p>Create channel, put values into the channel repeatly until cancel the context.</p>
-
-<b>Signature:</b>
-
-```go
-func (c *Channel[T]) Repeat(ctx context.Context, values ...T) <-chan T
-```
-<b>Example:</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="Generate">Generate</span>
-
-<p>Creates a channel, then put values into the channel.</p>
-
-<b>Signature:</b>
-
-```go
-func (c *Channel[T]) Generate(ctx context.Context, values ...T) <-chan T
-```
-<b>Example:</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="RepeatFn">RepeatFn</span>
-
-<p>Create a channel, excutes fn repeatly, and put the result into the channel, until close context.</p>
-
-<b>Signature:</b>
-
-```go
-func (c *Channel[T]) RepeatFn(ctx context.Context, fn func() T) <-chan T
-```
-<b>Example:</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>Read one or more channels into one channel, will close when any readin channel is closed.</p>
-
-<b>Signature:</b>
-
-```go
-func (c *Channel[T]) Or(channels ...<-chan T) <-chan T
-```
-<b>Example:</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>Read a channel into another channel, will close until cancel context.</p>
-
-<b>Signature:</b>
-
-```go
-func (c *Channel[T]) OrDone(ctx context.Context, channel <-chan T) <-chan T
-```
-<b>Example:</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>Create a channel whose values are taken from another channel with limit number.</p>
-
-<b>Signature:</b>
-
-```go
-func (c *Channel[T]) Take(ctx context.Context, valueStream <-chan T, number int) <-chan T
-```
-<b>Example:</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>Split one chanel into two channels, until cancel the context.</p>
-
-<b>Signature:</b>
-
-```go
-func (c *Channel[T]) Tee(ctx context.Context, in <-chan T) (<-chan T, <-chan T)
-```
-<b>Example:</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
-}
-```

docs/concurrency_zh-CN.md

@@ -1,439 +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)
-
-<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)
-
-<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>示例:</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>示例:</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>示例:</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>示例:</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>示例:</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>示例:</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>示例:</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>示例:</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>示例:</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>示例:</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
-}
-```

docs/condition.md

@@ -1,310 +0,0 @@
-# Condition
-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.
-
-<div STYLE="page-break-after: always;"></div>
-
-## Source:
-
-- [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>
-
-## Usage:
-```go
-import (
-    "github.com/duke-git/lancet/v2/condition"
-)
-```
-
-<div STYLE="page-break-after: always;"></div>
-
-## Index
-
-- [Bool](#Bool)
-- [And](#And)
-- [Or](#Or)
-- [Xor](#Generate)
-- [Nor](#Nor)
-- [Xnor](#Xnor)
-- [Nand](#Nand)
-- [TernaryOperator](#TernaryOperator)
-
-<div STYLE="page-break-after: always;"></div>
-
-## Documentation
-
-
-### <span id="Bool">Bool</span>
-<p>Returns the truthy value of anything.<br/>
-If the value's type has a Bool() bool method, the method is called and returned.<br/>
-If the type has an IsZero() bool method, the opposite value is returned.<br/>
-Slices and maps are truthy if they have a length greater than zero.<br/>
-All other types are truthy if they are not their zero value.</p>
-
-<b>Signature:</b>
-
-```go
-func Bool[T any](value T) bool
-```
-<b>Example:</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>Returns true if both a and b are truthy.</p>
-
-<b>Signature:</b>
-
-```go
-func And[T, U any](a T, b U) bool
-```
-<b>Example:</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>Returns false if neither a nor b is truthy.</p>
-
-<b>Signature:</b>
-
-```go
-func Or[T, U any](a T, b U) bool
-```
-<b>Example:</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>Returns true if a or b but not both is truthy.</p>
-
-<b>Signature:</b>
-
-```go
-func Xor[T, U any](a T, b U) bool
-```
-<b>Example:</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>Returns true if neither a nor b is truthy.</p>
-
-<b>Signature:</b>
-
-```go
-func Nor[T, U any](a T, b U) bool
-```
-<b>Example:</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>Returns true if both a and b or neither a nor b are truthy.</p>
-
-<b>Signature:</b>
-
-```go
-func Xnor[T, U any](a T, b U) bool
-```
-<b>Example:</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>Returns false if both a and b are truthy</p>
-
-<b>Signature:</b>
-
-```go
-func Nand[T, U any](a T, b U) bool
-```
-<b>Example:</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="TernaryOperator">TernaryOperator</span>
-<p>Checks the value of param `isTrue`, if true return ifValue else return elseValue</p>
-
-<b>Signature:</b>
-
-```go
-func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U
-```
-<b>Example:</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/condition_zh-CN.md

@@ -1,298 +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>
-
-## Index
-
-- [Bool](#Bool)
-- [And](#And)
-- [Or](#Or)
-- [Xor](#Generate)
-- [Nor](#Nor)
-- [Xnor](#Xnor)
-- [Nand](#Nand)
-- [TernaryOperator](#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>示例:</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>示例:</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>示例:</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>示例:</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>示例:</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>示例:</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>示例:</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="TernaryOperator">TernaryOperator</span>
-<p>三元运算符</p>
-
-<b>函数签名:</b>
-
-```go
-func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U
-```
-<b>示例:</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/convertor.md

@@ -1,55 +1,41 @@
 # Convertor
-
 Package convertor contains some functions for data type convertion.
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Source:
 
--   [https://github.com/duke-git/lancet/blob/main/convertor/convertor.go](https://github.com/duke-git/lancet/blob/main/convertor/convertor.go)
+[https://github.com/duke-git/lancet/blob/v1/convertor/convertor.go](https://github.com/duke-git/lancet/blob/v1/convertor/convertor.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Usage:
-
 ```go
 import (
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 ```
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Index
-
--   [ColorHexToRGB](#ColorHexToRGB)
--   [ColorRGBToHex](#ColorRGBToHex)
--   [ToBool](#ToBool)
--   [ToBytes](#ToBytes)
--   [ToChar](#ToChar)
--   [ToChannel](#ToChannel)
--   [ToFloat](#ToFloat)
--   [ToInt](#ToInt)
--   [ToJson](#ToJson)
--   [ToMap](#ToMap)
--   [ToPointer](#ToPointer)
--   [ToString](#ToString)
--   [StructToMap](#StructToMap)
--   [MapToSlice](#MapToSlice)
--   [EncodeByte](#EncodeByte)
--   [DecodeByte](#DecodeByte)
--   [DeepClone](#DeepClone)
--   [CopyProperties](#CopyProperties)
--   [ToInterface](#ToInterface)
--   [Utf8ToGbk](#Utf8ToGbk)
--   [GbkToUtf8](#GbkToUtf8)
+- [ColorHexToRGB](#ColorHexToRGB)
+- [ColorRGBToHex](#ColorRGBToHex)
+- [ToBool](#ToBool)
+- [ToBytes](#ToBytes)
+- [ToChar](#ToChar)
+- [ToInt](#ToInt)
+- [ToJson](#ToJson)
+- [ToString](#ToString)
+- [StructToMap](#StructToMap)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Documentation
 
-### <span id="ColorHexToRGB">ColorHexToRGB</span>
 
+
+### <span id="ColorHexToRGB">ColorHexToRGB</span>
 <p>Convert color hex to color rgb.</p>
 
 <b>Signature:</b>
@@ -57,7 +43,6 @@ import (
 ```go
 func ColorHexToRGB(colorHex string) (red, green, blue int)
 ```
-
 <b>Example:</b>
 
 ```go
@@ -65,20 +50,18 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
     colorHex := "#003366"
-    r, g, b := convertor.ColorHexToRGB(colorHex)
-
-    fmt.Println(r, g, b)
-
-    // Output:
-    // 0 51 102
+    r, g, b := ColorHexToRGB(colorHex)
+    fmt.Println(r, g, b) //0,51,102
 }
 ```
 
+
+
 ### <span id="ColorRGBToHex">ColorRGBToHex</span>
 
 <p>Convert color rgb to color hex.</p>
@@ -88,7 +71,6 @@ func main() {
 ```go
 func ColorRGBToHex(red, green, blue int) string
 ```
-
 <b>Example:</b>
 
 ```go
@@ -96,7 +78,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
@@ -105,23 +87,21 @@ func main() {
     b := 102
     colorHex := ColorRGBToHex(r, g, b)
 
-    fmt.Println(colorHex)
-
-    // Output:
-    // #003366
+    fmt.Println(colorHex) //#003366
 }
 ```
 
+
+
 ### <span id="ToBool">ToBool</span>
 
-<p>Convert string to bool. Use strconv.ParseBool.</p>
+<p>Convert string to a boolean value. Use strconv.ParseBool</p>
 
 <b>Signature:</b>
 
 ```go
 func ToBool(s string) (bool, error)
 ```
-
 <b>Example:</b>
 
 ```go
@@ -129,40 +109,35 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
-    cases := []string{"1", "true", "True", "false", "False", "0", "123", "0.0", "abc"}
+    v1, _ := convertor.ToBool("1")
+    fmt.Println(v1) //true
 
-    for i := 0; i < len(cases); i++ {
-        result, _ := convertor.ToBool(cases[i])
-        fmt.Println(result)
-    }
+    v2, _ := convertor.ToBool("true")
+    fmt.Println(v2) //true
 
-    // Output:
-    // true
-    // true
-    // true
-    // false
-    // false
-    // false
-    // false
-    // false
-    // false
+    v3, _ := convertor.ToBool("True")
+    fmt.Println(v3) //true
+
+    v4, _ := convertor.ToBool("123")
+    fmt.Println(v4) //false
 }
 ```
 
+
+
 ### <span id="ToBytes">ToBytes</span>
 
-<p>Convert value to byte slice.</p>
+<p>Convert interface to byte slice.</p>
 
 <b>Signature:</b>
 
 ```go
-func ToBytes(data any) ([]byte, error)
+func ToBytes(data interface{}) ([]byte, error)
 ```
-
 <b>Example:</b>
 
 ```go
@@ -170,22 +145,20 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
-    bytesData, err := convertor.ToBytes("abc")
+    bytesData, err := convertor.ToBytes("0")
     if err != nil {
         fmt.Println(err)
     }
-
-    fmt.Println(bytesData)
-
-    // Output:
-    // [97 98 99]
+    fmt.Println(bytesData) //[]bytes{3, 4, 0, 0}
 }
 ```
 
+
+
 ### <span id="ToChar">ToChar</span>
 
 <p>Convert string to char slice.</p>
@@ -195,7 +168,6 @@ func main() {
 ```go
 func ToChar(s string) []string
 ```
-
 <b>Example:</b>
 
 ```go
@@ -203,72 +175,32 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
-    result1 := convertor.ToChar("")
-    result2 := convertor.ToChar("abc")
-    result3 := convertor.ToChar("1 2#3")
+    chars := convertor.ToChar("")
+    fmt.Println(chars) //[]string{""}
 
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
+    chars = convertor.ToChar("abc")
+    fmt.Println(chars) //[]string{"a", "b", "c"}
 
-    // Output:
-    // []
-    // [a b c]
-    // [1   2 # 3]
+    chars = convertor.ToChar("1 2#3")
+    fmt.Println(chars) //[]string{"1", " ", "2", "#", "3"}
 }
 ```
 
-### <span id="ToChannel">ToChannel</span>
 
-<p>Convert a collection of elements to a read-only channel.</p>
-
-<b>Signature:</b>
-
-```go
-func ToChannel[T any](array []T) <-chan T
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    ch := convertor.ToChannel([]int{1, 2, 3})
-    result1 := <-ch
-    result2 := <-ch
-    result3 := <-ch
-
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
-
-    // Output:
-    // 1
-    // 2
-    // 3
-}
-```
 
 ### <span id="ToFloat">ToFloat</span>
 
-<p>Convert value to a float64 value. If param is a invalid floatable, will return 0.0 and error. </p>
+<p>Convert interface to a float64 value. If param is a invalid floatable, will return 0 and error. </p>
 
 <b>Signature:</b>
 
 ```go
-func ToFloat(value any) (float64, error)
+func ToFloat(value interface{}) (float64, error)
 ```
-
 <b>Example:</b>
 
 ```go
@@ -276,44 +208,32 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
-    result1, _ := convertor.ToFloat("")
-    result2, err := convertor.ToFloat("abc")
-    result3, _ := convertor.ToFloat("-1")
-    result4, _ := convertor.ToFloat("-.11")
-    result5, _ := convertor.ToFloat("1.23e3")
-    result6, _ := convertor.ToFloat(true)
+    v, err := convertor.ToFloat("")
+    if err != nil {
+        fmt.Println(err) //strconv.ParseFloat: parsing "": invalid syntax
+    }
+    fmt.Println(v) //0
 
-    fmt.Println(result1)
-    fmt.Println(result2, err)
-    fmt.Println(result3)
-    fmt.Println(result4)
-    fmt.Println(result5)
-    fmt.Println(result6)
-
-    // Output:
-    // 0
-    // 0 strconv.ParseFloat: parsing "": invalid syntax
-    // -1
-    // -0.11
-    // 1230
-    // 0
+    v, _ = convertor.ToFloat("-.11")
+    fmt.Println(v) //-0.11
 }
 ```
 
+
+
 ### <span id="ToInt">ToInt</span>
 
-<p>Convert value to a int64 value. If param is a invalid intable, will return 0 and error. </p>
+<p>Convert interface to a int64 value. If param is a invalid intable, will return 0 and error. </p>
 
 <b>Signature:</b>
 
 ```go
-func ToInt(value any) (int64, error)
+func ToInt(value interface{}) (int64, error)
 ```
-
 <b>Example:</b>
 
 ```go
@@ -321,31 +241,23 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
-    result1, _ := convertor.ToInt("123")
-    result2, _ := convertor.ToInt("-123")
-    result3, _ := convertor.ToInt(float64(12.3))
-    result4, err := convertor.ToInt("abc")
-    result5, _ := convertor.ToInt(true)
+    v, err := convertor.ToInt("")
+    if err != nil {
+        fmt.Println(err) //strconv.ParseInt: parsing "": invalid syntax
+    }
+    fmt.Println(v) //0
 
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
-    fmt.Println(result4, err)
-    fmt.Println(result5)
-
-    // Output:
-    // 123
-    // -123
-    // 12
-    // 0 strconv.ParseInt: parsing "": invalid syntax
-    // 0
+    v, _ = convertor.ToFloat(1.12)
+    fmt.Println(v) //1
 }
 ```
 
+
+
 ### <span id="ToJson">ToJson</span>
 
 <p>Convert interface to json string. If param can't be converted, will return "" and error. </p>
@@ -353,9 +265,8 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func ToJson(value any) (string, error)
+func ToJson(value interface{}) (string, error)
 ```
-
 <b>Example:</b>
 
 ```go
@@ -363,104 +274,27 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
-    aMap := map[string]int{"a": 1, "b": 2, "c": 3}
-    result, err := ToJson(aMap)
-
-    if err != nil {
-        fmt.Printf("%v", err)
-    }
-
-    fmt.Println(result)
-
-    // Output:
-    // {"a":1,"b":2,"c":3}
+    var aMap = map[string]int{"a": 1, "b": 2, "c": 3}
+    jsonStr, _ := convertor.ToJson(aMap)
+    fmt.Printf("%q", jsonStr) //"{\"a\":1,\"b\":2,\"c\":3}"
 }
 ```
 
-### <span id="ToMap">ToMap</span>
 
-<p>Convert a slice of structs to a map based on iteratee function. </p>
-
-<b>Signature:</b>
-
-```go
-func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K]V
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    type Message struct {
-        name string
-        code int
-    }
-    messages := []Message{
-        {name: "Hello", code: 100},
-        {name: "Hi", code: 101},
-    }
-
-    result := convertor.ToMap(messages, func(msg Message) (int, string) {
-        return msg.code, msg.name
-    })
-
-    fmt.Println(result)
-
-    // Output:
-    // map[100:Hello 101:Hi]
-}
-```
-
-### <span id="ToPointer">ToPointer</span>
-
-<p>Returns a pointer to passed value. </p>
-
-<b>Signature:</b>
-
-```go
-func ToPointer[T any](value T) *T
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    result := convertor.ToPointer(123)
-    fmt.Println(*result)
-
-    // Output:
-    // 123
-}
-```
 
 ### <span id="ToString">ToString</span>
 
-<p>ToString convert value to string, for number, string, []byte, will convert to string. For other type (slice, map, array, struct) will call json.Marshal</p>
+<p>Convert interface to string. </p>
 
 <b>Signature:</b>
 
 ```go
-func ToString(value any) string
+func ToString(value interface{}) string
 ```
-
 <b>Example:</b>
 
 ```go
@@ -468,37 +302,18 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
-    result1 := convertor.ToString("")
-    result2 := convertor.ToString(nil)
-    result3 := convertor.ToString(0)
-    result4 := convertor.ToString(1.23)
-    result5 := convertor.ToString(true)
-    result6 := convertor.ToString(false)
-    result7 := convertor.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]
+    fmt.Printf("%q", convertor.ToString(1)) //"1"
+    fmt.Printf("%q", convertor.ToString(1.1)) //"1.1"
+    fmt.Printf("%q", convertor.ToString([]int{1, 2, 3})) //"[1,2,3]"
 }
 ```
 
+
+
 ### <span id="StructToMap">StructToMap</span>
 
 <p>Convert struct to map, only convert exported field, struct field tag `json` should be set.</p>
@@ -506,9 +321,8 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func StructToMap(value any) (map[string]any, error)
+func StructToMap(value interface{}) (map[string]interface{}, error)
 ```
-
 <b>Example:</b>
 
 ```go
@@ -516,7 +330,7 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
@@ -530,349 +344,6 @@ func main() {
     }
     pm, _ := convertor.StructToMap(p)
 
-    fmt.Println(pm)
-
-    // Output:
-    // map[name:test]
-}
-```
-
-### <span id="MapToSlice">MapToSlice</span>
-
-<p>Convert a map to a slice based on iteratee function.</p>
-
-<b>Signature:</b>
-
-```go
-func MapToSlice[T any, K comparable, V any](aMap map[K]V, iteratee func(K, V) T) []T
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    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", "b:2", "c:3"}
-}
-```
-
-### <span id="EncodeByte">EncodeByte</span>
-
-<p>Encode data to byte slice.</p>
-
-<b>Signature:</b>
-
-```go
-func EncodeByte(data any) ([]byte, error)
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    byteData, _ := convertor.EncodeByte("abc")
-    fmt.Println(byteData)
-
-    // Output:
-    // [6 12 0 3 97 98 99]
-}
-```
-
-### <span id="DecodeByte">DecodeByte</span>
-
-<p>Decode byte data to target object. target should be a pointer instance.</p>
-
-<b>Signature:</b>
-
-```go
-func DecodeByte(data []byte, target any) error
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    var result string
-    byteData := []byte{6, 12, 0, 3, 97, 98, 99}
-
-    err := convertor.DecodeByte(byteData, &result)
-    if err != nil {
-        return
-    }
-
-    fmt.Println(result)
-
-    // Output:
-    // abc
-}
-```
-
-### <span id="DeepClone">DeepClone</span>
-
-<p>Creates a deep copy of passed item, can't clone unexported field of struct.</p>
-
-<b>Signature:</b>
-
-```go
-func DeepClone[T any](src T) T
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    type Struct struct {
-        Str        string
-        Int        int
-        Float      float64
-        Bool       bool
-        Nil        interface{}
-        unexported string
-    }
-
-    cases := []interface{}{
-        true,
-        1,
-        0.1,
-        map[string]int{
-            "a": 1,
-            "b": 2,
-        },
-        &Struct{
-            Str:   "test",
-            Int:   1,
-            Float: 0.1,
-            Bool:  true,
-            Nil:   nil,
-            // unexported: "can't be cloned",
-        },
-    }
-
-    for _, item := range cases {
-        cloned := convertor.DeepClone(item)
-
-        isPointerEqual := &cloned == &item
-        fmt.Println(cloned, isPointerEqual)
-    }
-
-    // Output:
-    // true false
-    // 1 false
-    // 0.1 false
-    // map[a:1 b:2] false
-    // &{test 1 0.1 true <nil> } false
-}
-```
-
-### <span id="CopyProperties">CopyProperties</span>
-
-<p>Copies each field from the source struct into the destination struct. Use json.Marshal/Unmarshal, so json tag should be set for fields of dst and src struct.</p>
-
-<b>Signature:</b>
-
-```go
-func CopyProperties[T, U any](dst T, src U) (err error)
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    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{}
-
-    err := convertor.CopyProperties(&indicatorVO, indicator)
-
-    if err != nil {
-        return
-    }
-
-    fmt.Println(indicatorVO.Id)
-    fmt.Println(indicatorVO.Ip)
-    fmt.Println(len(indicatorVO.Disk))
-
-    // Output:
-    // 001
-    // 127.0.0.1
-    // 3
-}
-```
-
-### <span id="ToInterface">ToInterface</span>
-
-<p>Converts reflect value to its interface type.</p>
-
-<b>Signature:</b>
-
-```go
-func ToInterface(v reflect.Value) (value interface{}, ok bool)
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    val := reflect.ValueOf("abc")
-    iVal, ok := convertor.ToInterface(val)
-
-    fmt.Printf("%T\n", iVal)
-    fmt.Printf("%v\n", iVal)
-    fmt.Println(ok)
-
-    // Output:
-    // string
-    // abc
-    // true    
-}
-```
-
-### <span id="Utf8ToGbk">Utf8ToGbk</span>
-
-<p>Converts utf8 encoding data to GBK encoding data.</p>
-
-<b>Signature:</b>
-
-```go
-func Utf8ToGbk(bs []byte) ([]byte, error)
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-    "github.com/duke-git/lancet/v2/validator"
-)
-
-func main() {
-    utf8Data := []byte("hello")
-    gbkData, _ := convertor.Utf8ToGbk(utf8Data)
-
-    fmt.Println(utf8.Valid(utf8Data))
-    fmt.Println(validator.IsGBK(gbkData))
-
-    // Output:
-    // true
-    // true   
-}
-```
-
-### <span id="GbkToUtf8">GbkToUtf8</span>
-
-<p>Converts GBK encoding data to utf8 encoding data.</p>
-
-<b>Signature:</b>
-
-```go
-func GbkToUtf8(bs []byte) ([]byte, error)
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    gbkData, _ := convertor.Utf8ToGbk([]byte("hello"))
-    utf8Data, _ := convertor.GbkToUtf8(gbkData)
-
-    fmt.Println(utf8.Valid(utf8Data))
-    fmt.Println(string(utf8Data))
-
-    // Output:
-    // true
-    // hello   
+    fmt.Printf("type: %T, value: %s", pm, pm) //type: map[string]interface {}, value: map[name:test]
 }
 ```

docs/convertor_zh-CN.md

@@ -1,12 +1,11 @@
 # Convertor
-
-convertor 转换器包支持一些常见的数据类型转换
+convertor转换器包支持一些常见的数据类型转换
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 源码:
 
--   [https://github.com/duke-git/lancet/blob/main/convertor/convertor.go](https://github.com/duke-git/lancet/blob/main/convertor/convertor.go)
+[https://github.com/duke-git/lancet/blob/v1/convertor/convertor.go](https://github.com/duke-git/lancet/blob/v1/convertor/convertor.go)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -14,7 +13,7 @@ convertor 转换器包支持一些常见的数据类型转换
 
 ```go
 import (
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 ```
 
@@ -22,81 +21,66 @@ import (
 
 ## 目录
 
--   [ColorHexToRGB](#ColorHexToRGB)
--   [ColorRGBToHex](#ColorRGBToHex)
--   [ToBool](#ToBool)
--   [ToBytes](#ToBytes)
--   [ToChar](#ToChar)
--   [ToChannel](#ToChannel)
--   [ToFloat](#ToFloat)
--   [ToInt](#ToInt)
--   [ToJson](#ToJson)
--   [ToMap](#ToMap)
--   [ToPointer](#ToPointer)
--   [ToString](#ToString)
--   [StructToMap](#StructToMap)
--   [MapToSlice](#MapToSlice)
--   [EncodeByte](#EncodeByte)
--   [DecodeByte](#DecodeByte)
--   [DeepClone](#DeepClone)
--   [CopyProperties](#CopyProperties)
--   [ToInterface](#ToInterface)
--   [Utf8ToGbk](#Utf8ToGbk)
--   [GbkToUtf8](#GbkToUtf8)
+- [ColorHexToRGB](#ColorHexToRGB)
+- [ColorRGBToHex](#ColorRGBToHex)
+- [ToBool](#ToBool)
+- [ToBytes](#ToBytes)
+- [ToChar](#ToChar)
+- [ToInt](#ToInt)
+- [ToJson](#ToJson)
+- [ToString](#ToString)
+- [StructToMap](#StructToMap)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 文档
 
-### <span id="ColorHexToRGB">ColorHexToRGB</span>
 
-<p>颜色值十六进制转rgb。</p>
+
+### <span id="ColorHexToRGB">ColorHexToRGB</span>
+<p>颜色值十六进制转rgb</p>
 
 <b>函数签名:</b>
 
 ```go
 func ColorHexToRGB(colorHex string) (red, green, blue int)
 ```
-
-<b>示例:</b>
+<b>列子:</b>
 
 ```go
 package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
     colorHex := "#003366"
-    r, g, b := convertor.ColorHexToRGB(colorHex)
-
-    fmt.Println(r, g, b)
-
-    // Output:
-    // 0 51 102
+    r, g, b := ColorHexToRGB(colorHex)
+    fmt.Println(r, g, b) //0,51,102
 }
 ```
 
+
+
 ### <span id="ColorRGBToHex">ColorRGBToHex</span>
 
-<p>颜色值rgb转十六进制。</p>
+<p>颜色值rgb转十六进制</p>
 
 <b>函数签名:</b>
 
 ```go
 func ColorRGBToHex(red, green, blue int) string
 ```
-
-<b>示例:</b>
+<b>列子:</b>
 
 ```go
 package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
@@ -105,418 +89,250 @@ func main() {
     b := 102
     colorHex := ColorRGBToHex(r, g, b)
 
-    fmt.Println(colorHex)
-
-    // Output:
-    // #003366
+    fmt.Println(colorHex) //#003366
 }
 ```
 
+
+
 ### <span id="ToBool">ToBool</span>
 
-<p>字符串转布尔类型，使用strconv.ParseBool。</p>
+<p>字符串转布尔类型，使用strconv.ParseBool</p>
 
 <b>函数签名:</b>
 
 ```go
 func ToBool(s string) (bool, error)
 ```
-
-<b>示例:</b>
+<b>列子:</b>
 
 ```go
 package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
-    cases := []string{"1", "true", "True", "false", "False", "0", "123", "0.0", "abc"}
+    v1, _ := convertor.ToBool("1")
+    fmt.Println(v1) //true
 
-    for i := 0; i < len(cases); i++ {
-        result, _ := convertor.ToBool(cases[i])
-        fmt.Println(result)
-    }
+    v2, _ := convertor.ToBool("true")
+    fmt.Println(v2) //true
 
-    // Output:
-    // true
-    // true
-    // true
-    // false
-    // false
-    // false
-    // false
-    // false
-    // false
+    v3, _ := convertor.ToBool("True")
+    fmt.Println(v3) //true
+
+    v4, _ := convertor.ToBool("123")
+    fmt.Println(v4) //false
 }
 ```
 
+
+
 ### <span id="ToBytes">ToBytes</span>
 
-<p>Interface转字节切片。</p>
+<p>interface转字节切片.</p>
 
 <b>函数签名:</b>
 
 ```go
-func ToBytes(data any) ([]byte, error)
+func ToBytes(data interface{}) ([]byte, error)
 ```
-
-<b>示例:</b>
+<b>列子:</b>
 
 ```go
 package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
-    bytesData, err := convertor.ToBytes("abc")
+    bytesData, err := convertor.ToBytes("0")
     if err != nil {
         fmt.Println(err)
     }
-
-    fmt.Println(bytesData)
-
-    // Output:
-    // [97 98 99]
+    fmt.Println(bytesData) //[]bytes{3, 4, 0, 0}
 }
 ```
 
+
+
 ### <span id="ToChar">ToChar</span>
 
-<p>字符串转字符切片。</p>
+<p>字符串转字符切片</p>
 
 <b>函数签名:</b>
 
 ```go
 func ToChar(s string) []string
 ```
-
-<b>示例:</b>
+<b>列子:</b>
 
 ```go
 package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
-    result1 := convertor.ToChar("")
-    result2 := convertor.ToChar("abc")
-    result3 := convertor.ToChar("1 2#3")
+    chars := convertor.ToChar("")
+    fmt.Println(chars) //[]string{""}
 
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
+    chars = convertor.ToChar("abc")
+    fmt.Println(chars) //[]string{"a", "b", "c"}
 
-    // Output:
-    // []
-    // [a b c]
-    // [1   2 # 3]
+    chars = convertor.ToChar("1 2#3")
+    fmt.Println(chars) //[]string{"1", " ", "2", "#", "3"}
 }
 ```
 
-### <span id="ToChannel">ToChannel</span>
 
-<p>将切片转为只读channel。</p>
-
-<b>函数签名:</b>
-
-```go
-func ToChannel[T any](array []T) <-chan T
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    ch := convertor.ToChannel([]int{1, 2, 3})
-    result1 := <-ch
-    result2 := <-ch
-    result3 := <-ch
-
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
-
-    // Output:
-    // 1
-    // 2
-    // 3
-}
-```
 
 ### <span id="ToFloat">ToFloat</span>
 
-<p>将interface转成float64类型，如果参数无法转换，会返回0和error。</p>
+<p>将interface转成float64类型，如果参数无法转换，会返回0和error</p>
 
 <b>函数签名:</b>
 
 ```go
-func ToFloat(value any) (float64, error)
+func ToFloat(value interface{}) (float64, error)
 ```
-
-<b>示例:</b>
+<b>列子:</b>
 
 ```go
 package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
-    result1, _ := convertor.ToFloat("")
-    result2, err := convertor.ToFloat("abc")
-    result3, _ := convertor.ToFloat("-1")
-    result4, _ := convertor.ToFloat("-.11")
-    result5, _ := convertor.ToFloat("1.23e3")
-    result6, _ := convertor.ToFloat(true)
+    v, err := convertor.ToFloat("")
+    if err != nil {
+        fmt.Println(err) //strconv.ParseFloat: parsing "": invalid syntax
+    }
+    fmt.Println(v) //0
 
-    fmt.Println(result1)
-    fmt.Println(result2, err)
-    fmt.Println(result3)
-    fmt.Println(result4)
-    fmt.Println(result5)
-    fmt.Println(result6)
-
-    // Output:
-    // 0
-    // 0 strconv.ParseFloat: parsing "": invalid syntax
-    // -1
-    // -0.11
-    // 1230
-    // 0
+    v, _ = convertor.ToFloat("-.11")
+    fmt.Println(v) //-0.11
 }
 ```
 
+
+
 ### <span id="ToInt">ToInt</span>
 
-<p>将interface转成int64类型，如果参数无法转换，会返回0和error。</p>
+<p>将interface转成intt64类型，如果参数无法转换，会返回0和error</p>
 
 <b>函数签名:</b>
 
 ```go
-func ToInt(value any) (int64, error)
+func ToInt(value interface{}) (int64, error)
 ```
-
-<b>示例:</b>
+<b>例子:</b>
 
 ```go
 package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
-    result1, _ := convertor.ToInt("123")
-    result2, _ := convertor.ToInt("-123")
-    result3, _ := convertor.ToInt(float64(12.3))
-    result4, err := convertor.ToInt("abc")
-    result5, _ := convertor.ToInt(true)
+    v, err := convertor.ToInt("")
+    if err != nil {
+        fmt.Println(err) //strconv.ParseInt: parsing "": invalid syntax
+    }
+    fmt.Println(v) //0
 
-    fmt.Println(result1)
-    fmt.Println(result2)
-    fmt.Println(result3)
-    fmt.Println(result4, err)
-    fmt.Println(result5)
-
-    // Output:
-    // 123
-    // -123
-    // 12
-    // 0 strconv.ParseInt: parsing "": invalid syntax
-    // 0
+    v, _ = convertor.ToFloat(1.12)
+    fmt.Println(v) //1
 }
 ```
 
+
+
 ### <span id="ToJson">ToJson</span>
 
-<p>将interface转成json字符串，如果参数无法转换，会返回""和error。</p>
+<p>将interface转成json字符串，如果参数无法转换，会返回""和error</p>
 
 <b>函数签名:</b>
 
 ```go
-func ToJson(value any) (string, error)
+func ToJson(value interface{}) (string, error)
 ```
-
-<b>示例:</b>
+<b>列子:</b>
 
 ```go
 package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
-    aMap := map[string]int{"a": 1, "b": 2, "c": 3}
-    result, err := ToJson(aMap)
-
-    if err != nil {
-        fmt.Printf("%v", err)
-    }
-
-    fmt.Println(result)
-
-    // Output:
-    // {"a":1,"b":2,"c":3}
+    var aMap = map[string]int{"a": 1, "b": 2, "c": 3}
+    jsonStr, _ := convertor.ToJson(aMap)
+    fmt.Printf("%q", jsonStr) //"{\"a\":1,\"b\":2,\"c\":3}"
 }
 ```
 
-### <span id="ToMap">ToMap</span>
 
-<p>将切片转为map。</p>
-
-<b>函数签名:</b>
-
-```go
-func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K]V
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    type Message struct {
-        name string
-        code int
-    }
-    messages := []Message{
-        {name: "Hello", code: 100},
-        {name: "Hi", code: 101},
-    }
-
-    result := convertor.ToMap(messages, func(msg Message) (int, string) {
-        return msg.code, msg.name
-    })
-
-    fmt.Println(result)
-
-    // Output:
-    // map[100:Hello 101:Hi]
-}
-```
-
-### <span id="ToPointer">ToPointer</span>
-
-<p>返回传入值的指针。</p>
-
-<b>函数签名:</b>
-
-```go
-func ToPointer[T any](value T) *T
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    result := convertor.ToPointer(123)
-    fmt.Println(*result)
-
-    // Output:
-    // 123
-}
-```
 
 ### <span id="ToString">ToString</span>
 
-<p>将值转换为字符串，对于数字、字符串、[]byte，将转换为字符串。 对于其他类型（切片、映射、数组、结构体）将调用 json.Marshal</p>
+<p>将interface转成字符串</p>
 
 <b>函数签名:</b>
 
 ```go
-func ToString(value any) string
+func ToString(value interface{}) string
 ```
-
-<b>示例:</b>
+<b>例子:</b>
 
 ```go
 package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
-    result1 := convertor.ToString("")
-    result2 := convertor.ToString(nil)
-    result3 := convertor.ToString(0)
-    result4 := convertor.ToString(1.23)
-    result5 := convertor.ToString(true)
-    result6 := convertor.ToString(false)
-    result7 := convertor.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]
+    fmt.Printf("%q", convertor.ToString(1)) //"1"
+    fmt.Printf("%q", convertor.ToString(1.1)) //"1.1"
+    fmt.Printf("%q", convertor.ToString([]int{1, 2, 3})) //"[1,2,3]"
 }
 ```
 
+
+
 ### <span id="StructToMap">StructToMap</span>
 
-<p>将struct转成map，只会转换struct中可导出的字段。struct中导出字段需要设置json tag标记。</p>
+<p>将struct转成map，只会转换struct中可导出的字段。struct中导出字段需要设置json tag标记</p>
 
 <b>函数签名:</b>
 
 ```go
-func StructToMap(value any) (map[string]any, error)
+func StructToMap(value interface{}) (map[string]interface{}, error)
 ```
-
-<b>示例:</b>
+<b>列子:</b>
 
 ```go
 package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
+    "github.com/duke-git/lancet/convertor"
 )
 
 func main() {
@@ -530,349 +346,6 @@ func main() {
     }
     pm, _ := convertor.StructToMap(p)
 
-    fmt.Println(pm)
-
-    // Output:
-    // map[name:test]
+    fmt.Printf("type: %T, value: %s", pm, pm) //type: map[string]interface {}, value: map[name:test]
 }
-```
-
-### <span id="MapToSlice">MapToSlice</span>
-
-<p>map中key和value执行函数iteratee后，转为切片。</p>
-
-<b>函数签名:</b>
-
-```go
-func MapToSlice[T any, K comparable, V any](aMap map[K]V, iteratee func(K, V) T) []T
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    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", "b:2", "c:3"}
-}
-```
-
-### <span id="EncodeByte">EncodeByte</span>
-
-<p>将data编码成字节切片。</p>
-
-<b>函数签名:</b>
-
-```go
-func EncodeByte(data any) ([]byte, error)
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    byteData, _ := convertor.EncodeByte("abc")
-    fmt.Println(byteData)
-
-    // Output:
-    // [6 12 0 3 97 98 99]
-}
-```
-
-### <span id="DecodeByte">DecodeByte</span>
-
-<p>解码字节切片到目标对象，目标对象需要传入一个指针实例。</p>
-
-<b>函数签名:</b>
-
-```go
-func DecodeByte(data []byte, target any) error
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    var result string
-    byteData := []byte{6, 12, 0, 3, 97, 98, 99}
-
-    err := convertor.DecodeByte(byteData, &result)
-    if err != nil {
-        return
-    }
-
-    fmt.Println(result)
-
-    // Output:
-    // abc
-}
-```
-
-### <span id="DeepClone">DeepClone</span>
-
-<p>创建一个传入值的深拷贝, 无法克隆结构体的非导出字段。</p>
-
-<b>函数签名:</b>
-
-```go
-func DeepClone[T any](src T) T
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    type Struct struct {
-        Str        string
-        Int        int
-        Float      float64
-        Bool       bool
-        Nil        interface{}
-        unexported string
-    }
-
-    cases := []interface{}{
-        true,
-        1,
-        0.1,
-        map[string]int{
-            "a": 1,
-            "b": 2,
-        },
-        &Struct{
-            Str:   "test",
-            Int:   1,
-            Float: 0.1,
-            Bool:  true,
-            Nil:   nil,
-            // unexported: "can't be cloned",
-        },
-    }
-
-    for _, item := range cases {
-        cloned := convertor.DeepClone(item)
-
-        isPointerEqual := &cloned == &item
-        fmt.Println(cloned, isPointerEqual)
-    }
-
-    // Output:
-    // true false
-    // 1 false
-    // 0.1 false
-    // map[a:1 b:2] false
-    // &{test 1 0.1 true <nil> } false
-}
-```
-
-### <span id="CopyProperties">CopyProperties</span>
-
-<p>拷贝不同结构体之间的同名字段。使用json.Marshal序列化，需要设置dst和src struct字段的json tag。</p>
-
-<b>函数签名:</b>
-
-```go
-func CopyProperties[T, U any](dst T, src U) (err error)
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    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{}
-
-    err := convertor.CopyProperties(&indicatorVO, indicator)
-
-    if err != nil {
-        return
-    }
-
-    fmt.Println(indicatorVO.Id)
-    fmt.Println(indicatorVO.Ip)
-    fmt.Println(len(indicatorVO.Disk))
-
-    // Output:
-    // 001
-    // 127.0.0.1
-    // 3
-}
-```
-
-### <span id="ToInterface">ToInterface</span>
-
-<p>将反射值转换成对应的interface类型。</p>
-
-<b>函数签名:</b>
-
-```go
-func ToInterface(v reflect.Value) (value interface{}, ok bool)
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    val := reflect.ValueOf("abc")
-    iVal, ok := convertor.ToInterface(val)
-
-    fmt.Printf("%T\n", iVal)
-    fmt.Printf("%v\n", iVal)
-    fmt.Println(ok)
-
-    // Output:
-    // string
-    // abc
-    // true
-}
-```
-
-### <span id="Utf8ToGbk">Utf8ToGbk</span>
-
-<p>utf8编码转GBK编码。</p>
-
-<b>函数签名:</b>
-
-```go
-func Utf8ToGbk(bs []byte) ([]byte, error)
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-    "github.com/duke-git/lancet/v2/validator"
-)
-
-func main() {
-    utf8Data := []byte("hello")
-    gbkData, _ := convertor.Utf8ToGbk(utf8Data)
-
-    fmt.Println(utf8.Valid(utf8Data))
-    fmt.Println(validator.IsGBK(gbkData))
-
-    // Output:
-    // true
-    // true
-}
-```
-
-### <span id="GbkToUtf8">GbkToUtf8</span>
-
-<p>GBK编码转utf8编码。</p>
-
-<b>函数签名:</b>
-
-```go
-func GbkToUtf8(bs []byte) ([]byte, error)
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/duke-git/lancet/v2/convertor"
-)
-
-func main() {
-    gbkData, _ := convertor.Utf8ToGbk([]byte("hello"))
-    utf8Data, _ := convertor.GbkToUtf8(gbkData)
-
-    fmt.Println(utf8.Valid(utf8Data))
-    fmt.Println(string(utf8Data))
-
-    // Output:
-    // true
-    // hello
-}
-```
+```

docs/cryptor.md

@@ -5,17 +5,17 @@ Package cryptor contains some functions for data encryption and decryption. Supp
 
 ## Source:
 
-- [https://github.com/duke-git/lancet/blob/main/cryptor/basic.go](https://github.com/duke-git/lancet/blob/main/cryptor/basic.go)
-- [https://github.com/duke-git/lancet/blob/main/cryptor/encrypt.go](https://github.com/duke-git/lancet/blob/main/cryptor/encrypt.go)
-
-
+- [https://github.com/duke-git/lancet/blob/v1/cryptor/aes.go](https://github.com/duke-git/lancet/blob/v1/cryptor/aes.go)
+- [https://github.com/duke-git/lancet/blob/v1/cryptor/des.go](https://github.com/duke-git/lancet/blob/v1/cryptor/des.go)
+- [https://github.com/duke-git/lancet/blob/v1/cryptor/basic.go](https://github.com/duke-git/lancet/blob/v1/cryptor/basic.go)
+- [https://github.com/duke-git/lancet/blob/v1/cryptor/rsa.go](https://github.com/duke-git/lancet/blob/v1/cryptor/rsa.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Usage:
 ```go
 import (
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 ```
 
@@ -47,6 +47,7 @@ import (
 - [HmacSha1](#HmacSha1)
 - [HmacSha256](#HmacSha256)
 - [HmacSha512](#HmacSha512)
+
 - [Md5String](#Md5String)
 - [Md5File](#Md5File)
 - [Sha1](#Sha1)
@@ -61,6 +62,8 @@ import (
 
 ## Documentation
 
+
+
 ### <span id="AesEcbEncrypt">AesEcbEncrypt</span>
 
 <p>Encrypt data with key use AES ECB algorithm. Length of `key` param should be 16, 24 or 32.</p>
@@ -77,23 +80,20 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefghijklmnop"
-
+    data := "hello world"
+  	key := "abcdefghijklmnop"
     encrypted := cryptor.AesEcbEncrypt([]byte(data), []byte(key))
-    decrypted := cryptor.AesEcbDecrypt(encrypted, []byte(key))
 
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+    fmt.Println(string(encrypted))
 }
 ```
 
+
+
 ### <span id="AesEcbDecrypt">AesEcbDecrypt</span>
 
 <p>Decrypt data with key use AES ECB algorithm. Length of `key` param should be 16, 24 or 32.</p>
@@ -110,23 +110,20 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefghijklmnop"
-
+    data := "hello world"
+  	key := "abcdefghijklmnop"
     encrypted := cryptor.AesEcbEncrypt([]byte(data), []byte(key))
-    decrypted := cryptor.AesEcbDecrypt(encrypted, []byte(key))
-
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+	decrypted := cryptor.AesEcbDecrypt(encrypted, []byte(key))
+    fmt.Println(string(decrypted)) //hello world
 }
 ```
 
+
+
 ### <span id="AesCbcEncrypt">AesCbcEncrypt</span>
 
 <p>Encrypt data with key use AES CBC algorithm. Length of `key` param should be 16, 24 or 32.</p>
@@ -143,23 +140,20 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefghijklmnop"
-
+    data := "hello world"
+  	key := "abcdefghijklmnop"
     encrypted := cryptor.AesCbcEncrypt([]byte(data), []byte(key))
-    decrypted := cryptor.AesCbcDecrypt(encrypted, []byte(key))
 
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+    fmt.Println(string(encrypted))
 }
 ```
 
+
+
 ### <span id="AesCbcDecrypt">AesCbcDecrypt</span>
 
 <p>Decrypt data with key use AES CBC algorithm. Length of `key` param should be 16, 24 or 32.</p>
@@ -177,23 +171,20 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefghijklmnop"
-
+    data := "hello world"
+  	key := "abcdefghijklmnop"
     encrypted := cryptor.AesCbcEncrypt([]byte(data), []byte(key))
-    decrypted := cryptor.AesCbcDecrypt(encrypted, []byte(key))
-
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+	decrypted := cryptor.AesCbcDecrypt(encrypted, []byte(key))
+    fmt.Println(string(decrypted)) //hello world
 }
 ```
 
+
+
 ### <span id="AesCtrCrypt">AesCtrCrypt</span>
 
 <p>Encrypt or decrypt data with key use AES CTR algorithm. Length of `key` param should be 16, 24 or 32.</p>
@@ -211,23 +202,21 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefghijklmnop"
-
+    data := "hello world"
+  	key := "abcdefghijklmnop"
     encrypted := cryptor.AesCtrCrypt([]byte(data), []byte(key))
     decrypted := cryptor.AesCtrCrypt(encrypted, []byte(key))
 
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+    fmt.Println(string(decrypted)) //hello world
 }
 ```
 
+
+
 ### <span id="AesCfbEncrypt">AesCfbEncrypt</span>
 
 <p>Encrypt data with key use AES CFB algorithm. Length of `key` param should be 16, 24 or 32.</p>
@@ -245,23 +234,19 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefghijklmnop"
-
+    data := "hello world"
+  	key := "abcdefghijklmnop"
     encrypted := cryptor.AesCfbEncrypt([]byte(data), []byte(key))
-    decrypted := cryptor.AesCfbDecrypt(encrypted, []byte(key))
-
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+    fmt.Println(string(encrypted))
 }
 ```
 
+
+
 ### <span id="AesCfbDecrypt">AesCfbDecrypt</span>
 
 <p>Decrypt data with key use AES CBC algorithm. Length of `key` param should be 16, 24 or 32.</p>
@@ -279,23 +264,20 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
+    data := "hello world"
     key := "abcdefghijklmnop"
-
     encrypted := cryptor.AesCfbEncrypt([]byte(data), []byte(key))
-    decrypted := cryptor.AesCfbDecrypt(encrypted, []byte(key))
-
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+	decrypted := cryptor.AesCfbDecrypt(encrypted, []byte(key))
+    fmt.Println(string(decrypted)) //hello world
 }
 ```
 
+
+
 ### <span id="AesOfbEncrypt">AesOfbEncrypt</span>
 
 <p>Enecrypt data with key use AES OFB algorithm. Length of `key` param should be 16, 24 or 32.</p>
@@ -313,22 +295,19 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefghijklmnop"
-
+    data := "hello world"
+  	key := "abcdefghijklmnop"
     encrypted := cryptor.AesOfbEncrypt([]byte(data), []byte(key))
-    decrypted := cryptor.AesCfbDecrypt(encrypted, []byte(key))
-
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+    fmt.Println(string(encrypted))
 }
 ```
+
+
+
 ### <span id="AesCfbDecrypt">AesOfbDecrypt</span>
 
 <p>Decrypt data with key use AES OFB algorithm. Length of `key` param should be 16, 24 or 32.</p>
@@ -346,23 +325,21 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefghijklmnop"
-
+    data := "hello world"
+  	key := "abcdefghijklmnop"
     encrypted := cryptor.AesOfbEncrypt([]byte(data), []byte(key))
-    decrypted := cryptor.AesCfbDecrypt(encrypted, []byte(key))
-
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+	decrypted := cryptor.AesOfbDecrypt(encrypted, []byte(key))
+    
+    fmt.Println(string(decrypted)) //hello world
 }
 ```
 
+
+
 ### <span id="Base64StdEncode">Base64StdEncode</span>
 
 <p>Encode string with base64 encoding.</p>
@@ -379,17 +356,17 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    base64Str := cryptor.Base64StdEncode("hello")
-    fmt.Println(base64Str)
-
-    // Output:
-    // aGVsbG8=
+  	base64Str := cryptor.Base64StdEncode("hello world")
+    fmt.Println(base64Str) //aGVsbG8gd29ybGQ=
 }
 ```
+
+
+
 ### <span id="Base64StdDecode">Base64StdDecode</span>
 
 <p>Decode a base64 encoded string.</p>
@@ -407,18 +384,17 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    str := cryptor.Base64StdDecode("aGVsbG8=")
-    fmt.Println(str)
-
-    // Output:
-    // hello
+    str := cryptor.Base64StdDecode("aGVsbG8gd29ybGQ=")
+    fmt.Println(str) //hello world
 }
 ```
 
+
+
 ### <span id="DesEcbEncrypt">DesEcbEncrypt</span>
 
 <p>Encrypt data with key use DES ECB algorithm. Length of `key` param should be 8.</p>
@@ -436,23 +412,20 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefgh"
-
+    data := "hello world"
+  	key := "abcdefgh"
     encrypted := cryptor.DesEcbEncrypt([]byte(data), []byte(key))
 
-    decrypted := cryptor.DesEcbDecrypt(encrypted, []byte(key))
-
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+    fmt.Println(string(encrypted))
 }
 ```
+
+
+
 ### <span id="DesEcbDecrypt">DesEcbDecrypt</span>
 
 <p>Decrypt data with key use DES ECB algorithm. Length of `key` param should be 8.</p>
@@ -470,24 +443,21 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefgh"
-
-    encrypted := cryptor.DesEcbEncrypt([]byte(data), []byte(key))
-
-    decrypted := cryptor.DesEcbDecrypt(encrypted, []byte(key))
-
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+    data := "hello world"
+  	key := "abcdefgh"
+    encrypted := cryptor.DesEcbEncrypt([]byte(data), []byt(key)
+	decrypted := cryptor.DesEcbDecrypt(encrypted, []byte(key))
+  
+    fmt.Println(string(decrypted)) //hello world
 }
 ```
 
+
+
 ### <span id="DesCbcEncrypt">DesCbcEncrypt</span>
 
 <p>Encrypt data with key use DES CBC algorithm. Length of `key` param should be 8.</p>
@@ -505,23 +475,20 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefgh"
+    data := "hello world"
+  	key := "abcdefgh"
+    encrypted := cryptor.DesCbcEncrypt([]byte(data), []byt(key)
 
-    encrypted := cryptor.DesCbcEncrypt([]byte(data), []byte(key))
-    decrypted := cryptor.DesCbcDecrypt(encrypted, []byte(key))
-
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+    fmt.Println(string(encrypted))
 }
 ```
 
+
+
 ### <span id="DesCbcDecrypt">DesCbcDecrypt</span>
 
 <p>Decrypt data with key use DES CBC algorithm. Length of `key` param should be 8.</p>
@@ -539,22 +506,21 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefgh"
-
-    encrypted := cryptor.DesCbcEncrypt([]byte(data), []byte(key))
-    decrypted := cryptor.DesCbcDecrypt(encrypted, []byte(key))
-
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+    data := "hello world"
+  	key := "abcdefgh"
+    encrypted := cryptor.DesCbcEncrypt([]byte(data), []byt(key)
+	decrypted := cryptor.DesCbcDecrypt(encrypted, []byte(key))
+    
+    fmt.Println(string(decrypted)) //hello world
 }
 ```
+
+
+
 ### <span id="DesCtrCrypt">DesCtrCrypt</span>
 
 <p>Encrypt or decrypt data with key use DES CTR algorithm. Length of `key` param should be 8.</p>
@@ -572,23 +538,21 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefgh"
-
+    data := "hello world"
+  	key := "abcdefgh"
     encrypted := cryptor.DesCtrCrypt([]byte(data), []byte(key))
     decrypted := cryptor.DesCtrCrypt(encrypted, []byte(key))
 
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+    fmt.Println(string(decrypted)) //hello world
 }
 ```
 
+
+
 ### <span id="DesCfbEncrypt">DesCfbEncrypt</span>
 
 <p>Encrypt data with key use DES CFB algorithm. Length of `key` param should be 8.</p>
@@ -606,22 +570,19 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefgh"
-
-    encrypted := cryptor.DesCfbEncrypt([]byte(data), []byte(key))
-    decrypted := cryptor.DesCfbDecrypt(encrypted, []byte(key))
-
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+    data := "hello world"
+  	key := "abcdefgh"
+    encrypted := cryptor.DesCfbEncrypt([]byte(data), []byt(key)
+    fmt.Println(string(encrypted))
 }
 ```
+
+
+
 ### <span id="DesCfbDecrypt">DesCfbDecrypt</span>
 
 <p>Decrypt data with key use DES CBC algorithm. Length of `key` param should be 8.</p>
@@ -639,22 +600,20 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefgh"
-
-    encrypted := cryptor.DesCfbEncrypt([]byte(data), []byte(key))
-    decrypted := cryptor.DesCfbDecrypt(encrypted, []byte(key))
-
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+    data := "hello world"
+  	key := "abcdefgh"
+    encrypted := cryptor.DesCfbEncrypt([]byte(data), []byt(key)
+	decrypted := cryptor.DesCfbDecrypt(encrypted, []byte(key))
+    fmt.Println(string(decrypted)) //hello world
 }
 ```
+
+
+
 ### <span id="DesOfbEncrypt">DesOfbEncrypt</span>
 
 <p>Enecrypt data with key use DES OFB algorithm. Length of `key` param should be 8.</p>
@@ -672,22 +631,19 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefgh"
-
+    data := "hello world"
+  	key := "abcdefgh"
     encrypted := cryptor.DesOfbEncrypt([]byte(data), []byte(key))
-    decrypted := cryptor.DesOfbDecrypt(encrypted, []byte(key))
-
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+    fmt.Println(string(encrypted))
 }
 ```
+
+
+
 ### <span id="DesOfbDecrypt">DesOfbDecrypt</span>
 
 <p>Decrypt data with key use DES OFB algorithm. Length of `key` param should be 8.</p>
@@ -705,23 +661,21 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    data := "hello"
-    key := "abcdefgh"
-
+    data := "hello world"
+  	key := "abcdefgh"
     encrypted := cryptor.DesOfbEncrypt([]byte(data), []byte(key))
-    decrypted := cryptor.DesOfbDecrypt(encrypted, []byte(key))
-
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+	decrypted := cryptor.DesOfbDecrypt(encrypted, []byte(key))
+    
+    fmt.Println(string(decrypted)) //hello world
 }
 ```
 
+
+
 ### <span id="HmacMd5">HmacMd5</span>
 
 <p>Get the md5 hmac hash of string.</p>
@@ -739,20 +693,17 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-      str := "hello"
-    key := "12345"
-
-    hms := cryptor.HmacMd5(str, key)
-    fmt.Println(hms)
-
-    // Output:
-    // e834306eab892d872525d4918a7a639a
+  	s := cryptor.HmacMd5("hello world", "12345"))
+  	fmt.Println(s) //5f4c9faaff0a1ad3007d9ddc06abe36d
 }
 ```
+
+
+
 ### <span id="HmacSha1">HmacSha1</span>
 
 <p>Get the sha1 hmac hash of string.</p>
@@ -770,20 +721,17 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    str := "hello"
-    key := "12345"
-
-    hms := cryptor.HmacSha1(str, key)
-    fmt.Println(hms)
-
-    // Output:
-    // 5c6a9db0cccb92e36ed0323fd09b7f936de9ace0
+  	s := cryptor.HmacSha1("hello world", "12345"))
+  	fmt.Println(s) //3826f812255d8683f051ee97346d1359234d5dbd
 }
 ```
+
+
+
 ### <span id="HmacSha256">HmacSha256</span>
 
 <p>Get the sha256 hmac hash of string</p>
@@ -801,21 +749,17 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    str := "hello"
-    key := "12345"
-
-    hms := cryptor.HmacSha256(str, key)
-    fmt.Println(hms)
-
-    // Output:
-    // 315bb93c4e989862ba09cb62e05d73a5f376cb36f0d786edab0c320d059fde75
+  	s := cryptor.HmacSha256("hello world", "12345"))
+  	fmt.Println(s) //9dce2609f2d67d41f74c7f9efc8ccd44370d41ad2de52982627588dfe7289ab8
 }
 ```
 
+
+
 ### <span id="HmacSha512">HmacSha512</span>
 
 <p>Get the sha512 hmac hash of string.</p>
@@ -833,22 +777,18 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    str := "hello"
-    key := "12345"
-
-    hms := cryptor.HmacSha512(str, key)
-    fmt.Println(hms)
-
-    // Output:
-    // dd8f1290a9dd23d354e2526d9a2e9ce8cffffdd37cb320800d1c6c13d2efc363288376a196c5458daf53f8e1aa6b45a6d856303d5c0a2064bff9785861d48cfc
+  	s := cryptor.HmacSha512("hello world", "12345"))
+  	fmt.Println(s) 
+ //5b1563ac4e9b49c9ada8ccb232588fc4f0c30fd12f756b3a0b95af4985c236ca60925253bae10ce2c6bf9af1c1679b51e5395ff3d2826c0a2c7c0d72225d4175
 }
 ```
 
 
+
 ### <span id="Md5String">Md5String</span>
 
 <p>Get the md5 value of string.</p>
@@ -866,20 +806,17 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    str := "hello"
-
-    md5Str := cryptor.Md5String(str)
-    fmt.Println(md5Str)
-
-    // Output:
-    // 5d41402abc4b2a76b9719d911017c592
+  	s := cryptor.Md5String("hello"))
+  	fmt.Println(s) //5d41402abc4b2a76b9719d911017c592
 }
 ```
 
+
+
 ### <span id="Md5File">Md5File</span>
 
 <p>Get the md5 value of file.</p>
@@ -897,15 +834,17 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    s := cryptor.Md5File("./main.go"))
-    fmt.Println(s)
+  	s := cryptor.Md5File("./main.go"))
+  	fmt.Println(s)
 }
 ```
 
+
+
 ### <span id="Sha1">Sha1</span>
 
 <p>Get the sha1 value of string.</p>
@@ -923,20 +862,17 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    str := "hello"
-
-    result := cryptor.Sha1(str)
-    fmt.Println(result)
-
-    // Output:
-    // aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
+  	s := cryptor.Sha1("hello world"))
+  	fmt.Println(s) //2aae6c35c94fcfb415dbe95f408b9ce91ee846ed
 }
 ```
 
+
+
 ### <span id="Sha256">Sha256</span>
 
 <p>Get the sha256 value of string.</p>
@@ -954,20 +890,17 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    str := "hello"
-
-    result := cryptor.Sha256(str)
-    fmt.Println(result)
-
-    // Output:
-    // 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
+  	s := cryptor.Sha256("hello world"))
+  	fmt.Println(s) //b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
 }
 ```
 
+
+
 ### <span id="Sha512">Sha512</span>
 
 <p>Get the sha512 value of string.</p>
@@ -985,20 +918,17 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    str := "hello"
-
-    result := cryptor.Sha512(str)
-    fmt.Println(result)
-
-    // Output:
-    // 9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043
+  	s := cryptor.Sha512("hello world"))
+    fmt.Println(s) //309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f
 }
 ```
 
+
+
 ### <span id="GenerateRsaKey">GenerateRsaKey</span>
 
 <p>Create the rsa public and private key file in current directory.</p>
@@ -1016,17 +946,19 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+  	err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
     if err != nil {
         fmt.Println(err)
-    }
+  	}
 }
 ```
 
+
+
 ### <span id="RsaEncrypt">RsaEncrypt</span>
 
 <p>Encrypt data with public key file useing ras algorithm.</p>
@@ -1044,27 +976,25 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+  	err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
     if err != nil {
-        return
+        fmt.Println(err)
     }
-      
-    data := []byte("hello")
-    encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
-    decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
-      
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+  	
+    data := []byte("hello world")
+	encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
+	decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
+  	
+    fmt.Println(string(decrypted)) //hello world
 }
 ```
 
 
+
 ### <span id="RsaDecrypt">RsaDecrypt</span>
 
 <p>Decrypt data with private key file useing ras algorithm.</p>
@@ -1082,23 +1012,20 @@ package main
 
 import (
     "fmt"
-    "github.com/duke-git/lancet/v2/cryptor"
+    "github.com/duke-git/lancet/cryptor"
 )
 
 func main() {
-    err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+  	err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
     if err != nil {
-        return
-    }
-      
-    data := []byte("hello")
-    encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
-    decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
-      
-    fmt.Println(string(decrypted))
-
-    // Output:
-    // hello
+        fmt.Println(err)
+  	}
+  	
+    data := []byte("hello world")
+	encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
+	decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
+  	
+    fmt.Println(string(decrypted)) //hello world
 }
 ```
 

docs/datastructure/hashmap.md

@@ -1,314 +0,0 @@
-# HashMap
-
-HashMap is a key value map data structure.
-
-<div STYLE="page-break-after: always;"></div>
-
-## Source
-
-- [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>
-
-## Usage
-
-```go
-import (
-    hashmap "github.com/duke-git/lancet/v2/datastructure/hashmap"
-)
-```
-
-<div STYLE="page-break-after: always;"></div>
-
-
-## Index
-
-- [NewHashMap](#NewHashMap)
-- [NewHashMapWithCapacity](#NewHashMapWithCapacity)
-- [Get](#Get)
-- [Put](#Put)
-- [Delete](#Delete)
-- [Contains](#Contains)
-- [Iterate](#Iterate)
-- [Keys](#Keys)
-- [Values](#Values)
-
-<div STYLE="page-break-after: always;"></div>
-
-## Documentation
-
-### <span id="NewHashMap">NewHashMap</span>
-
-<p>Make a HashMap instance with default capacity is 1 << 10.</p>
-
-<b>Signature:</b>
-
-```go
-func NewHashMap() *HashMap
-```
-
-<b>Example:</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="NewHashMap">NewHashMap</span>
-
-<p>Make a HashMap instance with given size and capacity.</p>
-
-<b>Signature:</b>
-
-```go
-func NewHashMapWithCapacity(size, capacity uint64) *HashMap
-```
-
-<b>Example:</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>Get the value of given key in hashmap</p>
-
-<b>Signature:</b>
-
-```go
-func (hm *HashMap) Get(key any) any
-```
-
-<b>Example:</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>Put new key value in hashmap, then return value</p>
-
-<b>Signature:</b>
-
-```go
-func (hm *HashMap) Put(key any, value any) any
-```
-
-<b>Example:</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>Delete key-value item by given key in hashmap.</p>
-
-<b>Signature:</b>
-
-```go
-func (hm *HashMap) Delete(key any)
-```
-
-<b>Example:</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>Checks if given key is in hashmap or not.</p>
-
-<b>Signature:</b>
-
-```go
-func (hm *HashMap) Contains(key any) bool
-```
-
-<b>Example:</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>Executes iteratee funcation for every key and value pair of hashmap.</p>
-
-<b>Signature:</b>
-
-```go
-func (hm *HashMap) Iterate(iteratee func(key, value any))
-```
-
-<b>Example:</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>Return a slice of the hashmap's keys (random order).</p>
-
-<b>Signature:</b>
-
-```go
-func (hm *HashMap) Keys() []any
-```
-
-<b>Example:</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>Return a slice of the hashmap's values (random order).</p>
-
-<b>Signature:</b>
-
-```go
-func (hm *HashMap) Values() []any
-```
-
-<b>Example:</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}
-}
-```
-
-

docs/datastructure/hashmap_zh-CN.md

@@ -1,308 +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)
-
-<div STYLE="page-break-after: always;"></div>
-
-## API 文档
-
-### <span id="NewHashMap">NewHashMap</span>
-
-<p>新建默认容量（1 << 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}
-}
-```
-
-

docs/datastructure/heap.md

@@ -1,364 +0,0 @@
-# Heap
-Heap is a binary heap tree implemented by slice.
-
-<div STYLE="page-break-after: always;"></div>
-
-## Source
-
-- [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>
-
-## Usage
-```go
-import (
-    heap "github.com/duke-git/lancet/v2/datastructure/heap"
-)
-```
-
-<div STYLE="page-break-after: always;"></div>
-
-## Index
-
-- [MaxHeap](#MaxHeap)
-- [Push](#Push)
-- [Pop](#Pop)
-- [Peek](#Peek)
-- [Data](#Data)
-- [Size](#Size)
-
-
-<div STYLE="page-break-after: always;"></div>
-
-## Documentation
-
-### 1. MaxHeap
-MaxHeap is a binary heap tree implemented by slice, The key of the root node is both greater than or equal to the key value of the left subtree and greater than or equal to the key value of the right subtree.
-
-### <span id="NewMaxHeap">NewMaxHeap</span>
-<p>Return a NewMaxHeap pointer instance.</p>
-
-<b>Signature:</b>
-
-```go
-type MaxHeap[T any] struct {
-	data       []T
-	comparator lancetconstraints.Comparator
-}
-func NewMaxHeap[T any](comparator lancetconstraints.Comparator) *MaxHeap[T]
-```
-<b>Example:</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>Push value into the heap</p>
-
-<b>Signature:</b>
-
-```go
-func (h *MaxHeap[T]) Push(value T)
-```
-<b>Example:</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>Pop return the largest value, and remove it from the heap if heap is empty, return zero value and fasle</p>
-
-<b>Signature:</b>
-
-```go
-func (h *MaxHeap[T]) Pop() (T, bool)
-```
-<b>Example:</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>Return the largest element from the heap without removing it, if heap is empty, it returns zero value and false.</p>
-
-<b>Signature:</b>
-
-```go
-func (h *MaxHeap[T]) Peek() (T, bool)
-```
-<b>Example:</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>Return all element of the heap</p>
-
-<b>Signature:</b>
-
-```go
-func (h *MaxHeap[T]) Data() []T
-```
-<b>Example:</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>Return the number of elements in the heap</p>
-
-<b>Signature:</b>
-
-```go
-func (h *MaxHeap[T]) Size() int
-```
-<b>Example:</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>Print the tree structure of the heap</p>
-
-<b>Signature:</b>
-
-```go
-func (h *MaxHeap[T]) PrintStructure()
-```
-<b>Example:</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
-}
-```

docs/datastructure/heap_zh-CN.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 lancetconstraints.Comparator
-}
-func NewMaxHeap[T any](comparator lancetconstraints.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
-}
-```

docs/datastructure/set.md

@@ -1,650 +0,0 @@
-# Set
-
-Set is a data container, like list, but elements of set is not duplicate.
-
-<div STYLE="page-break-after: always;"></div>
-
-## Source
-
--   [https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go](https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go)
-
-<div STYLE="page-break-after: always;"></div>
-
-## Usage
-
-```go
-import (
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-```
-
-<div STYLE="page-break-after: always;"></div>
-
-## Index
-
--   [NewSet](#NewSet)
--   [NewSetFromSlice](#NewSetFromSlice)
--   [Values](#Values)
--   [Add](#Add)
--   [AddIfNotExist](#AddIfNotExist)
--   [AddIfNotExistBy](#AddIfNotExistBy)
--   [Delete](#Delete)
--   [Contain](#Contain)
--   [ContainAll](#ContainAll)
--   [Clone](#Clone)
--   [Size](#Size)
--   [Equal](#Equal)
--   [Iterate](#Iterate)
--   [EachWithBreak](#EachWithBreak)
--   [IsEmpty](#IsEmpty)
--   [Union](#Union)
--   [Intersection](#Intersection)
--   [SymmetricDifference](#SymmetricDifference)
--   [Minus](#Minus)
-
-<div STYLE="page-break-after: always;"></div>
-
-## Documentation
-
-### <span id="NewSet">NewSet</span>
-
-<p>Create a set instance</p>
-
-<b>Signature:</b>
-
-```go
-type Set[T comparable] map[T]bool
-func NewSet[T comparable](items ...T) Set[T]
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    st := set.NewSet[int](1,2,2,3)
-    fmt.Println(st.Values()) //1,2,3
-}
-```
-
-### <span id="NewSetFromSlice">NewSetFromSlice</span>
-
-<p>Create a set from slice</p>
-
-<b>Signature:</b>
-
-```go
-func NewSetFromSlice[T comparable](items []T) Set[T]
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    st := set.NewSetFromSlice([]int{1, 2, 2, 3})
-    fmt.Println(st.Values()) //1,2,3
-}
-```
-
-### <span id="Values">Values</span>
-
-<p>Return slice of all set data</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) Values() []T
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    st := set.NewSet[int](1,2,2,3)
-    fmt.Println(st.Values()) //1,2,3
-}
-```
-
-### <span id="Add">Add</span>
-
-<p>Add items to set</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) Add(items ...T)
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    st := set.NewSet[int]()
-    st.Add(1, 2, 3)
-
-    fmt.Println(st.Values()) //1,2,3
-}
-```
-
-### <span id="AddIfNotExist">AddIfNotExist</span>
-
-<p>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.</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) AddIfNotExist(item T) bool
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    st := set.NewSet[int]()
-    st.Add(1, 2, 3)
-
-    r1 := st.AddIfNotExist(1)
-    r2 := st.AddIfNotExist(4)
-
-    fmt.Println(r1) // false
-    fmt.Println(r2) // true
-    fmt.Println(st.Values()) // 1,2,3,4
-}
-```
-
-### <span id="AddIfNotExistBy">AddIfNotExistBy</span>
-
-<p>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.</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) AddIfNotExistBy(item T, checker func(element T) bool) bool
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    st := set.NewSet[int]()
-    st.Add(1, 2)
-
-    ok := st.AddIfNotExistBy(3, func(val int) bool {
-        return val%2 != 0
-    })
-    fmt.Println(ok) // true
-
-
-    notOk := st.AddIfNotExistBy(4, func(val int) bool {
-        return val%2 != 0
-    })
-    fmt.Println(notOk) // false
-
-    fmt.Println(st.Values()) // 1, 2, 3
-}
-```
-
-### <span id="Delete">Delete</span>
-
-<p>Delete item in set</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) Delete(items ...T)
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    st := set.NewSet[int]()
-    st.Add(1, 2, 3)
-
-    set.Delete(3)
-    fmt.Println(st.Values()) //1,2
-}
-```
-
-### <span id="Contain">Contain</span>
-
-<p>Check if item is in set or not</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) Contain(item T) bool
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    st := set.NewSet[int]()
-    st.Add(1, 2, 3)
-
-    fmt.Println(st.Contain(1)) //true
-    fmt.Println(st.Contain(4)) //false
-}
-```
-
-### <span id="ContainAll">ContainAll</span>
-
-<p>Checks if set contains another set</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) ContainAll(other Set[T]) bool
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(1, 2)
-    set3 := set.NewSet(1, 2, 3, 4)
-
-    fmt.Println(set1.ContainAll(set2)) //true
-    fmt.Println(set1.ContainAll(set3)) //false
-}
-```
-
-### <span id="Size">Size</span>
-
-<p>Get the number of elements in set</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) Size() int
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-
-    fmt.Println(set1.Size()) //3
-}
-```
-
-### <span id="Clone">Clone</span>
-
-<p>Make a copy of set</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) Clone() Set[T]
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set1.Clone()
-
-    fmt.Println(set1.Size() == set2.Size()) //true
-    fmt.Println(set1.ContainAll(set2)) //true
-}
-```
-
-### <span id="Equal">Equal</span>
-
-<p>Check if two sets has same elements or not</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) Equal(other Set[T]) bool
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(1, 2, 3)
-    set3 := set.NewSet(1, 2, 3, 4)
-
-    fmt.Println(set1.Equal(set2)) //true
-    fmt.Println(set1.Equal(set3)) //false
-}
-```
-
-### <span id="Iterate">Iterate</span>
-
-<p>Call function by every element of set</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) Iterate(fn func(item T))
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    arr := []int{}
-    set.Iterate(func(item int) {
-        arr = append(arr, item)
-    })
-
-    fmt.Println(arr) //1,2,3
-}
-```
-
-### <span id="EachWithBreak">EachWithBreak</span>
-
-<p>Iterates over elements of a set and invokes function for each element, when iteratee return false, will break the for each loop.</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) EachWithBreak(iteratee func(item T) bool)
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    s := set.NewSet(1, 2, 3, 4, 5)
-
-    var sum int
-
-    s.EachWithBreak(func(n int) bool {
-        if n > 3 {
-            return false
-        }
-        sum += n
-        return true
-    })
-
-    fmt.Println(sum) //6
-}
-```
-
-### <span id="IsEmpty">IsEmpty</span>
-
-<p>Check if the set is empty or not</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) IsEmpty() bool
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet()
-
-    fmt.Println(set1.IsEmpty()) //false
-    fmt.Println(set2.IsEmpty()) //true
-}
-```
-
-### <span id="Union">Union</span>
-
-<p>Create a new set contain all element of set s and other</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) Union(other Set[T]) Set[T]
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
-    set3 := set1.Union(set2)
-
-    fmt.Println(set3.Values()) //1,2,3,4,5
-}
-```
-
-### <span id="Intersection">Intersection</span>
-
-<p>Create a new set whose element both be contained in set s and other</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) Intersection(other Set[T]) Set[T]
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
-    set3 := set1.Intersection(set2)
-
-    fmt.Println(set3.Values()) //2,3
-}
-```
-
-### <span id="SymmetricDifference">SymmetricDifference</span>
-
-<p>Create a new set whose element is in set1 or set2, but not in both set1 and set2</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) SymmetricDifference(other Set[T]) Set[T]
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
-    set3 := set1.SymmetricDifference(set2)
-
-    fmt.Println(set3.Values()) //1,4,5
-}
-```
-
-### <span id="Minus">Minus</span>
-
-<p>Create an set of whose element in origin set but not in compared set</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) Minus(comparedSet Set[T]) Set[T]
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
-    set3 := set.NewSet(2, 3)
-
-    res1 := set1.Minus(set2)
-    fmt.Println(res1.Values()) //1
-
-    res2 := set2.Minus(set3)
-    fmt.Println(res2.Values()) //4,5
-}
-```
-
-### <span id="Pop">Pop</span>
-
-<p>Delete the top element of set then return it, if set is empty, return nil-value of T and false.</p>
-
-<b>Signature:</b>
-
-```go
-func (s Set[T]) Pop() (v T, ok bool)
-```
-
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    s := set.NewSet[int]()
-    s.Add(1)
-    s.Add(2)
-    s.Add(3)
-
-    val, ok = s.Pop()
-
-    fmt.Println(val) // 3
-    fmt.Println(ok) // true
-}
-```

docs/datastructure/set_zh-CN.md

@@ -1,649 +0,0 @@
-# Set
-
-Set 集合数据结构，类似列表。Set 中元素不重复。
-
-<div STYLE="page-break-after: always;"></div>
-
-## 源码
-
--   [https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go](https://github.com/duke-git/lancet/blob/main/datastructure/set/set.go)
-
-<div STYLE="page-break-after: always;"></div>
-
-## 用法
-
-```go
-import (
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-```
-
-<div STYLE="page-break-after: always;"></div>
-
-## 目录
-
--   [NewSet](#NewSet)
--   [NewSetFromSlice](#NewSetFromSlice)
--   [Values](#Values)
--   [Add](#Add)
--   [AddIfNotExist](#AddIfNotExist)
--   [AddIfNotExistBy](#AddIfNotExistBy)
--   [Delete](#Delete)
--   [Contain](#Contain)
--   [ContainAll](#ContainAll)
--   [Clone](#Clone)
--   [Size](#Size)
--   [Equal](#Equal)
--   [Iterate](#Iterate)
--   [IsEmpty](#IsEmpty)
--   [Union](#Union)
--   [Intersection](#Intersection)
--   [SymmetricDifference](#SymmetricDifference)
--   [Minus](#Minus)
-
-<div STYLE="page-break-after: always;"></div>
-
-## 文档
-
-### <span id="NewSet">NewSet</span>
-
-<p>返回Set结构体对象</p>
-
-<b>函数签名:</b>
-
-```go
-type Set[T comparable] map[T]bool
-func NewSet[T comparable](items ...T) Set[T]
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    st := set.NewSet[int](1,2,2,3)
-    fmt.Println(st.Values()) //1,2,3
-}
-```
-
-### <span id="NewSetFromSlice">NewSetFromSlice</span>
-
-<p>基于切片创建集合</p>
-
-<b>函数签名:</b>
-
-```go
-func NewSetFromSlice[T comparable](items []T) Set[T]
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    st := set.NewSetFromSlice([]int{1, 2, 2, 3})
-    fmt.Println(st.Values()) //1,2,3
-}
-```
-
-### <span id="Values">Values</span>
-
-<p>获取集合中所有元素的切片</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) Values() []T
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    st := set.NewSet[int](1,2,2,3)
-    fmt.Println(st.Values()) //1,2,3
-}
-```
-
-### <span id="Add">Add</span>
-
-<p>向集合中添加元素</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) Add(items ...T)
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    st := set.NewSet[int]()
-    st.Add(1, 2, 3)
-
-    fmt.Println(st.Values()) //1,2,3
-}
-```
-
-### <span id="AddIfNotExist">AddIfNotExist</span>
-
-<p>如果集合中不存在元素，则添加该元素返回true, 如果集合中存在元素, 不做任何操作，返回false</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) AddIfNotExist(item T) bool
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    st := set.NewSet[int]()
-    st.Add(1, 2, 3)
-
-    r1 := st.AddIfNotExist(1)
-    r2 := st.AddIfNotExist(4)
-
-    fmt.Println(r1) // false
-    fmt.Println(r2) // true
-    fmt.Println(st.Values()) // 1,2,3,4
-}
-```
-
-### <span id="AddIfNotExistBy">AddIfNotExistBy</span>
-
-<p>根据checker函数判断元素是否在集合中，如果集合中不存在元素且checker返回true，则添加该元素返回true, 否则不做任何操作，返回false</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) AddIfNotExistBy(item T, checker func(element T) bool) bool
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    st := set.NewSet[int]()
-    st.Add(1, 2)
-
-    ok := st.AddIfNotExistBy(3, func(val int) bool {
-        return val%2 != 0
-    })
-    fmt.Println(ok) // true
-
-
-    notOk := st.AddIfNotExistBy(4, func(val int) bool {
-        return val%2 != 0
-    })
-    fmt.Println(notOk) // false
-
-    fmt.Println(st.Values()) // 1, 2, 3
-}
-```
-
-### <span id="Delete">Delete</span>
-
-<p>删除集合中元素</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) Delete(items ...T)
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    st := set.NewSet[int]()
-    st.Add(1, 2, 3)
-
-    set.Delete(3)
-    fmt.Println(st.Values()) //1,2
-}
-```
-
-### <span id="Contain">Contain</span>
-
-<p>判断集合是否包含某个值</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) Contain(item T) bool
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    st := set.NewSet[int]()
-    st.Add(1, 2, 3)
-
-    fmt.Println(st.Contain(1)) //true
-    fmt.Println(st.Contain(4)) //false
-}
-```
-
-### <span id="ContainAll">ContainAll</span>
-
-<p>判断集合是否包含另一个集合</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) ContainAll(other Set[T]) bool
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(1, 2)
-    set3 := set.NewSet(1, 2, 3, 4)
-
-    fmt.Println(set1.ContainAll(set2)) //true
-    fmt.Println(set1.ContainAll(set3)) //false
-}
-```
-
-### <span id="Size">Size</span>
-
-<p>获取集合中元素的个数</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) Size() int
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-
-    fmt.Println(set1.Size()) //3
-}
-```
-
-### <span id="Clone">Clone</span>
-
-<p>克隆一个集合</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) Clone() Set[T]
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set1.Clone()
-
-    fmt.Println(set1.Size() == set2.Size()) //true
-    fmt.Println(set1.ContainAll(set2)) //true
-}
-```
-
-### <span id="Equal">Equal</span>
-
-<p>比较两个集合是否相等，包含相同元素为相等</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) Equal(other Set[T]) bool
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(1, 2, 3)
-    set3 := set.NewSet(1, 2, 3, 4)
-
-    fmt.Println(set1.Equal(set2)) //true
-    fmt.Println(set1.Equal(set3)) //false
-}
-```
-
-### <span id="Iterate">Iterate</span>
-
-<p>迭代结合，在每个元素上调用函数</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) Iterate(fn func(item T))
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    arr := []int{}
-    set.Iterate(func(item int) {
-        arr = append(arr, item)
-    })
-
-    fmt.Println(arr) //1,2,3
-}
-```
-
-### <span id="EachWithBreak">EachWithBreak</span>
-
-<p>遍历集合的元素并为每个元素调用iteratee函数，当iteratee函数返回false时，终止遍历。</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) EachWithBreak(iteratee func(item T) bool)
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    s := set.NewSet(1, 2, 3, 4, 5)
-
-    var sum int
-
-    s.EachWithBreak(func(n int) bool {
-        if n > 3 {
-            return false
-        }
-        sum += n
-        return true
-    })
-
-    fmt.Println(sum) //6
-}
-```
-
-### <span id="IsEmpty">IsEmpty</span>
-
-<p>判断集合是否为空</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) IsEmpty() bool
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet()
-
-    fmt.Println(set1.IsEmpty()) //false
-    fmt.Println(set2.IsEmpty()) //true
-}
-```
-
-### <span id="Union">Union</span>
-
-<p>求两个集合的并集</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) Union(other Set[T]) Set[T]
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
-    set3 := set1.Union(set2)
-
-    fmt.Println(set3.Values()) //1,2,3,4,5
-}
-```
-
-### <span id="Intersection">Intersection</span>
-
-<p>求两个集合的交集</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) Intersection(other Set[T]) Set[T]
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
-    set3 := set1.Intersection(set2)
-
-    fmt.Println(set3.Values()) //2,3
-}
-```
-
-### <span id="SymmetricDifference">SymmetricDifference</span>
-
-<p>返回一个集合，其中元素在第一个集合或第二个集合中，且不同时存在于两个集合中</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) SymmetricDifference(other Set[T]) Set[T]
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
-    set3 := set1.SymmetricDifference(set2)
-
-    fmt.Println(set3.Values()) //1,4,5
-}
-```
-
-### <span id="Minus">Minus</span>
-
-<p>创建一个集合，其元素在原始集中但不在比较集中</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) Minus(comparedSet Set[T]) Set[T]
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    set1 := set.NewSet(1, 2, 3)
-    set2 := set.NewSet(2, 3, 4, 5)
-    set3 := set.NewSet(2, 3)
-
-    res1 := set1.Minus(set2)
-    fmt.Println(res1.Values()) //1
-
-    res2 := set2.Minus(set3)
-    fmt.Println(res2.Values()) //4,5
-}
-```
-
-### <span id="Pop">Pop</span>
-
-<p>删除并返回集合中的顶部元素</p>
-
-<b>函数签名:</b>
-
-```go
-func (s Set[T]) Pop() (v T, ok bool)
-```
-
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    set "github.com/duke-git/lancet/v2/datastructure/set"
-)
-
-func main() {
-    s := set.NewSet[int]()
-    s.Add(1)
-    s.Add(2)
-    s.Add(3)
-
-    val, ok = s.Pop()
-
-    fmt.Println(val) // 3
-    fmt.Println(ok) // true
-}
-```

docs/datastructure/stack.md

@@ -1,611 +0,0 @@
-# Stack
-Stack is an abstract data type that serves as a collection of elements. Elements follow the LIFO principle. FIFO is last-in, first-out, meaning that the most recently produced items are recorded as sold first.
-
-<div STYLE="page-break-after: always;"></div>
-
-## Source
-
-- [https://github.com/duke-git/lancet/blob/main/datastructure/stack/arraystack.go](https://github.com/duke-git/lancet/blob/main/datastructure/stack/arraystack.go)
-- [https://github.com/duke-git/lancet/blob/main/datastructure/stack/linkedstack.go](https://github.com/duke-git/lancet/blob/main/datastructure/stack/linkedstack.go)
-
-
-<div STYLE="page-break-after: always;"></div>
-
-## Usage
-```go
-import (
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-```
-
-<div STYLE="page-break-after: always;"></div>
-
-## Index
-
-### 1. ArrayStack
-
-- [NewArrayStack](#NewArrayStack)
-- [Push](#ArrayStack_Push)
-- [Pop](#ArrayStack_Pop)
-- [Peak](#ArrayStack_Peak)
-- [Data](#ArrayStack_Data)
-- [Size](#ArrayStack_Size)
-- [IsEmpty](#ArrayStack_IsEmpty)
-- [Clear](#ArrayStack_Clear)
-
-### 2. LinkedStack
-
-- [NewLinkedStack](#NewLinkedStack)
-- [Push](#LinkedStack_Push)
-- [Pop](#LinkedStack_Pop)
-- [Peak](#LinkedStack_Peak)
-- [Data](#LinkedStack_Data)
-- [Size](#LinkedStack_Size)
-- [IsEmpty](#LinkedStack_IsEmpty)
-- [Clear](#LinkedStack_Clear)
-- [Print](#LinkedStack_Print)
-
-<div STYLE="page-break-after: always;"></div>
-
-## Documentation
-
-### 1. ArrayStack
-ArrayStack is a stack implemented by slice.
-
-### <span id="NewArrayStack">NewArrayStack</span>
-<p>Return a empty ArrayStack pointer</p>
-
-<b>Signature:</b>
-
-```go
-type ArrayStack[T any] struct {
-	data   []T
-	length int
-}
-func NewArrayStack[T any]() *ArrayStack[T]
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewArrayStack[int]()
-    fmt.Println(sk)
-}
-```
-
-
-
-
-### <span id="ArrayStack_Push">Push</span>
-<p>Push element into array stack</p>
-
-<b>Signature:</b>
-
-```go
-func (s *ArrayStack[T]) Push(value T)
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewArrayStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    fmt.Println(sk.Data()) //[]int{3, 2, 1}
-}
-```
-
-
-
-
-### <span id="ArrayStack_Pop">Pop</span>
-<p>Delete the top element of stack then return it, if stack is empty, return nil and error</p>
-
-<b>Signature:</b>
-
-```go
-func (s *ArrayStack[T]) Pop() (*T, error)
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewArrayStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    val, err := sk.Pop()
-    fmt.Println(err) //nil
-    fmt.Println(*val) //3
-
-    fmt.Println(sk.Data()) //[]int{2, 1}
-}
-```
-
-
-
-
-### <span id="ArrayStack_Peak">Peak</span>
-<p>Return the top element of array stack</p>
-
-<b>Signature:</b>
-
-```go
-func (s *ArrayStack[T]) Peak() (*T, error)
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewArrayStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    val, err := sk.Peak()
-    fmt.Println(err) //nil
-    fmt.Println(*val) //3
-
-    fmt.Println(sk.Data()) //[]int{3, 2, 1}
-}
-```
-
-
-
-
-### <span id="ArrayStack_Data">Data</span>
-<p>Return a slice of all data in array stack</p>
-
-<b>Signature:</b>
-
-```go
-func (s *ArrayStack[T]) Data() []T
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewArrayStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    fmt.Println(sk.Data()) //[]int{3, 2, 1}
-}
-```
-
-
-
-
-### <span id="ArrayStack_Size">Size</span>
-<p>Return number of elements in array stack</p>
-
-<b>Signature:</b>
-
-```go
-func (s *ArrayStack[T]) Size() int
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewArrayStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    fmt.Println(sk.Size()) //3
-}
-```
-
-
-
-
-### <span id="ArrayStack_IsEmpty">IsEmpty</span>
-<p>Check if array stack is empty or not</p>
-
-<b>Signature:</b>
-
-```go
-func (s *ArrayStack[T]) IsEmpty() bool
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewArrayStack[int]()
-    fmt.Println(sk.IsEmpty()) //true
-
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    fmt.Println(sk.IsEmpty()) //false
-}
-```
-
-
-
-
-### <span id="ArrayStack_Clear">Clear</span>
-<p>Clear all elments in array stack</p>
-
-<b>Signature:</b>
-
-```go
-func (s *ArrayStack[T]) Clear()
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewArrayStack[int]()
-
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    sk.Clear()
-
-    fmt.Println(sk.Data()) //[]int{}
-}
-```
-
-
-
-### 2. LinkedStack
-LinkedStack is a stack implemented by linked list.
-
-### <span id="NewLinkedStack">NewLinkedStack</span>
-<p>Return a empty LinkedStack pointer</p>
-
-<b>Signature:</b>
-
-```go
-type StackNode[T any] struct {
-	Value T
-	Next  *StackNode[T]
-}
-type LinkedStack[T any] struct {
-	top    *datastructure.StackNode[T]
-	length int
-}
-func NewLinkedStack[T any]() *LinkedStack[T]
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-    fmt.Println(sk)
-}
-```
-
-
-
-
-### <span id="LinkedStack_Push">Push</span>
-<p>Push element into linked stack</p>
-
-<b>Signature:</b>
-
-```go
-func (s *LinkedStack[T]) Push(value T)
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    fmt.Println(sk.Data()) //[]int{3, 2, 1}
-}
-```
-
-
-
-
-### <span id="LinkedStack_Pop">Pop</span>
-<p>Delete the top element of stack then return it, if stack is empty, return nil and error</p>
-
-<b>Signature:</b>
-
-```go
-func (s *LinkedStack[T]) Pop() (*T, error)
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    val, err := sk.Pop()
-    fmt.Println(err) //nil
-    fmt.Println(*val) //3
-
-    fmt.Println(sk.Data()) //[]int{2, 1}
-}
-```
-
-
-
-
-### <span id="LinkedStack_Peak">Peak</span>
-<p>Return the top element of linked stack</p>
-
-<b>Signature:</b>
-
-```go
-func (s *LinkedStack[T]) Peak() (*T, error)
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    val, err := sk.Peak()
-    fmt.Println(err) //nil
-    fmt.Println(*val) //3
-
-    fmt.Println(sk.Data()) //[]int{3, 2, 1}
-}
-```
-
-
-
-
-### <span id="LinkedStack_Data">Data</span>
-<p>Return a slice of all data in linked stack</p>
-
-<b>Signature:</b>
-
-```go
-func (s *LinkedStack[T]) Data() []T
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    fmt.Println(sk.Data()) //[]int{3, 2, 1}
-}
-```
-
-
-
-
-### <span id="LinkedStack_Size">Size</span>
-<p>Return number of elements in linked stack</p>
-
-<b>Signature:</b>
-
-```go
-func (s *LinkedStack[T]) Size() int
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    fmt.Println(sk.Size()) //3
-}
-```
-
-
-
-
-### <span id="LinkedStack_IsEmpty">IsEmpty</span>
-<p>Check if linked stack is empty or not</p>
-
-<b>Signature:</b>
-
-```go
-func (s *LinkedStack[T]) IsEmpty() bool
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-    fmt.Println(sk.IsEmpty()) //true
-
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    fmt.Println(sk.IsEmpty()) //false
-}
-```
-
-
-
-
-### <span id="LinkedStack_Clear">Clear</span>
-<p>Clear all elments in linked stack</p>
-
-<b>Signature:</b>
-
-```go
-func (s *LinkedStack[T]) Clear()
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    sk.Clear()
-
-    fmt.Println(sk.Data()) //[]int{}
-}
-```
-
-
-
-
-### <span id="LinkedStack_Print">Print</span>
-<p>Print the structure of a linked stack</p>
-
-<b>Signature:</b>
-
-```go
-func (s *LinkedStack[T]) Print()
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-
-    sk.Print() //[ &{Value:3 Next:0xc000010260}, &{Value:2 Next:0xc000010250}, &{Value:1 Next:<nil>},  ]
-}
-```

docs/datastructure/stack_zh-CN.md

@@ -1,611 +0,0 @@
-# Stack
-栈数据结构，包括ArrayStack（数组栈）和LinkedStack（链表栈）。
-
-<div STYLE="page-break-after: always;"></div>
-
-## 源码
-
-- [https://github.com/duke-git/lancet/blob/main/datastructure/stack/arraystack.go](https://github.com/duke-git/lancet/blob/main/datastructure/stack/arraystack.go)
-- [https://github.com/duke-git/lancet/blob/main/datastructure/stack/linkedstack.go](https://github.com/duke-git/lancet/blob/main/datastructure/stack/linkedstack.go)
-
-
-<div STYLE="page-break-after: always;"></div>
-
-## 用法
-```go
-import (
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-```
-
-<div STYLE="page-break-after: always;"></div>
-
-## 目录
-
-### 1. ArrayStack（数组栈）
-
-- [NewArrayStack](#NewArrayStack)
-- [Push](#ArrayStack_Push)
-- [Pop](#ArrayStack_Pop)
-- [Peak](#ArrayStack_Peak)
-- [Data](#ArrayStack_Data)
-- [Size](#ArrayStack_Size)
-- [IsEmpty](#ArrayStack_IsEmpty)
-- [Clear](#ArrayStack_Clear)
-
-### 2. LinkedStack（链表栈）
-
-- [NewLinkedStack](#NewLinkedStack)
-- [Push](#LinkedStack_Push)
-- [Pop](#LinkedStack_Pop)
-- [Peak](#LinkedStack_Peak)
-- [Data](#LinkedStack_Data)
-- [Size](#LinkedStack_Size)
-- [IsEmpty](#LinkedStack_IsEmpty)
-- [Clear](#LinkedStack_Clear)
-- [Print](#LinkedStack_Print)
-
-<div STYLE="page-break-after: always;"></div>
-
-## 文档
-
-### 1. ArrayStack
-用切片实现栈结构
-
-### <span id="NewArrayStack">NewArrayStack</span>
-<p>返回ArrayStack指针实例</p>
-
-<b>函数签名:</b>
-
-```go
-type ArrayStack[T any] struct {
-	data   []T
-	length int
-}
-func NewArrayStack[T any]() *ArrayStack[T]
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewArrayStack[int]()
-    fmt.Println(sk)
-}
-```
-
-
-
-
-### <span id="ArrayStack_Push">Push</span>
-<p>将元素加入数组栈</p>
-
-<b>函数签名:</b>
-
-```go
-func (s *ArrayStack[T]) Push(value T)
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewArrayStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    fmt.Println(sk.Data()) //[]int{3, 2, 1}
-}
-```
-
-
-
-
-### <span id="ArrayStack_Pop">Pop</span>
-<p>删除栈顶元素并返回该元素指针</p>
-
-<b>函数签名:</b>
-
-```go
-func (s *ArrayStack[T]) Pop() (*T, error)
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewArrayStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    val, err := sk.Pop()
-    fmt.Println(err) //nil
-    fmt.Println(*val) //3
-
-    fmt.Println(sk.Data()) //[]int{2, 1}
-}
-```
-
-
-
-
-### <span id="ArrayStack_Peak">Peak</span>
-<p>返回栈顶元素指针</p>
-
-<b>函数签名:</b>
-
-```go
-func (s *ArrayStack[T]) Peak() (*T, error)
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewArrayStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    val, err := sk.Peak()
-    fmt.Println(err) //nil
-    fmt.Println(*val) //3
-
-    fmt.Println(sk.Data()) //[]int{3, 2, 1}
-}
-```
-
-
-
-
-### <span id="ArrayStack_Data">Data</span>
-<p>返回栈中所有元素组成的切片</p>
-
-<b>函数签名:</b>
-
-```go
-func (s *ArrayStack[T]) Data() []T
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewArrayStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    fmt.Println(sk.Data()) //[]int{3, 2, 1}
-}
-```
-
-
-
-
-### <span id="ArrayStack_Size">Size</span>
-<p>返回栈中元素的数量</p>
-
-<b>函数签名:</b>
-
-```go
-func (s *ArrayStack[T]) Size() int
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewArrayStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    fmt.Println(sk.Size()) //3
-}
-```
-
-
-
-
-### <span id="ArrayStack_IsEmpty">IsEmpty</span>
-<p>判断栈是否为空</p>
-
-<b>函数签名:</b>
-
-```go
-func (s *ArrayStack[T]) IsEmpty() bool
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewArrayStack[int]()
-    fmt.Println(sk.IsEmpty()) //true
-
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    fmt.Println(sk.IsEmpty()) //false
-}
-```
-
-
-
-
-### <span id="ArrayStack_Clear">Clear</span>
-<p>清空栈元素，使栈为空</p>
-
-<b>函数签名:</b>
-
-```go
-func (s *ArrayStack[T]) Clear()
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewArrayStack[int]()
-
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    sk.Clear()
-
-    fmt.Println(sk.Data()) //[]int{}
-}
-```
-
-
-
-### 2. LinkedStack
-链表实现的栈结构。
-
-### <span id="NewLinkedStack">NewLinkedStack</span>
-<p>返回LinkedStack指针实例</p>
-
-<b>函数签名:</b>
-
-```go
-type StackNode[T any] struct {
-	Value T
-	Next  *StackNode[T]
-}
-type LinkedStack[T any] struct {
-	top    *datastructure.StackNode[T]
-	length int
-}
-func NewLinkedStack[T any]() *LinkedStack[T]
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-    fmt.Println(sk)
-}
-```
-
-
-
-
-### <span id="LinkedStack_Push">Push</span>
-<p>将元素加入链表栈</p>
-
-<b>函数签名:</b>
-
-```go
-func (s *LinkedStack[T]) Push(value T)
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    fmt.Println(sk.Data()) //[]int{3, 2, 1}
-}
-```
-
-
-
-
-### <span id="LinkedStack_Pop">Pop</span>
-<p>删除栈顶元素并返回该元素指针</p>
-
-<b>函数签名:</b>
-
-```go
-func (s *LinkedStack[T]) Pop() (*T, error)
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    val, err := sk.Pop()
-    fmt.Println(err) //nil
-    fmt.Println(*val) //3
-
-    fmt.Println(sk.Data()) //[]int{2, 1}
-}
-```
-
-
-
-
-### <span id="LinkedStack_Peak">Peak</span>
-<p>返回栈顶元素指针</p>
-
-<b>函数签名:</b>
-
-```go
-func (s *LinkedStack[T]) Peak() (*T, error)
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    val, err := sk.Peak()
-    fmt.Println(err) //nil
-    fmt.Println(*val) //3
-
-    fmt.Println(sk.Data()) //[]int{3, 2, 1}
-}
-```
-
-
-
-
-### <span id="LinkedStack_Data">Data</span>
-<p>返回栈中所有元素组成的切片</p>
-
-<b>函数签名:</b>
-
-```go
-func (s *LinkedStack[T]) Data() []T
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    fmt.Println(sk.Data()) //[]int{3, 2, 1}
-}
-```
-
-
-
-
-### <span id="LinkedStack_Size">Size</span>
-<p>返回栈中元素的数量</p>
-
-<b>函数签名:</b>
-
-```go
-func (s *LinkedStack[T]) Size() int
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    fmt.Println(sk.Size()) //3
-}
-```
-
-
-
-
-### <span id="LinkedStack_IsEmpty">IsEmpty</span>
-<p>判断栈是否为空</p>
-
-<b>函数签名:</b>
-
-```go
-func (s *LinkedStack[T]) IsEmpty() bool
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-    fmt.Println(sk.IsEmpty()) //true
-
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    fmt.Println(sk.IsEmpty()) //false
-}
-```
-
-
-
-
-### <span id="LinkedStack_Clear">Clear</span>
-<p>清空栈元素，使栈为空</p>
-
-<b>函数签名:</b>
-
-```go
-func (s *LinkedStack[T]) Clear()
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-    sk.Clear()
-
-    fmt.Println(sk.Data()) //[]int{}
-}
-```
-
-
-
-
-### <span id="LinkedStack_Print">Print</span>
-<p>打印链表栈结构</p>
-
-<b>函数签名:</b>
-
-```go
-func (s *LinkedStack[T]) Print()
-```
-<b>示例:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    stack "github.com/duke-git/lancet/v2/datastructure/stack"
-)
-
-func main() {
-    sk := stack.NewLinkedStack[int]()
-
-    sk.Push(1)
-    sk.Push(2)
-    sk.Push(3)
-
-
-    sk.Print() //[ &{Value:3 Next:0xc000010260}, &{Value:2 Next:0xc000010250}, &{Value:1 Next:<nil>},  ]
-}
-```

docs/datastructure/tree.md

@@ -1,526 +0,0 @@
-# Tree
-Tree is a collection of tree nodes. Each tree node has a value, a left pointer point to left node and a right pointer point to right node.
-
-<div STYLE="page-break-after: always;"></div>
-
-## Source
-
-- [https://github.com/duke-git/lancet/blob/main/datastructure/tree/bstree.go](https://github.com/duke-git/lancet/blob/main/datastructure/tree/bstree.go)
-
-
-<div STYLE="page-break-after: always;"></div>
-
-## Usage
-```go
-import (
-    tree "github.com/duke-git/lancet/v2/datastructure/tree"
-)
-```
-
-<div STYLE="page-break-after: always;"></div>
-
-## Index
-
-### 1. BSTree
-
-- [NewBSTree](#NewBSTree)
-- [Insert](#BSTree_Insert)
-- [Delete](#BSTree_Delete)
-- [PreOrderTraverse](#BSTree_PreOrderTraverse)
-- [InOrderTraverse](#BSTree_InOrderTraverse)
-- [PostOrderTraverse](#BSTree_PostOrderTraverse)
-- [LevelOrderTraverse](#BSTree_LevelOrderTraverse)
-- [Depth](#BSTree_Depth)
-- [HasSubTree](#BSTree_HasSubTree)
-- [Print](#BSTree_Print)
-
-
-
-<div STYLE="page-break-after: always;"></div>
-
-## Documentation
-
-## 1. BSTree
-BSTree is a binary search tree data structure in which each node has at two children, which are referred to as the left child and the right child. In BSTree: leftNode < rootNode < rightNode. Type T should implements Compare function in lancetconstraints.Comparator interface.
-
-### <span id="NewBSTree">NewBSTree</span>
-<p>Make a BSTree pointer instance</p>
-
-<b>Signature:</b>
-
-```go
-func NewBSTree[T any](rootData T, comparator lancetconstraints.Comparator) *BSTree[T]
-
-type BSTree[T any] struct {
-	root       *datastructure.TreeNode[T]
-	comparator lancetconstraints.Comparator
-}
-
-type TreeNode[T any] struct {
-	Value T
-	Left  *TreeNode[T]
-	Right *TreeNode[T]
-}
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    tree "github.com/duke-git/lancet/v2/datastructure/tree"
-)
-
-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() {
-    bstree := tree.NewBSTree(6, &intComparator{})
-    fmt.Println(bstree) //
-}
-```
-
-
-
-
-### <span id="BSTree_Insert">Insert</span>
-<p>Insert value into binary search tree</p>
-
-<b>Signature:</b>
-
-```go
-func (t *BSTree[T]) Insert(data T)
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    tree "github.com/duke-git/lancet/v2/datastructure/tree"
-)
-
-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() {
-    bstree := tree.NewBSTree(6, &intComparator{})
-    bstree.Insert(7)
-	bstree.Insert(5)
-	bstree.Insert(2)
-	bstree.Insert(4)
-
-    fmt.Println(bstree.PreOrderTraverse()) //6, 5, 2, 4, 7
-}
-```
-
-
-
-
-### <span id="BSTree_Delete">Delete</span>
-<p>Delete value of binary search tree</p>
-
-<b>Signature:</b>
-
-```go
-func (t *BSTree[T]) Delete(data T)
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    tree "github.com/duke-git/lancet/v2/datastructure/tree"
-)
-
-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() {
-    bstree := tree.NewBSTree(6, &intComparator{})
-    bstree.Insert(7)
-	bstree.Insert(5)
-	bstree.Insert(2)
-	bstree.Insert(4)
-
-    bstree.Delete(4)
-
-    fmt.Println(bstree.PreOrderTraverse()) //2, 5, 6, 7
-}
-```
-
-
-
-
-### <span id="BSTree_PreOrderTraverse">PreOrderTraverse</span>
-<p>Traverse tree nodes in pre order</p>
-
-<b>Signature:</b>
-
-```go
-func (t *BSTree[T]) PreOrderTraverse() []T
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    tree "github.com/duke-git/lancet/v2/datastructure/tree"
-)
-
-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() {
-    bstree := tree.NewBSTree(6, &intComparator{})
-    bstree.Insert(7)
-	bstree.Insert(5)
-	bstree.Insert(2)
-	bstree.Insert(4)
-
-    fmt.Println(bstree.PreOrderTraverse()) //6, 5, 2, 4, 7
-}
-```
-
-
-
-
-### <span id="BSTree_InOrderTraverse">InOrderTraverse</span>
-<p>Traverse tree nodes in middle order</p>
-
-<b>Signature:</b>
-
-```go
-func (t *BSTree[T]) InOrderTraverse() []T
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    tree "github.com/duke-git/lancet/v2/datastructure/tree"
-)
-
-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() {
-    bstree := tree.NewBSTree(6, &intComparator{})
-    bstree.Insert(7)
-	bstree.Insert(5)
-	bstree.Insert(2)
-	bstree.Insert(4)
-
-    fmt.Println(bstree.InOrderTraverse()) //2, 4, 5, 6, 7
-}
-```
-
-
-
-
-### <span id="BSTree_PostOrderTraverse">PostOrderTraverse</span>
-<p>Traverse tree nodes in post order</p>
-
-<b>Signature:</b>
-
-```go
-func (t *BSTree[T]) PostOrderTraverse() []T
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    tree "github.com/duke-git/lancet/v2/datastructure/tree"
-)
-
-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() {
-    bstree := tree.NewBSTree(6, &intComparator{})
-    bstree.Insert(7)
-	bstree.Insert(5)
-	bstree.Insert(2)
-	bstree.Insert(4)
-
-    fmt.Println(bstree.PostOrderTraverse()) //5, 2, 4, 7, 6
-}
-```
-
-
-
-
-### <span id="BSTree_LevelOrderTraverse">LevelOrderTraverse</span>
-<p>Traverse tree nodes in node level order</p>
-
-<b>Signature:</b>
-
-```go
-func (t *BSTree[T]) LevelOrderTraverse() []T
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    tree "github.com/duke-git/lancet/v2/datastructure/tree"
-)
-
-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() {
-    bstree := tree.NewBSTree(6, &intComparator{})
-    bstree.Insert(7)
-	bstree.Insert(5)
-	bstree.Insert(2)
-	bstree.Insert(4)
-
-    fmt.Println(bstree.LevelOrderTraverse()) //6, 5, 7, 2, 4
-}
-```
-
-
-
-
-### <span id="BSTree_Depth">Depth</span>
-<p>Get the depth of a binary saerch tree</p>
-
-<b>Signature:</b>
-
-```go
-func (t *BSTree[T]) Depth() int
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    tree "github.com/duke-git/lancet/v2/datastructure/tree"
-)
-
-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() {
-    bstree := tree.NewBSTree(6, &intComparator{})
-    bstree.Insert(7)
-	bstree.Insert(5)
-	bstree.Insert(2)
-	bstree.Insert(4)
-
-    fmt.Println(bstree.Depth()) //4
-}
-```
-
-
-
-
-### <span id="BSTree_HasSubTree">HasSubTree</span>
-<p>Check if the given tree is sub tree of origin tree or not</p>
-
-<b>Signature:</b>
-
-```go
-func (t *BSTree[T]) HasSubTree(subTree *BSTree[T]) bool
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    tree "github.com/duke-git/lancet/v2/datastructure/tree"
-)
-
-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() {
-    superTree := tree.NewBSTree(8, &intComparator{})
-	superTree.Insert(4)
-	superTree.Insert(5)
-	superTree.Insert(6)
-	superTree.Insert(9)
-	superTree.Insert(4)
-
-    subTree := tree.NewBSTree(5, &intComparator{})
-	subTree.Insert(4)
-	subTree.Insert(6)
-
-    fmt.Println(superTree.HasSubTree(subTree)) //true
-    fmt.Println(subTree.HasSubTree(superTree)) //false
-}
-```
-
-
-
-
-### <span id="BSTree_Print">Print</span>
-<p>Print the structure of binary saerch tree</p>
-
-<b>Signature:</b>
-
-```go
-func (t *BSTree[T]) Print()
-```
-<b>Example:</b>
-
-```go
-package main
-
-import (
-    "fmt"
-    tree "github.com/duke-git/lancet/v2/datastructure/tree"
-)
-
-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() {
-    bstree := tree.NewBSTree(6, &intComparator{})
-    bstree.Insert(7)
-	bstree.Insert(5)
-	bstree.Insert(2)
-	bstree.Insert(4)
-
-    fmt.Println(bstree.Print())
-//        6
-//       / \
-//      /   \
-//     /     \
-//    /       \
-//    5       7
-//   /
-//  /
-//  2
-//   \
-//    4
-}
-```