Merge pull request #44470 from hashicorp/f-iter-funcs

Add `WithError` functions to `internal/slices`

Author: ewbankkit

internal/service/ec2/find.go

@@ -409,12 +409,10 @@ func findInstanceByID(ctx context.Context, conn *ec2.Client, id string) (*awstyp
 }
 
 func findInstance(ctx context.Context, conn *ec2.Client, input *ec2.DescribeInstancesInput) (*awstypes.Instance, error) {
-	var output []awstypes.Instance
-	for v, err := range listInstances(ctx, conn, input) {
-		if err != nil {
-			return nil, err
-		}
-		output = append(output, v)
+	output, err := tfslices.CollectWithError(listInstances(ctx, conn, input))
+
+	if err != nil {
+		return nil, err
 	}
 
 	return tfresource.AssertSingleValueResult(output, func(v *awstypes.Instance) bool { return v.State != nil })

internal/slices/slices.go

@@ -4,6 +4,7 @@
 package slices
 
 import (
+	"iter"
 	"slices"
 )
 
@@ -167,3 +168,23 @@ func Strings[S ~[]E, E stringable](s S) []string {
 		return string(e)
 	})
 }
+
+// CollectWithError collects values from seq into a new slice and returns it.
+// The first non-nil error in seq is returned.
+// If seq is empty, the result is nil.
+func CollectWithError[E any](seq iter.Seq2[E, error]) ([]E, error) {
+	return AppendSeqWithError([]E(nil), seq)
+}
+
+// AppendSeqWithError appends the values from seq to the slice and returns the extended slice.
+// The first non-nil error in seq is returned.
+// If seq is empty, the result preserves the nilness of s.
+func AppendSeqWithError[S ~[]E, E any](s S, seq iter.Seq2[E, error]) (S, error) {
+	for v, err := range seq {
+		if err != nil {
+			return nil, err
+		}
+		s = append(s, v)
+	}
+	return s, nil
+}

internal/slices/slices_test.go

@@ -4,6 +4,8 @@
 package slices
 
 import (
+	"errors"
+	"maps"
 	"strings"
 	"testing"
 
@@ -365,3 +367,46 @@ func TestRange(t *testing.T) {
 		})
 	}
 }
+
+func TestCollectWithError(t *testing.T) {
+	t.Parallel()
+
+	type testCase struct {
+		input   map[int]error
+		wantErr bool
+	}
+	tests := map[string]testCase{
+		"no error": {
+			input: map[int]error{
+				1: nil,
+				2: nil,
+				3: nil,
+			},
+		},
+		"has error": {
+			input: map[int]error{
+				1: nil,
+				2: errors.New("test error"),
+				3: nil,
+			},
+			wantErr: true,
+		},
+	}
+
+	for name, test := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := CollectWithError(maps.All(test.input))
+
+			if got, want := err != nil, test.wantErr; !cmp.Equal(got, want) {
+				t.Errorf("CollectWithError() err %t, want %t", got, want)
+			}
+			if err == nil {
+				if got, want := len(got), len(test.input); !cmp.Equal(got, want) {
+					t.Errorf("CollectWithError() len %d, want %d", got, want)
+				}
+			}
+		})
+	}
+}