How should the term "comptime value" be defined?

Help
1

I’m not sure if the following definition is precise.

A `comptime value` is a value determined at compile time.

Maybe, if we don’t treat a pointer as a specified address, then it is precise.
For example, in the following code, &x is a comptime value, but the address value stored in it is not.

var x = true;

pub fn main() void {
    // The two lines compile okay.
    _ = comptime &type;
    _ = comptime &x;
    
    // The two lines fail to compile when enabled.
    // _ = comptime @intFromPtr(&type);
    // _ = comptime @intFromPtr(&x);
}
2

From the docs:

At Namespace level (outside of any function), all expressions are implicitly comptime expressions

x itself is comptime in your example and so &x itself is known at compile time.

Look also on this example, here &x is not only taken but also used

const std = @import("std");

// Try to add comptime keyword here and will get error: redundant comptime keyword in already comptime scope
//              |
//              |
//              *
var compt_var =  compt_fn();

fn compt_fn() u8 {
    var x: u8 = 0;
    const y = &x;
    y.* = 10;
    return x;
}
pub fn main() void {
    std.debug.print("{}\n", .{compt_var}); // 10
}

So in my opinion it is more of a problem of @intFromPtr rather than %x itself but I am still new to the language and moreover have a lot of unresolved questions about comptime by myself so maybe probably I am wrong

EDIT: My point is that compiler needs to actually run the code so there should be real pointers with real values which are obviously only comptime known and then discarded but they are valid…?

3

This might be not accurate. Namespace-level mutable declarations are absolutely not comptime values. For example the x in my code. Their initializer expressions indeed are.

I don’t know if there is a simple way to verify whether or not an expression is an always-comptime value. I think my way _ = comptime anExpression is not rigorous. The way just verifies that anExpression can be used as a comptime value. In fact, it might be a runtime value. Though I think the conclusion of the address of a namespace-level mutable declaration is an always-comptime value should be right.