Merge pull request #8 from hyphennn/hyphen/dev

chore: change pakage

Author: hyphennn

README.md

@@ -10,32 +10,31 @@ package main
 import (
 	"fmt"
 
-	"github.com/hyphennn/glamda/lslice"
+	"github.com/hyphennn/glamda/gstream"
 )
 
 func main() {
-	s := []int{1, 1, 4, 5, 1, 4}
-	ss := lslice.Map(s, func(f int) int {
-		return f + 1
-	})
-	fmt.Println(ss) //[2 2 5 6 2 5]
+	s := []int{1, 1, 4, 5, 1, 4, 114514, 0, 0, 0}
+	s2 := gstream.AsSliceStream(s).Filter(func(i int) bool {
+		return i%2 == 0
+	}).Convert(func(i int) int {
+		return i + 1
+	}).Sort(func(t1, t2 int) bool {
+		return t1 < t2
+	}).Collect()
+	fmt.Println(s2) // [1 1 1 5 5 114515]
 }
 ```
 
-Dedicated to providing a go lamda expression library that does not introduce any additional dependencies and only incurs minimal additional performance costs
+致力于构建一个 Go Stream API 以及一些常用的泛型、闭包工具，并且不引入任何第三方依赖以及过多的性能消耗
 
+Source of inspiration: Bytedance code.byted.org.lang/gg
 
+This package was not open source when the author resigned, and a similar repository was not found, so this package was
+made based on some ideas from the Java Stream API and lang/gg
 
-Inspiration source: ByteDance code.byted.org/lang/gg
-
-
-
-This package was not yet open source at the time of the author's resignation, and also cannot find a similar repository, so some ideas from lang/gg were used to create this package. If lang/gg plans to open source it in the future, please feel free to contact me so that ownership of this repository can be transferred
-
-致力于提供一个不引入任何额外依赖以及只带来极小额外性能成本的 go lamda 表达式库，涵盖面向 go 的一些 lamda 常用表达式
+致力于构建一个 Go Stream API 以及一些常用的泛型、闭包工具，并且不引入任何第三方依赖以及过多的性能消耗
 
 灵感来源：字节跳动 code.byted.org/lang/gg
 
-此包在作者离职时仍未开源，也未找到一个类似的仓库，因此基于 lang/gg 的一些思想做了此包，若后续 lang/gg 计划开源，欢迎联系我，可以转移此仓库的所有权
-
-注：所有代码均为手写，个人理解不存在侵权问题，如果 lang/gg 愿意开源自然更好
+此包在作者离职时仍未开源，也未找到一个类似的仓库，因此基于 Java Stream API 以及 lang/gg 的一些思想做了此包

…ion/disjoint-set/disjoint-set-with-pc.go …ion/disjoint-set/disjoint-set-with-pc.golcollection/disjoint-set/disjoint-set-with-pc.go renamed to gcollection/disjoint-set/disjoint-set-with-pc.go lcollection/disjoint-set/disjoint-set-with-pc.go renamed to gcollection/disjoint-set/disjoint-set-with-pc.go

@@ -8,7 +8,7 @@ package disjoint_set
 import (
 	"fmt"
 
-	"github.com/hyphennn/glamda/lutils"
+	"github.com/hyphennn/glamda/gutils"
 )
 
 type DisjointSetWithPC[T comparable] struct {
@@ -34,7 +34,7 @@ func (d *DisjointSetWithPC[T]) Find(value T) (T, error) {
 }
 
 func (d *DisjointSetWithPC[T]) innerFind(value T) T {
-	return lutils.TernaryForm(d.parent[value] != value, func() T {
+	return gutils.TernaryForm(d.parent[value] != value, func() T {
 		d.parent[value] = d.innerFind(d.parent[value])
 		return value
 	}(), d.parent[value])

lcollection/disjoint-set/disjoint-set.go gcollection/disjoint-set/disjoint-set.golcollection/disjoint-set/disjoint-set.go renamed to gcollection/disjoint-set/disjoint-set.go

@@ -1,8 +1,8 @@
-// Package lset
+// Package gset
 // Author: hyphen
 // Copyright 2023 hyphen. All rights reserved.
 // Create-time: 2023/12/8
-package lset
+package gset
 
 type SliceSet[K comparable, V any] struct {
 	m     map[K]int

lcollection/disjoint-set/factory.go gcollection/disjoint-set/factory.golcollection/disjoint-set/factory.go renamed to gcollection/disjoint-set/factory.go

@@ -1,4 +1,4 @@
-package lmap
+package gmap
 
 func Map[K1, K2 comparable, V1, V2 any](m map[K1]V1, fc func(K1, V1) (K2, V2)) map[K2]V2 {
 	ret := make(map[K2]V2, len(m))

lcollection/lset/slice-set.go gcollection/gset/slice-set.golcollection/lset/slice-set.go renamed to gcollection/gset/slice-set.go

@@ -1,28 +1,28 @@
-// Package lmap
+// Package gmap
 // Author: hyphen
 // Copyright 2023 hyphen. All rights reserved.
 // Create-time: 2023/12/8
-package lmap_test
+package gmap_test
 
 import (
 	"strconv"
 	"testing"
 
+	"github.com/hyphennn/glamda/gmap"
 	"github.com/hyphennn/glamda/internal/assert"
-	"github.com/hyphennn/glamda/lmap"
 )
 
 func TestMap(t *testing.T) {
 	assert.Equal(t,
 		map[string]string{"1": "1", "4": "4", "5": "5"},
-		lmap.Map(map[int]int{1: 1, 4: 4, 5: 5}, func(k1 int, v1 int) (string, string) {
+		gmap.Map(map[int]int{1: 1, 4: 4, 5: 5}, func(k1 int, v1 int) (string, string) {
 			return strconv.Itoa(k1), strconv.Itoa(v1)
 		}))
 }
 
 func TestUnion(t *testing.T) {
 	assert.Equal(t,
 		map[string]string{"1": "1", "4": "4", "5": "5"},
-		lmap.Union(map[string]string{"1": "1", "4": "4"}, map[string]string{"4": "4", "5": "5"}),
+		gmap.Union(map[string]string{"1": "1", "4": "4"}, map[string]string{"4": "4", "5": "5"}),
 	)
 }

lmap/lmap.go gmap/gmap.golmap/lmap.go renamed to gmap/gmap.go

@@ -1,8 +1,8 @@
-// Package lmap
+// Package gmap
 // Author: hyphen
 // Copyright 2023 hyphen. All rights reserved.
 // Create-time: 2023/12/8
-package lmap
+package gmap
 
 func Union[K comparable, V any](ms ...map[K]V) map[K]V {
 	if len(ms) == 0 {

lmap/lmap_test.go gmap/gmap_test.golmap/lmap_test.go renamed to gmap/gmap_test.go

@@ -1,8 +1,8 @@
-// Package lslice
+// Package gslice
 // Author: hyphen
 // Copyright 2023 hyphen. All rights reserved.
 // Create-time: 2023/12/4
-package lslice
+package gslice
 
 func Map[F, T any](s []F, fc func(F) T) []T {
 	ret := make([]T, 0, len(s))

lmap/union.go gmap/union.golmap/union.go renamed to gmap/union.go

@@ -1,45 +1,45 @@
-// Package lslice
+// Package gslice
 // Author: hyphen
 // Copyright 2023 hyphen. All rights reserved.
 // Create-time: 2023/12/4
-package lslice_test
+package gslice_test
 
 import (
 	"strconv"
 	"testing"
 
+	"github.com/hyphennn/glamda/gslice"
 	"github.com/hyphennn/glamda/internal/assert"
-	"github.com/hyphennn/glamda/lslice"
 )
 
 func TestMap(t *testing.T) {
 	assert.Equal(t,
-		lslice.Map([]int{1, 1, 4, 5, 1, 4}, strconv.Itoa),
+		gslice.Map([]int{1, 1, 4, 5, 1, 4}, strconv.Itoa),
 		[]string{"1", "1", "4", "5", "1", "4"},
 	)
 }
 
 func TestToMap(t *testing.T) {
 	assert.Equal(t,
 		map[int]bool{1: true, 4: true, 5: true},
-		lslice.ToMap([]int{1, 1, 4, 5, 1, 4}, func(f int) (int, bool) { return f, true }),
+		gslice.ToMap([]int{1, 1, 4, 5, 1, 4}, func(f int) (int, bool) { return f, true }),
 	)
 }
 
 func TestTryMap(t *testing.T) {
-	m, err := lslice.TryMap([]string{"1", "1", "4", "5", "1", "4"}, strconv.Atoi)
+	m, err := gslice.TryMap([]string{"1", "1", "4", "5", "1", "4"}, strconv.Atoi)
 	assert.Nil(t, err)
 	assert.Equal(t, m, []int{1, 1, 4, 5, 1, 4})
 
-	m2, err := lslice.TryMap([]string{"1", "1", "4", "5a", "1", "4"}, strconv.Atoi)
+	m2, err := gslice.TryMap([]string{"1", "1", "4", "5a", "1", "4"}, strconv.Atoi)
 	t.Log(err)
 	assert.NotNil(t, err)
 	assert.Equal(t, m2, []int{1, 1, 4})
 }
 
 func TestFilter(t *testing.T) {
 	assert.Equal(t,
-		lslice.Filter([]int{1, 1, 4, 5, 1, 4}, func(i int) bool {
+		gslice.Filter([]int{1, 1, 4, 5, 1, 4}, func(i int) bool {
 			return i%2 == 1
 		}),
 		[]int{1, 1, 5, 1},