Add a Reorder() decorator (#31)

* WIP

* WIP, 2 tests pass

* reorder now works

* bugfix: eliminate shun functions first

* lint

Author: muir

api.go

@@ -334,7 +334,14 @@ func NonFinal(fn interface{}) Provider {
 // head of the provider chain.  The static portion of the provider
 // chain will run once.  The values returned from the initialization
 // function come from the values available after the static portion
-// of the provider chain runs.
+// of the provider chain runs.  For example, if the static portion
+// of an injection chain consists of:
+//
+//	func(int) string { ... }
+//	func(string) int64 { ... }
+//
+// Then the return value from the initialization could include int,
+// int64, and string but no other types.
 //
 // Bind pre-computes as much as possible so that the invokeFunc is fast.
 //

bind.go

@@ -64,8 +64,7 @@ func doBind(sc *Collection, originalInvokeF *provider, originalInitF *provider,
 		funcs = append(funcs, invokeF)
 		funcs = append(funcs, afterInvoke...)
 
-		for i, fm := range funcs {
-			fm.chainPosition = i
+		for _, fm := range funcs {
 			if fm.required {
 				fm.include = true
 			}
@@ -93,7 +92,8 @@ func doBind(sc *Collection, originalInvokeF *provider, originalInitF *provider,
 
 	// Compute dependencies: set fm.downRmap, fm.upRmap, fm.cannotInclude,
 	// fm.whyIncluded, fm.include
-	err := computeDependenciesAndInclusion(funcs, initF)
+	var err error
+	funcs, err = computeDependenciesAndInclusion(funcs, initF)
 	if err != nil {
 		return err
 	}

characterize.go

@@ -145,6 +145,7 @@ var (
 	markedMemoized       = predicate("is not marked Memoized", func(a testArgs) bool { return a.fm.memoize })
 	markedCacheable      = predicate("is not marked Cacheable", func(a testArgs) bool { return a.fm.cacheable })
 	markedSingleton      = predicate("is not marked Singleton", func(a testArgs) bool { return a.fm.singleton })
+	notMarkedReorder     = predicate("is marked Reorder", func(a testArgs) bool { return !a.fm.reorder })
 	notMarkedSingleton   = predicate("is marked Singleton", func(a testArgs) bool { return !a.fm.singleton })
 	notMarkedNoCache     = predicate("is marked NotCacheable", func(a testArgs) bool { return !a.fm.notCacheable })
 	mappableInputs       = predicate("has inputs that cannot be map keys", func(a testArgs) bool { return mappable(typesIn(a.t)...) })
@@ -244,6 +245,7 @@ var handlerRegistry = typeRegistry{
 			mappableInputs,
 			notMarkedNoCache,
 			mustNotMemoize,
+			notMarkedReorder,
 		},
 		mutate: func(a testArgs) {
 			a.fm.group = staticGroup
@@ -265,6 +267,7 @@ var handlerRegistry = typeRegistry{
 			mappableInputs,
 			notMarkedNoCache,
 			mustNotMemoize,
+			notMarkedReorder,
 		},
 		mutate: func(a testArgs) {
 			a.fm.group = staticGroup
@@ -288,6 +291,7 @@ var handlerRegistry = typeRegistry{
 			notMarkedNoCache,
 			possibleMapKey,
 			notMarkedSingleton,
+			notMarkedReorder,
 		},
 		mutate: func(a testArgs) {
 			a.fm.group = staticGroup
@@ -313,6 +317,7 @@ var handlerRegistry = typeRegistry{
 			notMarkedNoCache,
 			possibleMapKey,
 			notMarkedSingleton,
+			notMarkedReorder,
 		},
 		mutate: func(a testArgs) {
 			a.fm.group = staticGroup
@@ -336,6 +341,7 @@ var handlerRegistry = typeRegistry{
 			mustNotMemoize,
 			notMarkedNoCache,
 			notMarkedSingleton,
+			notMarkedReorder,
 		},
 		mutate: func(a testArgs) {
 			a.fm.group = staticGroup
@@ -504,8 +510,10 @@ func (reg typeRegistry) characterizeFuncDetails(fm *provider, cc charContext) (*
 		var isNil bool
 		// nolint:exhaustive
 		switch v.Type().Kind() {
-		case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+		case reflect.Chan, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
 			isNil = v.IsNil()
+		default:
+			isNil = false
 		}
 		a = testArgs{
 			fm:    fm.copy(),
@@ -531,7 +539,7 @@ Match:
 	}
 
 	// panic(fmt.Sprintf("%s: %s - %s", fm.describe(), t, strings.Join(rejectReasons, "; ")))
-	return nil, fm.errorf("Could not type %s to any prototype: %s", a.t, strings.Join(rejectReasons, "; "))
+	return nil, fm.errorf("Could not match type %s to any prototype: %s", a.t, strings.Join(rejectReasons, "; "))
 }
 
 func characterizeInitInvoke(fm *provider, context charContext) (*provider, error) {

debug.go

@@ -188,16 +188,24 @@ func formatFlow(flow []typeCode) string {
 	return strings.Join(types, ", ")
 }
 
+func elem(i interface{}) reflect.Type {
+	t := reflect.TypeOf(i)
+	if t.Kind() == reflect.Ptr {
+		return t.Elem()
+	}
+	return t
+}
+
 func generateReproduce(funcs []*provider, invokeF *provider, initF *provider) string {
 	subs := make(map[typeCode]string)
 	t := ""
 	f := "func TestRegression(t *testing.T) {\n"
 	f += "\twrapTest(t, func(t *testing.T) {\n"
 	f += "\t\tcalled := make(map[string]int)\n"
-	f += "\t\tvar invoker " + funcSig(subs, &t, reflect.TypeOf(invokeF.fn).Elem()) + "\n"
+	f += "\t\tvar invoker " + funcSig(subs, &t, elem(invokeF.fn)) + "\n"
 	initName := "nil"
 	if initF != nil {
-		f += "\t\tvar initer " + funcSig(subs, &t, reflect.TypeOf(initF.fn).Elem()) + "\n"
+		f += "\t\tvar initer " + funcSig(subs, &t, elem(initF.fn)) + "\n"
 		initName = "&initer"
 	}
 	f += "\t\trequire.NoError(t,\n"
@@ -277,9 +285,9 @@ func generateReproduce(funcs []*provider, invokeF *provider, initF *provider) st
 	}
 	f += "\t\t\t).Bind(&invoker, " + initName + "))\n"
 	if initF != nil {
-		f += "\t\tiniter(" + strings.Join(substituteDefaults(subs, typesIn(reflect.TypeOf(initF.fn).Elem())), ", ") + ")\n"
+		f += "\t\tiniter(" + strings.Join(substituteDefaults(subs, typesIn(elem(initF.fn))), ", ") + ")\n"
 	}
-	f += "\t\tinvoker(" + strings.Join(substituteDefaults(subs, typesIn(reflect.TypeOf(invokeF.fn).Elem())), ", ") + ")\n"
+	f += "\t\tinvoker(" + strings.Join(substituteDefaults(subs, typesIn(elem(invokeF.fn))), ", ") + ")\n"
 	f += "\t})\n"
 	f += "}\n"
 	return t + "\n" + f

example_provider_test.go

@@ -110,3 +110,28 @@ func ExampleNonFinal() {
 	// Output: final 20 some string
 	// <nil>
 }
+
+// This demonstrates how it to have a default that gets overridden by
+// by later inputs.
+func ExampleReorder() {
+	seq1 := nject.Sequence("example",
+		nject.Shun(func() string {
+			fmt.Println("fallback default included")
+			return "fallback default"
+		}),
+	)
+	seq2 := nject.Sequence("later inputs",
+		nject.Reorder(func() string {
+			return "override value"
+		}),
+	)
+	fmt.Println(nject.Run("combination",
+		seq1,
+		seq2,
+		func(s string) {
+			fmt.Println(s)
+		},
+	))
+	// Output: override value
+	// <nil>
+}

include.go

@@ -14,6 +14,7 @@ type includeWorkingData struct {
 	excluded        error
 	clusterMembers  []*provider
 	wantedInCluster bool
+	hasFlow         [lastFlowType]func(typeCode) bool // populated and used in reorder
 }
 
 //
@@ -64,7 +65,12 @@ type includeWorkingData struct {
 //	fm.wanted
 //
 
-func computeDependenciesAndInclusion(funcs []*provider, initF *provider) error {
+func computeDependenciesAndInclusion(funcs []*provider, initF *provider) ([]*provider, error) {
+	var err error
+	funcs = reorder(funcs, initF)
+	for i, fm := range funcs {
+		fm.chainPosition = i
+	}
 	debugln("initial set of functions")
 	clusterLeaders := make(map[int32]*provider)
 	for _, fm := range funcs {
@@ -98,15 +104,15 @@ func computeDependenciesAndInclusion(funcs []*provider, initF *provider) error {
 		}
 	}
 	debugln("calculate flows, initial")
-	err := providesReturns(funcs, initF)
+	err = providesReturns(funcs, initF)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	debugln("check chain validity, no provider excluded")
 	err = validateChainMarkIncludeExclude(funcs, true)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	for _, fm := range funcs {
@@ -187,15 +193,15 @@ func computeDependenciesAndInclusion(funcs []*provider, initF *provider) error {
 	debugln("final calculate flows")
 	err = providesReturns(funcs, initF)
 	if err != nil {
-		return fmt.Errorf("internal error: uh oh")
+		return nil, fmt.Errorf("internal error: uh oh")
 	}
 	debugf("final check chain validity")
 	err = validateChainMarkIncludeExclude(funcs, true)
 	if err != nil {
-		return fmt.Errorf("internal error: uh oh #2")
+		return nil, fmt.Errorf("internal error: uh oh #2")
 	}
 
-	return nil
+	return funcs, nil
 }
 
 func validateChainMarkIncludeExclude(funcs []*provider, canRemoveDesired bool) error {
@@ -508,8 +514,13 @@ func proposeEliminations(funcs []*provider) []*provider {
 		}
 	}
 	proposal := make([]*provider, 0, len(funcs))
+	for _, fm := range funcs {
+		if fm.shun {
+			proposal = append(proposal, fm)
+		}
+	}
 	for i, fm := range funcs {
-		if !kept[i] || fm.shun {
+		if !kept[i] && !fm.shun {
 			proposal = append(proposal, fm)
 		}
 	}

intheap.go

@@ -0,0 +1,23 @@
+package nject 
+
+// Code below originated with the container/heap documentation
+
+type IntHeap []int
+
+func (h IntHeap) Len() int           { return len(h) }
+func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
+func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+
+func (h *IntHeap) Push(x interface{}) {
+	// Push and Pop use pointer receivers because they modify the slice's length,
+	// not just its contents.
+	*h = append(*h, x.(int))
+}
+
+func (h *IntHeap) Pop() interface{} {
+	old := *h
+	n := len(old)
+	x := old[n-1]
+	*h = old[0 : n-1]
+	return x
+}

nject.go

@@ -25,6 +25,7 @@ type provider struct {
 	callsInner          bool
 	memoize             bool
 	loose               bool
+	reorder             bool
 	overridesError      bool
 	desired             bool
 	shun                bool
@@ -51,9 +52,9 @@ type provider struct {
 	bypassRmap    map[typeCode]typeCode //  overrides types of returning parameters
 	include       bool
 	d             includeWorkingData
+	chainPosition int
 
 	// added during binding
-	chainPosition              int
 	mustZeroIfRemainderSkipped []typeCode
 	mustZeroIfInnerNotCalled   []typeCode
 	vmapCount                  int
@@ -84,6 +85,7 @@ func (fm *provider) copy() *provider {
 		callsInner:          fm.callsInner,
 		memoize:             fm.memoize,
 		loose:               fm.loose,
+		reorder:             fm.reorder,
 		desired:             fm.desired,
 		shun:                fm.shun,
 		notCacheable:        fm.notCacheable,