What's the best way to parse a value into a nested field using Kong's built-in decoders?

[arvidfm]

I want to define a PositiveNumber[T] type that can be set to any number type T and validates the the input to be positive. Since Go doesn't allow you to use a type variable as the RHS in a type statement (i.e. type PositiveNumber[T any] T), I have to create a struct with the actual value as a field:

type PositiveNumber[T constraints.Integer | constraints.Float] struct {
	Value T
}

func (p PositiveNumber[T]) Validate() error {
	if p.Value < 0 {
		return errors.New("value must be positive")
	}
	return nil
}

Now I'd like to be able to use this in a struct to be populated by Kong:

var config struct{
	MyIntNumber *PositiveNumber[int64]
	MyFloatNumber *PositiveNumber[float32]
}

func main() {
	kong.Parse(&config)
}

However this obviously won't work out of the box:

error: --my-int-number: cannot find mapper for main.PositiveNumber[int64]

So what I want to do is tell Kong to decode the value into PositiveNumber.Value instead. I could implement encoding.TextUnmarshaler, but that would mean having to handle every possible type T manually. If possible I would like to leverage the existing decoders that Kong already provides.

I did come up with this solution, but it's pretty jank and I was wondering if there's a better way:

func (p *PositiveNumber[T]) Decode(ctx *kong.DecodeContext) error {
	var t T
	mapper := kong.
		NewRegistry().
		RegisterDefaults().
		ForType(reflect.TypeOf(t))
	target := reflect.ValueOf(&p.Value).Elem()
	return mapper.Decode(ctx, target)
}

[alecthomas]

Give ctx.Scan.PopValueInto("number", &t) a shot, it should do what you want:

func (p *PositiveNumber[T]) Decode(ctx *kong.DecodeContext) error {
  return ctx.Scan.PopValueInto("number", &p.Value)
}

[arvidfm]

Trying that with --my-int-number=1000 gives me:

error: --my-int-number: "1000" -> *int64: json: cannot unmarshal string into Go value of type int64

It looks like the kong.Token value that gets popped by the Scanner is a string value:

Value = {interface{} | string} "1000"
Type = {kong.TokenType} FlagValueToken (3)

which then gets passed through a round of json.Marshal (making it a JSON string) and json.Unmarshal (which will fail unless the target field is a string) in jsonTranscode.

[alecthomas]

In that case I think your best bet is probably strconv.ParseInt() then reflect.ValueOf(&v).SetInt(i)

[arvidfm]

The thing is just that if I want to support all the type allowed by the type constraints, I'd have to write that as something like:

func (p *PositiveNumber[T]) UnmarshalText(data []byte) error {
	v := reflect.ValueOf(&p.Value).Elem()
	switch v.Kind() {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		i, err := strconv.ParseInt(string(data), 10, 64)
		if err != nil {
			return err
		}
		v.SetInt(i)
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		u, err := strconv.ParseUint(string(data), 10, 64)
		if err != nil {
			return err
		}
		v.SetUint(u)
	case reflect.Float32, reflect.Float64:
		f, err := strconv.ParseFloat(string(data), 64)
		if err != nil {
			return err
		}
		v.SetFloat(f)
	}
	return nil
}

which ends up essentially just being a reimplementation of the default decoders populated by Registry.RegisterDefaults() - except with potentially subtly different semantics.

Ideally I'd like to just be able to say to Kong, "unmarshal this value the same way you would any other value, except use this nested field as the target instead" to ensure that all semantics are preserved. But from the sounds of it, I take it that's not something Kong supports out of the box at the moment. I might just go with using json.Unmarshal(&p.Value) in that case, since it should hopefully work more or less the same with numbers at least. Thanks for the tips though.