iter-err: add ForEachErr and ForEachIdxErr

[ninedraft]

Adding error returning iterators

[ninedraft]

Fixed linter issues

[codecov-commenter]

Codecov Report

Merging #104 (8bde958) into main (8e5ba59) will increase coverage by 0.05%.
The diff coverage is 100.00%.

@@            Coverage Diff             @@
##             main     #104      +/-   ##
==========================================
+ Coverage   99.30%   99.36%   +0.05%     
==========================================
  Files          12       12              
  Lines         433      474      +41     
==========================================
+ Hits          430      471      +41     
  Misses          3        3              

Impacted Files	Coverage Δ
iter/iter.go	100.00% <100.00%> (ø)

📣 We’re building smart automated test selection to slash your CI/CD build times. Learn more

[camdencheek]

This is great work! A couple small comments inline.

[camdencheek]

It looks to me like FailFast does not guarantee returning only the error that caused the failure. One task can check if failed was set, error, and append its error while another task concurrently failed and appends an error.

I think this counts as surprising behavior given that the rest of the library guarantees that only the first error is retained when WithFirstError() is used.

I think we can fix this by checking the old value of failed:

Suggested change

	task := func() {
	i := int(idx.Add(1) - 1)
	for ; i < numInput && !failed.Load(); i = int(idx.Add(1) - 1) {
	if err := f(i, &input[i]); err != nil {
	errsMu.Lock()
	errs = multierror.Join(errs, err)
	errsMu.Unlock()
	failed.Store(iter.FailFast)
	}
	}
	}
	task := func() {
	i := int(idx.Add(1) - 1)
	for ; i < numInput && !failed.Load(); i = int(idx.Add(1) - 1) {
	if err := f(i, &input[i]); err != nil {
	if alreadyFailedFast := failed.Swap(iter.FailFast); !alreadyFailedFast {
	errsMu.Lock()
	errs = multierror.Join(errs, err)
	errsMu.Unlock()
	}
	}
	}
	}

[ninedraft]

fixed 👍

[camdencheek]

Looks like a duplicate

Suggested change

	t.Run("mutating inputs is fine", func(t *testing.T) {
	t.Parallel()
	ints := []int{1, 2, 3, 4, 5}
	_ = forEach(ints, func(val *int) error {
	*val += 1
	return nil
	})
	require.Equal(t, []int{2, 3, 4, 5, 6}, ints)
	})
	t.Run("mutating inputs is fine", func(t *testing.T) {
	t.Parallel()
	ints := []int{1, 2, 3, 4, 5}
	_ = forEach(ints, func(val *int) error {
	*val += 1
	return nil
	})
	require.Equal(t, []int{2, 3, 4, 5, 6}, ints)
	})
	t.Run("mutating inputs is fine", func(t *testing.T) {
	t.Parallel()
	ints := []int{1, 2, 3, 4, 5}
	_ = forEach(ints, func(val *int) error {
	*val += 1
	return nil
	})
	require.Equal(t, []int{2, 3, 4, 5, 6}, ints)
	})

[ninedraft]

fixed

[camdencheek]

We should probably make Mapper respect the FailFast flag as well since we already have a MapErr and we don't want that to have different behavior.

[justenstall]

Is this still on the radar?

[ninedraft]

Yeah, I will refine the pr