Hello,
what numerical type should I use to represent 0xffff_ffff_ffff_ffff ?
Obviously, Int64.of_int 0xffff_ffff_ffff_ffff doesn’t work:
Error: Integer literal exceeds the range of representable integers of type intThis doesn’t really answer your question but Int64 literal are suffixed with n : 0xffff_ffff_ffff_ffffn = -1n works as expected.
I believe 1n is a nativeint, it’s 1L for a int64 value 
Indeed (and 1l for int32), I had an erroneous native=64bit in mind 
.
Thank you all for the suggestions.
Maybe some context is useful here:
The question arose while implementing a language, that has a nat64 data type. The type checker had to make sure that all nat64 literals are between 0 and 0xffff_ffff_ffff_ffff.
But since the parser uses Int64.of_string_opt he wouldn’t even be able to parse literals greater than 0xffff_ffff_ffff_ffff.
This is good so far.
However, the type checker still couldn’t differentiate between
var x nat64 = 0xffff_ffff_ffff_ffff // should typecheck
and
var x nat64 = -1 // should not typecheck
I think I’ll ignore the problem for now, but any hints how to solve it are still welcome.
Perhaps I’m missing something basic here, but why aren’t you just using infinite-precision rationals and just be done with it? This is the type-checker, not the runtime, right? So you should be perfectly safe using something less efficient than native ints, yes? Just arrange to check in all computations on constant-expressions/values, for overflow, and everything should be fine, yes?
Maybe I’m just missing something really basic. But for example, recently, perusing the Ocaml AST, I noticed that it went from using “int” in integer-constants, to using strings + a one-char indication of which type the string was a member of.
No, you are not missing anything at all. 
Knowing OCaml represents integer constants as strings makes me feel better to choose a less performant implementation, too.