How to represent 0xffff_ffff_ffff_ffff?


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 int

This 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 :slightly_smiling_face:

Indeed (and 1l for int32), I had an erroneous native=64bit in mind :smile: .

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


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. :slight_smile:

Knowing OCaml represents integer constants as strings makes me feel better to choose a less performant implementation, too.