The length of integer in the Nix language

shamrocklee · January 26, 2023, 1:47am

There’s a built-in integer type the Nix language. However, its range is left undocumented. What’s the specification of the range of integer?

On my x86_64-linux NixOS, the integer seems to be 64-bit long, using two’s complement for signing and wrapping for overflow.

Is this behavior the same across all platforms, or is it platform-specific?

I encountered this problem when trying to implement the hash base conversion function to workaround the lack of related builtins.

github.com/NixOS/nix

Add the builtin `hashTo`

opened 06:53PM - 15 Oct 19 UTC

nlewo

I would like to add a builtin to convert a hash from one representation to anoth…er. Several Nix sub-commands (`to-base16`, `to-sri`, ...) already exist to do such conversion but I would like to do that at evaluation time. ### Spec ```builtins.hashTo <type> <hash-string>``` where - `<type>` is the expected representation. `<type>` could be one of the hash representations supported by Nix, which are currently `base16`, `base32`, `base64` and `sri`. - `<hash-string>` is a string representing a hash. The format of this hash can be inferred. It would return the hash to the expected representation or an error if the input string doesn't represent a hash. What do you think?

nix-repl> powWithTermInt = let f = n: base: term: if n == 0 t
hen term else if n < 0 then f (n + 1) base (builtins.div term
 base) else f (n - 1) base (term * base); in f

nix-repl> powWithTermInt 62 2 1
4611686018427387904

nix-repl> powWithTermInt 63 2 1
-9223372036854775808

nix-repl> -1 + powWithTermInt 63 2 1
9223372036854775807

nix-repl> powWithTermInt 64 2 1
0

nix-repl> -1 + powWithTermInt 64 2 1
-1

fricklerhandwerk · January 26, 2023, 9:08am

Please open a GitHub issue to track this. Discourse posts will get lost and one cannot visibly indicate when the problem is solved.

shamrocklee · January 26, 2023, 1:17pm

Issue opened.

github.com/NixOS/nix

Missing documentation about the integer size and the floating point precision

opened 01:17PM - 26 Jan 23 UTC

ShamrockLee

documentation

## Problem There is a primitive integer type in the Nix expression language, …but no documentation is there about its *size* and overflow behavior. There's also a primitive floating point, but the behavior of it is also not documented. On my `x86-64_linux` NixOS, the integer is 64-bit, in two's complement and and wrapping when overflow. Is this platform specific? Initial discussion: https://discourse.nixos.org/t/the-length-of-integer-in-the-nix-language/24958 ## Checklist - [ ] checked [latest Nix manual] \([source]) - [ ] checked [open documentation issues and pull requests] for possible duplicates [latest Nix manual]: https://nixos.org/manual/nix/unstable/ [source]: https://github.com/NixOS/nix/tree/master/doc/manual/src [open documentation issues and pull requests]: https://github.com/NixOS/nix/labels/documentation ## Proposal Document the specification to the integer type and the floating point number type of the Nix language, including the portable part and the platform-specific part. For example: The integer type occupies 64 bits, whose sign is represented using the two's complement, indicating that ``` nix-repl> 9223372036854775807 + 1 -9223372036854775808 ``` or The integer type occupies 64 bits, which is similar to `int64_t` in C++. Its overflow is an undefined behavior. or The integer type is an analogy to the `long` type in C++, whose size is platform-specific. The floating point type conforms to the IEEE 754 double-precision floating point format specification. ## Priorities Add :+1: to [issues you find important](https://github.com/NixOS/nix/issues?q=is%3Aissue+is%3Aopen+sort%3Areactions-%2B1-desc).