proposal: iter: add Empty function

[tamayika]

Proposal Details

Add Empty function to iter package.
This function returns empty iterator.

Implementation

package iter

func Empty[T any]() Seq[T] {
	return func(yield func(T) bool) {}
}

func Empty2[K, V any]() Seq2[K, V] {
	return func(yield func(K, V) bool) {}
}

Usage

This function is useful to replace slice/map implementation to iter implementation.
Please see following code.
This function do something to all item when cond is true.

func do(cond bool) {
	var all []int
	if cond {
		all = findAll()
	}
	for _, v := range all {
		doItem(v)
	}
}

#65629 was declined, so range over nil function panics.
I have to rewrite like following.

func do(cond bool) {
	var all iter.Seq[int]
	if cond {
		all = findAll()
	}
	if all == nil {
		return
	}
	for _, v := range all {
		doItem(v)
	}
}

When Empty function exists, I can migrate code easily.

func do(cond bool) {
	var all = iter.Empty[int]()
	if cond {
		all = findAll()
	}
	for _, v := range all {
		doItem(v)
	}
}

[DeedleFake]

I know the code is contrived as an example, but couldn't you rewrite it as

if cond {
  if all := findAll(); all != nil {
    for _, v := range all {
      doItem(v)
    }
  }
}

instead? And what is findAll() that it would return nil instead of an empty iterator itself? What circumstances would necessitate this particular approach to it often enough that writing func(func(int) bool) {} manually would be too much of a problem?

[tamayika]

I prefer unnested code.
If this function needs error handling, is it understandable situation?

func do(cond bool) error {
	var all = iter.Empty[int]()
	if cond {
		var err error
		all, err = findAll()
		if err != nil {
			return fmt.Errorf("failed to find all: %w", err)
		}
	}
	for _, v := range all {
		doItem(v)
	}
	return nil
}

v.s.

func do(cond bool) error {
	if cond {
		if all, err := findAll(); err != nil {
			return fmt.Errorf("failed to find all: %w", err)
		} else if all != nil {
			for _, v := range all {
				doItem(v)
			}
		}
	}
	return nil
}

writing func(func(int) bool) {} manually would be too much of a problem?

I think it's less readable.

var all = func(func(int) bool) {} // what's this!?

v.s.

var all = iter.Empty[int]() // I see, this is empty iterator.

[DeedleFake]

How about

func do(cond bool) error {
  if !cond {
    return nil
  }

  all, err := findAll()
  if err != nil {
    return fmt.Errorf("failed to find all: %w", err)
  }
  if all == nil {
    return nil
  }

  for _, v := range all {
    doItem(v)
  }
  return nil
}

instead? And again, what is findAll() that it can return a nil error and and a nil iter.Seq? Why would it not just return an empty iter.Seq itself in the non-error case?

I just can't see this kind of thing coming up very often. Maybe I'm wrong, but I feel like this should be added once it's proven to be an annoyance, rather than in advance as a counter to what seems likely to me to be a non-existent problem.

[tamayika]

Please consider the sutuation you can't early return by

  if !cond {
    return nil
  }

because we need to do some after iteration

  for _, v := range all {
    doItem(v)
  }
  doAfterIteration()
  return nil

I just want to say there are many codes which depends on iteration safety of nil slice/map.
And it becomes problem when we replace to iter implementation, so we need the direct replacement for this.
You should write like this insteadly means nothing in this case.

[tamayika]

How about this case?
Do you write empty iterator manually or add nil checks to all getIds() referenced codes?

func getIds() []int {
	if condA {
		return nil
	}
	somethingAfterA()
	if condB {
		return nil
	}
	somethingAfterB()
	if condC {
		return nil
	}
	somethingAfterC()
	return getIdsImpl()
}

func do() {
	for _, v := range getIds() {
		println(v)
	}
}

When iter.Empty() exists, I can migrate directly.

func getIds() iter.Seq[int] {
	if condA {
		return iter.Empty[int]()
	}
	somethingAfterA()
	if condB {
		return iter.Empty[int]()
	}
	somethingAfterB()
	if condC {
		return iter.Empty[int]()
	}
	somethingAfterC()
	return getIdsImpl()
}

func do() {
	for _, v := range getIds() {
		println(v)
	}
}

[Wani4ka]

That would be really useful. For now, it is possible to use iter.Seq[[]int](nil), which, according to benchmarks, has the same performance as if it was an empty yield function. Although this nil approach looks counter intuitive and could raise some questions when met in the code

Code

package main

import (
	"iter"
	"slices"
	"testing"
)

func getIter1[T any]() iter.Seq[T] {
	return slices.Values[[]T](nil)
}

func getIter2[T any]() iter.Seq[T] {
	return func(yield func(T) bool) {}
}

func BenchmarkIterNil(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		sum := 0
		for num := range getIter1[int]() {
			sum += num
		}
	}
}

func BenchmarkIterEmpty(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		sum := 0
		for num := range getIter2[int]() {
			sum += num
		}
	}
}

Benchmarks

goos: darwin
goarch: arm64
pkg: upstream2
cpu: Apple M1
BenchmarkIterNil
BenchmarkIterNil-8     	1000000000	         0.4371 ns/op	       0 B/op	       0 allocs/op
BenchmarkIterEmpty
BenchmarkIterEmpty-8   	1000000000	         0.4406 ns/op	       0 B/op	       0 allocs/op
PASS