Add DropWhile iterator

Author: BooleanCat

README.md

@@ -381,7 +381,7 @@ numbers := itx.FromMap(map[int]string{1: "one"}).Cycle().Take(5)
 > otherwise it's likely to result in an infinite while loop. Consider bounding the size of the
 > iterator before consuming (e.g. using [Take](#take)).
 
-### Drop
+<h3 id="drop">Drop & DropWhile</h3>
 
 Drop yields all values from a delegate iterator after dropping a number of values from the
 beginning. Values are not dropped immediately, but when consumption begins.
@@ -402,6 +402,24 @@ numbers := it.Drop2(maps.All(map[int]string{1: "one", 2: "two", 3: "three"}), 1)
 numbers := itx.FromMap(map[int]string{1: "one", 2: "two", 3: "three"}).Drop(1)
 ```
 
+DropWhile drops values from the provided iterator whilst the predicate returns true for each value.
+After the first value results in the predicate returning false, the iterator resumes as normal.
+
+```go
+slices.Collect(it.DropWhile(slices.Values([]int{1, 2, 3, 4, 5}), filter.LessThan(3)))
+
+// Chainable
+itx.FromSlice([]int{1, 2, 3, 4, 5}).DropWhile(filter.LessThan(3)).Collect()
+
+lessThanThree := func(string, number int) { return number < 3 }
+
+// Taking from iter.Seq2
+maps.Collect(it.DropWhile2(maps.All(map[string]int{"one": 1, "four": 4}), lessThanThree))
+
+// As above, but chainable
+itx.FromMap(map[string]int{"one": 1, "four": 4}).DropWhile(lessThanThree).Collect()
+```
+
 ### Enumerate
 
 Enumerating an [iter.Seq](https://pkg.go.dev/iter#Seq) like iterator returns an
@@ -713,20 +731,18 @@ TakeWhile yields values from the provided iterator whilst the predicate returns
 After the first value results in the predicate returning false, the iterator is exhausted.
 
 ```go
-lessThanThree := func(number int) { number < 3 }
-
-slices.Collect(it.TakeWhile(slices.Values([]int{1, 2, 3}), lessThanThree))
+slices.Collect(it.TakeWhile(slices.Values([]int{1, 2, 3}), filter.LessThan(3)))
 
 // Chainable
-itx.FromSlice([]int{1, 2, 3}).TakeWhile(lessThanThree).Collect()
+itx.FromSlice([]int{1, 2, 3}).TakeWhile(filter.LessThan(3)).Collect()
 
-lessThanThreeRight := func(_ string, number int) { return number < 3 }
+lessThanThree := func(string, number int) { return number < 3 }
 
 // Taking from iter.Seq2
-maps.Collect(it.TakeWhile2(maps.All(map[string]int{"one": 1, "four": 4}), lessThanThreeRight))
+maps.Collect(it.TakeWhile2(maps.All(map[string]int{"one": 1, "four": 4}), lessThanThree))
 
 // As above, but chainable
-itx.FromMap(map[string]int{"one": 1, "four": 4}).TakeWhile(lessThanThreeRight).Collect()
+itx.FromMap(map[string]int{"one": 1, "four": 4}).TakeWhile(lessThanThree).Collect()
 ```
 
 ### Zip, Left & Right

it/drop.go

@@ -33,3 +33,39 @@ func Drop2[V, W any](delegate func(func(V, W) bool), count uint) iter.Seq2[V, W]
 		}
 	}
 }
+
+// DropWhile yields all values from a delegate iterator after the predicate
+// returns false.
+func DropWhile[V any](delegate func(func(V) bool), predicate func(V) bool) iter.Seq[V] {
+	return func(yield func(V) bool) {
+		dropped := false
+		for value := range delegate {
+			if !dropped && predicate(value) {
+				continue
+			}
+
+			dropped = true
+			if !yield(value) {
+				return
+			}
+		}
+	}
+}
+
+// DropWhile2 yields all pairs of values from a delegate iterator after the
+// predicate returns false.
+func DropWhile2[V, W any](delegate func(func(V, W) bool), predicate func(V, W) bool) iter.Seq2[V, W] {
+	return func(yield func(V, W) bool) {
+		dropped := false
+		for v, w := range delegate {
+			if !dropped && predicate(v, w) {
+				continue
+			}
+
+			dropped = true
+			if !yield(v, w) {
+				return
+			}
+		}
+	}
+}

it/drop_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/BooleanCat/go-functional/v2/internal/assert"
 	"github.com/BooleanCat/go-functional/v2/it"
+	"github.com/BooleanCat/go-functional/v2/it/filter"
 )
 
 func ExampleDrop() {
@@ -79,3 +80,87 @@ func TestDrop2YieldFalse(t *testing.T) {
 		return false
 	})
 }
+
+func ExampleDropWhile() {
+	for value := range it.DropWhile(slices.Values([]int{1, 2, 3, 4, 1}), filter.LessThan(3)) {
+		fmt.Println(value)
+	}
+
+	// Output:
+	// 3
+	// 4
+	// 1
+}
+
+func TestDropWhileYieldFalse(t *testing.T) {
+	t.Parallel()
+
+	numbers := it.DropWhile(slices.Values([]int{1, 2, 3, 4, 1}), filter.LessThan(3))
+
+	numbers(func(v int) bool {
+		return false
+	})
+}
+
+func TestDropWhileEmpty(t *testing.T) {
+	t.Parallel()
+
+	assert.Empty[int](t, slices.Collect(it.DropWhile(it.Exhausted[int](), filter.Passthrough)))
+}
+
+func TestDropWhileNeverDrop(t *testing.T) {
+	t.Parallel()
+
+	numbers := slices.Collect(it.DropWhile(slices.Values([]int{1, 2, 3}), func(int) bool { return false }))
+	assert.SliceEqual(t, []int{1, 2, 3}, numbers)
+}
+
+func TestDropWhileDropAll(t *testing.T) {
+	t.Parallel()
+
+	numbers := slices.Collect(it.DropWhile(slices.Values([]int{1, 2, 3}), filter.LessThan(4)))
+	assert.Empty[int](t, numbers)
+}
+
+func ExampleDropWhile2() {
+	_, values := it.Collect2(it.DropWhile2(slices.All([]int{1, 2, 3}), func(int, v int) bool {
+		return v < 3
+	}))
+
+	fmt.Println(values)
+	// Output: [3]
+}
+
+func TestDropWhile2YieldFalse(t *testing.T) {
+	t.Parallel()
+
+	numbers := it.DropWhile2(slices.All([]int{1, 2, 3}), func(int, v int) bool {
+		return v < 3
+	})
+
+	numbers(func(int, v int) bool {
+		return false
+	})
+}
+
+func TestDropWhile2Empty(t *testing.T) {
+	t.Parallel()
+
+	_, values := it.Collect2(it.DropWhile2(it.Exhausted2[int, int](), filter.Passthrough2))
+
+	assert.Empty[int](t, values)
+}
+
+func TestDropWhile2NeverDrop(t *testing.T) {
+	t.Parallel()
+
+	_, values := it.Collect2(it.DropWhile2(slices.All([]int{1, 2, 3}), func(int, int) bool { return false }))
+	assert.SliceEqual(t, []int{1, 2, 3}, values)
+}
+
+func TestDropWhile2DropAll(t *testing.T) {
+	t.Parallel()
+
+	_, values := it.Collect2(it.DropWhile2(slices.All([]int{1, 2, 3}), func(int, int) bool { return true }))
+	assert.Empty[int](t, values)
+}

it/itx/drop.go

@@ -11,3 +11,15 @@ func (iterator Iterator[V]) Drop(count uint) Iterator[V] {
 func (iterator Iterator2[V, W]) Drop(count uint) Iterator2[V, W] {
 	return Iterator2[V, W](it.Drop2(iterator, count))
 }
+
+// DropWhile is a convenience method for chaining [it.DropWhile] on
+// [Iterator]s.
+func (iterator Iterator[V]) DropWhile(predicate func(V) bool) Iterator[V] {
+	return Iterator[V](it.DropWhile(iterator, predicate))
+}
+
+// DropWhile is a convenience method for chaining [it.DropWhile2] on
+// [Iterator2]s.
+func (iterator Iterator2[V, W]) DropWhile(predicate func(V, W) bool) Iterator2[V, W] {
+	return Iterator2[V, W](it.DropWhile2(iterator, predicate))
+}

it/itx/drop_test.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"maps"
 
+	"github.com/BooleanCat/go-functional/v2/it/filter"
 	"github.com/BooleanCat/go-functional/v2/it/itx"
 )
 
@@ -24,3 +25,22 @@ func ExampleIterator2_Drop() {
 	fmt.Println(len(maps.Collect(numbers.Seq())))
 	// Output: 2
 }
+
+func ExampleIterator_DropWhile() {
+	for value := range itx.FromSlice([]int{1, 2, 3, 4, 5}).DropWhile(filter.LessThan(3)) {
+		fmt.Println(value)
+	}
+
+	// Output:
+	// 3
+	// 4
+	// 5
+}
+
+func ExampleIterator2_DropWhile() {
+	lessThanThree := func(int, v int) bool { return v < 3 }
+
+	_, numbers := itx.FromSlice([]int{1, 2, 3, 4, 5}).Enumerate().DropWhile(lessThanThree).Collect()
+	fmt.Println(numbers)
+	// Output: [3 4 5]
+}