Match naming conventions for Seq on Count (-> NaturalNumbers)

README.md

@@ -7,14 +7,14 @@ A library of iterators for use with `iter.Seq`. Requires Go 1.23+.
 ```go
 // The first 5 natural numbers
 numbers := slices.Collect(
-	it.Take(it.Count[int](), 5),
+	it.Take(it.NaturalNumbers[int](), 5),
 )
 
 // All even numbers
-evens := it.Filter(it.Count[int](), filter.IsEven)
+evens := it.Filter(it.NaturalNumbers[int](), filter.IsEven)
 
 // String representations of integers
-numbers := it.Map(it.Count[int](), strconv.Itoa)
+numbers := it.Map(it.NaturalNumbers[int](), strconv.Itoa)
 ```
 
 _[Read the docs](https://pkg.go.dev/github.com/BooleanCat/go-functional/v2)_ to see the full iterator library.
@@ -38,7 +38,7 @@ Let's take a look at an example:
 
 ```go
 // The first 10 odd integers
-itx.Count[int]().Filter(filter.IsOdd).Take(10).Collect()
+itx.NaturalNumbers[int]().Filter(filter.IsOdd).Take(10).Collect()
 ```
 
 Most iterators support chaining. A notable exception is `it.Map` which cannot

it/chain_test.go

@@ -29,7 +29,7 @@ func TestChainMany(t *testing.T) {
 
 	numbers := slices.Collect(it.Chain(
 		slices.Values([]int{1, 2}),
-		it.Take(it.Drop(it.Count[int](), 3), 2),
+		it.Take(it.Drop(it.NaturalNumbers[int](), 3), 2),
 		slices.Values([]int{5, 6}),
 	))
 

it/integers.go

@@ -0,0 +1,28 @@
+package it
+
+import "iter"
+
+// Integers yields all integers in the range [start, stop) with the given step.
+func Integers[V ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | ~int | ~int8 | ~int16 | ~int32 | ~int64](start, stop, step V) iter.Seq[V] {
+	return func(yield func(V) bool) {
+		for i := start; i < stop; i += step {
+			if !yield(i) {
+				return
+			}
+		}
+	}
+}
+
+// NaturalNumbers yields all non-negative integers in ascending order.
+func NaturalNumbers[V ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | ~int | ~int8 | ~int16 | ~int32 | ~int64]() iter.Seq[V] {
+	return func(yield func(V) bool) {
+		var i V
+
+		for {
+			if !yield(i) {
+				return
+			}
+			i++
+		}
+	}
+}

it/integers_test.go

@@ -0,0 +1,44 @@
+package it_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/BooleanCat/go-functional/v2/it"
+)
+
+func ExampleNaturalNumbers() {
+	for i := range it.NaturalNumbers[int]() {
+		if i >= 3 {
+			break
+		}
+
+		fmt.Println(i)
+	}
+
+	// Output:
+	// 0
+	// 1
+	// 2
+}
+
+func ExampleIntegers() {
+	for i := range it.Integers[uint](0, 3, 1) {
+		fmt.Println(i)
+	}
+
+	// Output:
+	// 0
+	// 1
+	// 2
+}
+
+func TestIntegersYieldFalse(t *testing.T) {
+	t.Parallel()
+
+	numbers := it.Integers[uint](0, 3, 1)
+
+	numbers(func(value uint) bool {
+		return false
+	})
+}

it/itx/integers.go

@@ -0,0 +1,13 @@
+package itx
+
+import "github.com/BooleanCat/go-functional/v2/it"
+
+// Integers yields all integers in the range [start, stop) with the given step.
+func Integers[V ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | ~int | ~int8 | ~int16 | ~int32 | ~int64](start, stop, step V) Iterator[V] {
+	return Iterator[V](it.Integers[V](start, stop, step))
+}
+
+// NaturalNumbers yields all non-negative integers in ascending order.
+func NaturalNumbers[V ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | ~int | ~int8 | ~int16 | ~int32 | ~int64]() Iterator[V] {
+	return Iterator[V](it.NaturalNumbers[V]())
+}

it/itx/integers_test.go

@@ -0,0 +1,17 @@
+package itx_test
+
+import (
+	"fmt"
+
+	"github.com/BooleanCat/go-functional/v2/it/itx"
+)
+
+func ExampleNaturalNumbers() {
+	fmt.Println(itx.NaturalNumbers[int]().Take(4).Collect())
+	// Output: [0 1 2 3]
+}
+
+func ExampleIntegers() {
+	fmt.Println(itx.Integers[uint](0, 3, 1).Collect())
+	// Output: [0 1 2]
+}

it/itx/iter_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func ExampleIterator_Seq() {
-	fmt.Println(slices.Collect(itx.Count[int]().Take(3).Seq()))
+	fmt.Println(slices.Collect(itx.NaturalNumbers[int]().Take(3).Seq()))
 	// Output: [0 1 2]
 }
 

it/itx/zip_test.go

@@ -3,6 +3,7 @@ package itx_test
 import (
 	"fmt"
 	"maps"
+	"strings"
 	"testing"
 
 	"github.com/BooleanCat/go-functional/v2/internal/assert"
@@ -29,10 +30,10 @@ func TestUnzipMethod(t *testing.T) {
 }
 
 func ExampleIterator2_Left() {
-	for key := range itx.From2(maps.All(map[int]string{1: "one"})).Left() {
-		fmt.Println(key)
-	}
-	// Output: 1
+	text := strings.NewReader("one\ntwo\nthree\n")
+
+	fmt.Println(itx.LinesString(text).Left().Collect())
+	// Output: [one two three]
 }
 
 func ExampleIterator2_Right() {