Support complex and big numeric types?

[theory]

The implementation currently supports all of Go's core numeric types for comparison and truthiness except for complex64 and complex128. And as of #14 it also supports json.Numbers.

Should it also support complex64 and complex128? What about big.Int, big.Float, and big.Rat? Are those likely to be parsed from JSON? encoding/json does not, but perhaps other JSON parsers?

Is there a need to support these types?

[jarangutan]

Don't have much to add but I feel if someone needs to handle such large numbers like that then they're reaching for something more powerful than jsonpath?

Although, I didn't see in the RFC if they're limiting the truthiness checks to only certain sizes.

There's this piece that goes over json values https://www.rfc-editor.org/rfc/rfc9535.html#name-json-values but doesn't really cover complex or large numbers.

This quote under 2.1 overview maybe points to the need for such large numbers:

Obviously, an implementation can still fail when executing a JSONPath query, e.g., because of resource depletion, but this is not modeled in this document. However, the implementation MUST NOT silently malfunction. Specifically, if a valid JSONPath query is evaluated against a structured value whose size is too large to process the query correctly (for instance, requiring the processing of numbers that fall outside the range of exact values), the implementation MUST provide an indication of overflow.

The piece of a structure value whose size is too large and "falls outside the range of exact values" might be a clue that parsing big or complex numbers is expected behavior?

I won't speak for others but I've not had a situation where I shipped large numbers like that via json.

There's likely a use case for folks shipping DNA sequences over json for some reason or trying to send their latest calculations of Pi to their pen pal.