func uintSetter(bits int, valueMaker interface{}, value reflect.Value, tagValue string) (bool, error) {
	uintMaker, ok := valueMaker.(UintMaker)
	if !ok {
		return false, &UnsupportedKindError{reflect.Uint}
	}
	set, u64, err := uintMaker.MakeUint(tagValue, bits)
	if err != nil {
		return false, err
	} else if set {
		value.SetUint(u64)
	}
	return set, nil
}
uintSetter sets value with the int returned from valueMaker, if it implements UintMaker. Otherwise it returns an error.
package inject
import "reflect"
func TypedInjector(valueMaker interface{}) Injector {
	return &typedInjector{valueMaker}
}
type typedInjector struct {
	valueMaker interface{}
}
func (tvs typedInjector) Inject(value reflect.Value, tagValue string) (bool, error) {
	kind := value.Kind()
	switch kind {
	case reflect.String:
		stringValueMaker, ok := tvs.valueMaker.(StringMaker)
		if !ok {
			return false, &UnsupportedKindError{reflect.String}
		}
		set, s, err := stringValueMaker.MakeString(tagValue)
		if err != nil {
			return false, err
		} else if set {
			value.SetString(s)
		}
		return set, err
	case reflect.Bool:
		boolValueMaker, ok := tvs.valueMaker.(BoolMaker)
		if !ok {
			return false, &UnsupportedKindError{reflect.Bool}
		}
		set, b, err := boolValueMaker.MakeBool(tagValue)
		if err != nil {
			return false, err
		} else if set {
			value.SetBool(b)
		}
		return set, nil
	case reflect.Int:
		return intSetter(0, tvs.valueMaker, value, tagValue)
	case reflect.Int8:
		return intSetter(8, tvs.valueMaker, value, tagValue)
	case reflect.Int16:
		return intSetter(16, tvs.valueMaker, value, tagValue)
	case reflect.Int32:
		return intSetter(32, tvs.valueMaker, value, tagValue)
	case reflect.Int64:
		return intSetter(64, tvs.valueMaker, value, tagValue)
	case reflect.Uint:
		return uintSetter(0, tvs.valueMaker, value, tagValue)
	case reflect.Uint8:
		return uintSetter(8, tvs.valueMaker, value, tagValue)
	case reflect.Uint16:
		return uintSetter(16, tvs.valueMaker, value, tagValue)
	case reflect.Uint32:
		return uintSetter(32, tvs.valueMaker, value, tagValue)
	case reflect.Uint64:
		return uintSetter(64, tvs.valueMaker, value, tagValue)
	case reflect.Float32:
		return floatSetter(32, tvs.valueMaker, value, tagValue)
	case reflect.Float64:
		return floatSetter(64, tvs.valueMaker, value, tagValue)
	case reflect.Complex64:
		return complexSetter(64, tvs.valueMaker, value, tagValue)
	case reflect.Complex128:
		return complexSetter(128, tvs.valueMaker, value, tagValue)
	case reflect.Slice:
		sliceValueMaker, ok := tvs.valueMaker.(SliceMaker)
		if !ok {
			return false, &UnsupportedKindError{reflect.Slice}
		}
		set, made, err := sliceValueMaker.MakeSlice(tagValue, value.Type())
		if err != nil {
			return false, err
		} else if set {
			value.Set(made)
		}
		return set, nil
	case reflect.Array:
		arrayValueMaker, ok := tvs.valueMaker.(ArrayMaker)
		if !ok {
			return false, &UnsupportedKindError{reflect.Array}
		}
		set, made, err := arrayValueMaker.MakeArray(tagValue, value.Type())
		if err != nil {
			return false, err
		} else if set {
			value.Set(made)
		}
		return set, nil
	case reflect.Chan:
		chanValueMaker, ok := tvs.valueMaker.(ChanMaker)
		if !ok {
			return false, &UnsupportedKindError{reflect.Chan}
		}
		set, made, err := chanValueMaker.MakeChan(tagValue, reflect.TypeOf(value))
		if err != nil {
			return false, err
		} else if set {
			value.Set(made)
		}
		return set, nil
	default:
		return false, &UnsupportedKindError{kind}
	}
}
func intSetter(bits int, valueMaker interface{}, value reflect.Value, tagValue string) (bool, error) {
	intMaker, ok := valueMaker.(IntMaker)
	if !ok {
		return false, &UnsupportedKindError{reflect.Int}
	}
	set, i64, err := intMaker.MakeInt(tagValue, bits)
	if err != nil {
		return false, err
	} else if set {
		value.SetInt(i64)
	}
	return set, nil
}