rename From to InSlice and Slice to ToSlice

this is a breaking change but improves consistency, I guess.

It also paves the road for functions taking in a map and providing
a pairs iterator over the key value pairs.

Author: 0x5a17ed

Diff for: README.md

@@ -27,12 +27,12 @@ func main() {
 	s := []int{1, 2, 3}
 
 	// iterating using the for keyword.
-	for it := itkit.From(s); it.Next(); {
+	for it := itkit.InSlice(s); it.Next(); {
 		fmt.Println(it.Value())
 	}
 
 	// iterating using a slightly more functional approach.
-	itkit.Apply(itkit.From(s), func(v int) {
+	itkit.Apply(itkit.InSlice(s), func(v int) {
 		fmt.Println(v)
 	})
 }

Diff for: _example/simple/main.go

@@ -10,12 +10,12 @@ func main() {
 	s := []int{1, 2, 3}
 
 	// iterating using the for keyword.
-	for it := itkit.From(s); it.Next(); {
+	for it := itkit.InSlice(s); it.Next(); {
 		fmt.Println(it.Value())
 	}
 
 	// iterating using a slightly more functional approach.
-	itkit.Apply(itkit.From(s), func(v int) {
+	itkit.Apply(itkit.InSlice(s), func(v int) {
 		fmt.Println(v)
 	})
 }

Diff for: chain.go

@@ -51,5 +51,5 @@ func ChainI[T any](iters Iterator[Iterator[T]]) Iterator[T] {
 
 // ChainV is the variadic version of ChainI.
 func ChainV[T any](iters ...Iterator[T]) Iterator[T] {
-	return ChainI(From(iters))
+	return ChainI(InSlice(iters))
 }

Diff for: chain_test.go

@@ -35,33 +35,33 @@ func TestChain(t *testing.T) {
 		{"empty", args{[]itkit.Iterator[int]{itkit.Empty[int]()}}, []int(nil)},
 
 		{"one", args{[]itkit.Iterator[int]{
-			itkit.From([]int{1, 2, 3}),
+			itkit.InSlice([]int{1, 2, 3}),
 		}}, []int{1, 2, 3}},
 
 		{"two", args{[]itkit.Iterator[int]{
-			itkit.From([]int{1, 2, 3}),
-			itkit.From([]int{7, 8, 9}),
+			itkit.InSlice([]int{1, 2, 3}),
+			itkit.InSlice([]int{7, 8, 9}),
 		}}, []int{1, 2, 3, 7, 8, 9}},
 
 		{"empty mixed-start", args{[]itkit.Iterator[int]{
 			itkit.Empty[int](),
-			itkit.From([]int{1, 2, 3}),
-			itkit.From([]int{7, 8, 9}),
+			itkit.InSlice([]int{1, 2, 3}),
+			itkit.InSlice([]int{7, 8, 9}),
 		}}, []int{1, 2, 3, 7, 8, 9}},
 		{"empty mixed-middle", args{[]itkit.Iterator[int]{
-			itkit.From([]int{1, 2, 3}),
+			itkit.InSlice([]int{1, 2, 3}),
 			itkit.Empty[int](),
-			itkit.From([]int{7, 8, 9}),
+			itkit.InSlice([]int{7, 8, 9}),
 		}}, []int{1, 2, 3, 7, 8, 9}},
 		{"empty mixed-end", args{[]itkit.Iterator[int]{
-			itkit.From([]int{1, 2, 3}),
-			itkit.From([]int{7, 8, 9}),
+			itkit.InSlice([]int{1, 2, 3}),
+			itkit.InSlice([]int{7, 8, 9}),
 			itkit.Empty[int](),
 		}}, []int{1, 2, 3, 7, 8, 9}},
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			got := itkit.Slice(itkit.ChainV(test.args.iters...))
+			got := itkit.ToSlice(itkit.ChainV(test.args.iters...))
 			assertpkg.Equal(t, test.wanted, got)
 		})
 	}

Diff for: channel_test.go

@@ -29,6 +29,6 @@ func TestChannel(t *testing.T) {
 	}
 	close(ch)
 
-	s := itkit.Slice(itkit.Channel(ch))
+	s := itkit.ToSlice(itkit.Channel(ch))
 	assertpkg.Equal(t, []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, s)
 }

Diff for: filter_test.go

@@ -25,7 +25,7 @@ import (
 func TestFilter(t *testing.T) {
 	t.Run("FilterRange", func(t *testing.T) {
 		assert := assertpkg.New(t)
-		s := itkit.Slice(itkit.Filter(itkit.Range(10), func(i int) bool { return i%2 == 0 }))
+		s := itkit.ToSlice(itkit.Filter(itkit.Range(10), func(i int) bool { return i%2 == 0 }))
 		assert.Equal([]int{0, 2, 4, 6, 8}, s)
 	})
 

Diff for: find_test.go

@@ -39,7 +39,7 @@ func TestFind(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			assert := assertpkg.New(t)
 
-			it := itkit.From([]int{1, 2, 3, 4, 5})
+			it := itkit.InSlice([]int{1, 2, 3, 4, 5})
 
 			gotOut, gotOk := itkit.Find(it, compareFn, tc.needle)
 			assert.Equal(tc.wantOk, gotOk)

Diff for: generator_test.go

@@ -28,7 +28,7 @@ import (
 func TestGenerator(t *testing.T) {
 	defer goleak.VerifyNone(t)
 
-	s := itkit.Slice(itkit.Generator(func(g *itkit.G[int]) {
+	s := itkit.ToSlice(itkit.Generator(func(g *itkit.G[int]) {
 		for i := 1; i < 5; i++ {
 			g.Send(i)
 		}

Diff for: map_test.go

@@ -24,6 +24,6 @@ import (
 
 func TestMap(t *testing.T) {
 	assert := assertpkg.New(t)
-	s := itkit.Slice(itkit.Map(itkit.Runes("Hello World!"), func(r rune) string { return string(r) }))
+	s := itkit.ToSlice(itkit.Map(itkit.Runes("Hello World!"), func(r rune) string { return string(r) }))
 	assert.Equal([]string{"H", "e", "l", "l", "o", " ", "W", "o", "r", "l", "d", "!"}, s)
 }

Diff for: maps_test.go

@@ -37,7 +37,7 @@ func TestKeys_String(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := itkit.Slice(itkit.Keys(tt.given).Iter())
+			got := itkit.ToSlice(itkit.Keys(tt.given).Iter())
 			sort.Strings(got)
 			assertpkg.Equalf(t, tt.wanted, got, "Keys(%v)", tt.given)
 		})

Diff for: range_test.go

@@ -35,7 +35,7 @@ func TestRange(t *testing.T) {
 			return itkit.Range(10)
 		}}, []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}},
 
-		{"From", args{fn: func() itkit.Iterator[int] {
+		{"InSlice", args{fn: func() itkit.Iterator[int] {
 			return itkit.RangeFrom(5, 10)
 		}}, []int{5, 6, 7, 8, 9}},
 		{"WithStep", args{fn: func() itkit.Iterator[int] {
@@ -52,7 +52,7 @@ func TestRange(t *testing.T) {
 	for _, tc := range tt {
 		t.Run(tc.name, func(t *testing.T) {
 			assert := assertpkg.New(t)
-			assert.Equal(itkit.Slice(tc.args.fn()), tc.want)
+			assert.Equal(itkit.ToSlice(tc.args.fn()), tc.want)
 		})
 	}
 }

Diff for: slice.go

@@ -39,14 +39,13 @@ func (it *SliceIterator[T]) Value() T {
 	return *it.current
 }
 
-// From returns an iterator yielding items from the given slice.
-func From[T any](s []T) Iterator[T] {
+// InSlice returns an [Iterator] yielding items in the given slice.
+func InSlice[T any](s []T) Iterator[T] {
 	return &SliceIterator[T]{Data: s}
 }
 
-// Slice consumes the iterator iterkit.Iterator returning its
-// elements as a Go slice.
-func Slice[T any](it Iterator[T]) (out []T) {
+// ToSlice consumes the [Iterator] returning its elements as a Go slice.
+func ToSlice[T any](it Iterator[T]) (out []T) {
 	for it.Next() {
 		out = append(out, it.Value())
 	}

Diff for: slice_test.go

@@ -25,12 +25,12 @@ import (
 func TestSlice(t *testing.T) {
 	assert := assertpkg.New(t)
 
-	s := itkit.Slice(itkit.Range(10))
+	s := itkit.ToSlice(itkit.Range(10))
 	assert.Equal([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, s)
 }
 
 func TestSliceIterator(t *testing.T) {
-	it := itkit.From([]int{1, 2, 3})
+	it := itkit.InSlice([]int{1, 2, 3})
 
 	var values []int
 	for it.Next() {

Diff for: string.go

@@ -67,5 +67,5 @@ func Runes(v string) Iterator[rune] {
 // String consumes the given rune iterator and returns the content as
 // a string.
 func String(it Iterator[rune]) string {
-	return string(Slice(it))
+	return string(ToSlice(it))
 }

Diff for: string_test.go

@@ -22,17 +22,17 @@ import (
 
 func TestString(t *testing.T) {
 	t.Run("unicode", func(t *testing.T) {
-		s := Slice(Runes("日本\x80語"))
+		s := ToSlice(Runes("日本\x80語"))
 		assert.Equal(t, []rune{0x65E5, 0x672C, 0xFFFD, 0x8A9E}, s)
 	})
 
 	t.Run("ascii", func(t *testing.T) {
-		s := Slice(Runes("Hello World"))
+		s := ToSlice(Runes("Hello World"))
 		assert.Equal(t, []rune{0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64}, s)
 	})
 
 	t.Run("late unicode", func(t *testing.T) {
-		s := Slice(Runes("Hello Wörld"))
+		s := ToSlice(Runes("Hello Wörld"))
 		assert.Equal(t, []rune{0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0xf6, 0x72, 0x6c, 0x64}, s)
 	})
 }