ConsumptionOptional now takes a type param

Author: muir

api.go

@@ -286,16 +286,23 @@ func MustConsume[T any](fn any) Provider {
 // TODO: add ExampleConsumptionOptional
 
 // ConsumptionOptional creates a new provider and annotates it as
-// allowed to have some of its return values ignored.
+// allowed to have one of its return values ignored.
 // Without this annotation, a wrap function will not be included
 // if some of its return values are not consumed.
 //
 // In the downward direction, optional consumption is the default.
 //
 // When used on an existing Provider, it creates an annotated copy of that provider.
-func ConsumptionOptional(fn any) Provider {
+//
+// ConsumptionOptional calls may be called on the output of ConsumptionOptional calls
+// to mark more than one type as optional.
+func ConsumptionOptional[T any](fn any) Provider {
 	return newThing(fn).modify(func(fm *provider) {
-		fm.consumptionOptional = true
+		if fm.consumptionOptional == nil {
+			fm.consumptionOptional = make(map[typeCode]struct{})
+		}
+		t := reflect.TypeOf((*T)(nil)).Elem()
+		fm.consumptionOptional[getTypeCode(t)] = struct{}{}
 	})
 }
 

bind.go

@@ -452,7 +452,9 @@ func makeUnusedInputProvider() (*provider, error) {
 	d.nonFinal = true
 	d.cacheable = true
 	d.mustCache = true
-	d.consumptionOptional = true
+	d.consumptionOptional = map[typeCode]struct{}{
+		unusedTypeCode: {},
+	}
 	d, err := characterizeFunc(d, charContext{inputsAreStatic: true})
 	if err != nil {
 		return nil, fmt.Errorf("internal error #328: problem with unused injectors: %w", err)
@@ -472,7 +474,9 @@ func makeUnusedReturnsProvider() (*provider, error) {
 	d.isSynthetic = true
 	d.shun = true
 	d.required = false
-	d.consumptionOptional = true
+	d.consumptionOptional = map[typeCode]struct{}{
+		unusedTypeCode: {},
+	}
 	return d, nil
 }
 

debug.go

@@ -240,28 +240,28 @@ func generateReproduce(funcs []*provider, invokeF *provider, initF *provider) st
 		f += "\t\t\t\t" + extraIndent
 		closeParens := ""
 		for annotation, active := range map[string]bool{
-			"NonFinal":            fm.nonFinal,
-			"Cacheable":           fm.cacheable,
-			"MustCache":           fm.mustCache,
-			"Required":            fm.required,
-			"CallsInner":          fm.callsInner,
-			"Memoize":             fm.memoize,
-			"Reorder":             fm.reorder,
-			"Desired":             fm.desired,
-			"Shun":                fm.shun,
-			"NotCacheable":        fm.notCacheable,
-			"ConsumptionOptional": fm.consumptionOptional,
-			"Singleton":           fm.singleton,
+			"NonFinal":     fm.nonFinal,
+			"Cacheable":    fm.cacheable,
+			"MustCache":    fm.mustCache,
+			"Required":     fm.required,
+			"CallsInner":   fm.callsInner,
+			"Memoize":      fm.memoize,
+			"Reorder":      fm.reorder,
+			"Desired":      fm.desired,
+			"Shun":         fm.shun,
+			"NotCacheable": fm.notCacheable,
+			"Singleton":    fm.singleton,
 		} {
 			if active {
 				f += annotation + "("
 				closeParens += ")"
 			}
 		}
 		for anno, m := range map[string]map[typeCode]struct{}{
-			"ShadowingAllowed": fm.shadowingAllowed,
-			"Loose":            fm.loose,
-			"MustConsume":      fm.mustConsume,
+			"ShadowingAllowed":    fm.shadowingAllowed,
+			"Loose":               fm.loose,
+			"MustConsume":         fm.mustConsume,
+			"ConsumptionOptional": fm.consumptionOptional,
 		} {
 			for tc := range m {
 				f += anno + "[" + tc.String() + "]("

debug_test.go

@@ -80,7 +80,7 @@ func TestDetailedError(t *testing.T) {
 		Memoize(func(i int32) int32 { return i }),
 		OverridesError(func(_ func()) error { return nil }),
 		MustConsume[int64](func(i int32) int64 { return int64(i) }),
-		ConsumptionOptional(func(i int64) float64 { return float64(i) }),
+		ConsumptionOptional[float64](func(i int64) float64 { return float64(i) }),
 		func(_ MyType5) error { return nil },
 		NonFinal(func() {}),
 	)
@@ -93,7 +93,7 @@ func TestDetailedError(t *testing.T) {
 	require.NotEqual(t, -1, index, "contains 'func TestRegression'")
 	detailed = detailed[index:]
 
-	for _, word := range strings.Split("Desired Shun Required Cacheable MustCache Cluster Memoize ShadowingAllowed\\[error\\] MustConsume\\[int64\\] ConsumptionOptional NonFinal Loose\\[string\\]", " ") {
+	for _, word := range strings.Split("Desired Shun Required Cacheable MustCache Cluster Memoize ShadowingAllowed\\[error\\] MustConsume\\[int64\\] ConsumptionOptional\\[float64\\] NonFinal Loose\\[string\\]", " ") {
 		re := regexp.MustCompile(fmt.Sprintf(`\b%s\(` /*)*/, word))
 		if !re.MatchString(detailed) {
 			t.Errorf("did not find %s( in reproduce output", word) // )

include.go

@@ -80,7 +80,7 @@ func computeDependenciesAndInclusion(funcs []*provider, initF *provider) ([]*pro
 		if fm.mustConsume != nil {
 			fm.d.mustConsumeFlow[outputParams] = true
 		}
-		if !fm.consumptionOptional {
+		if fm.consumptionOptional == nil {
 			fm.d.mustConsumeFlow[returnParams] = true
 		}
 		if fm.required {
@@ -307,9 +307,14 @@ func checkFlows(funcs []*provider, numFuncs int, canRemoveDesired bool) error {
 				}
 			Param:
 				for _, tc := range tclist {
-					if param == int(outputParams) {
+					switch flowType(param) {
+					case outputParams:
 						if _, ok := fm.mustConsume[tc]; !ok {
-							continue
+							continue Param
+						}
+					case returnParams:
+						if _, ok := fm.consumptionOptional[tc]; ok {
+							continue Param
 						}
 					}
 					if tc == unusedTypeCode {

nject.go

@@ -30,7 +30,7 @@ type provider struct {
 	shun                bool
 	notCacheable        bool
 	mustConsume         map[typeCode]struct{}
-	consumptionOptional bool
+	consumptionOptional map[typeCode]struct{}
 	singleton           bool
 	cluster             int32
 	parallel            bool
@@ -94,7 +94,7 @@ func (fm *provider) copy() *provider {
 		shun:                fm.shun,
 		notCacheable:        fm.notCacheable,
 		mustConsume:         mapCopy(fm.mustConsume),
-		consumptionOptional: fm.consumptionOptional,
+		consumptionOptional: mapCopy(fm.consumptionOptional),
 		singleton:           fm.singleton,
 		cluster:             fm.cluster,
 		parallel:            fm.parallel,

nject_test.go

@@ -58,11 +58,14 @@ func TestAnnotateMustConsume(t *testing.T) {
 }
 
 func TestAnnotateConsumptionOptional(t *testing.T) {
+	stc := getTypeCode("foo")
 	wrapTest(t, func(t *testing.T) {
-		p := ConsumptionOptional(func() {})
+		p := ConsumptionOptional[string](func() {})
 		require.IsType(t, &provider{}, p)
-		require.True(t, p.(*provider).consumptionOptional)
-		require.True(t, p.(*provider).copy().consumptionOptional)
+		require.NotNil(t, p.(*provider).consumptionOptional)
+		require.Contains(t, p.(*provider).consumptionOptional, stc)
+		require.NotNil(t, p.(*provider).copy().consumptionOptional)
+		require.Contains(t, p.(*provider).copy().consumptionOptional, stc)
 	})
 }
 

reorder.go

@@ -177,12 +177,13 @@ func reorder(funcs []*provider, initF *provider) ([]*provider, error) {
 			}
 			// if you return a T, you're not marked consumptionOptional, then you
 			// MUST be after a provider that receives a T as a returned value
+			_, consumptionOptional := fm.consumptionOptional[t]
 			if num, ok := upTypes[t]; ok {
-				aAfterB(!fm.consumptionOptional, i, num)
+				aAfterB(!consumptionOptional, i, num)
 			} else {
 				debugln("\tuptype", counter, t)
 				upTypes[t] = counter
-				aAfterB(!fm.consumptionOptional, i, counter)
+				aAfterB(!consumptionOptional, i, counter)
 				counter++
 			}
 			// if you return a T, then you SHOULD be be after all providers that