Suppose there is a variable that is set once per run, and is (supposed) never to be altered again. However, the value to which it is set is not known at compile time.
Example below, variable is 'ArrPtr';

ubyte[10] Arr;

// immutable void* ArrPtr;
void* ArrPtr;

void main() {

   ArrPtr = cast(void*)Arr[0];

// <Lots of code depending on ArrPtr, but not supposed to modify ArrPtr>

}

Is there a way of getting D to guarantee that ArrPtr is never modified after

   ArrPtr = cast(void*)Arr[0];

Best regards

On 9/2/21 12:01 PM, DLearner wrote:

ubyte[10] Arr;

// immutable void* ArrPtr;
void* ArrPtr;

void main() {

    ArrPtr = cast(void*)Arr[0];

// <Lots of code depending on ArrPtr, but not supposed to modify ArrPtr>

}

    ArrPtr = cast(void*)Arr[0];
```]

You shouldn't be doing this. Arr is not immutable, so ArrPtr shouldn't point at it if it's immutable.

If you want to guarantee that ArrPtr never changes once set, yet still want it to point at mutable data, you need to use a type that does that (like a head mutable or "write once" type), which I believe doesn't exist in phobos.

If you don't actually need to mutate the data via ArrPtr, you can make it const, and use H.S. Teoh's solution. But you should not use immutable, as the compiler implies that data pointed at is also immutable (and of course, you won't need casting). Make sure you use regular static this, not shared static this, as your fields are thread-local, not shared.

-Steve

On Thursday, 2 September 2021 at 16:46:46 UTC, Steven Schveighoffer wrote:

ubyte[10] Arr;

// immutable void* ArrPtr;
void* ArrPtr;

void main() {

    ArrPtr = cast(void*)Arr[0];

// <Lots of code depending on ArrPtr, but not supposed to modify ArrPtr>

}

    ArrPtr = cast(void*)Arr[0];
```]

The following clean-compiled and produced the expected result:

    ubyte[10] Arr;

    immutable void* ArrPtr;
	shared static this() {
		ArrPtr = cast(immutable void*)(&Arr[0]);
	}

	void main() {
	
	  import std.stdio;
      void* ArrPtr2;

      ArrPtr2 = cast(void*)(&Arr[0]);
		
      writeln("ArrPtr = ", ArrPtr);
      writeln("ArrPtr2 = ", ArrPtr2);  // consistency test

//      ArrPtr = ArrPtr + 1;  // mutability test - compile (correctly) failed when uncommented.
      ArrPtr2 = ArrPtr2 + 1;
	
      Arr[1] = 4;
	  Arr[1] = 7;  // mutability test	
	}

The following produced deprecated warnings, but still seemed to work:

    ubyte[10] Arr;

    immutable void* ArrPtr;
	static this() {
		ArrPtr = cast(immutable void*)(&Arr[0]);
	}

	void main() {
	
	  import std.stdio;
      void* ArrPtr2;

      ArrPtr2 = cast(void*)(&Arr[0]);
		
      writeln("ArrPtr = ", ArrPtr);
      writeln("ArrPtr2 = ", ArrPtr2);  // consistency test

//      ArrPtr = ArrPtr + 1;  // mutability test on ArrPtr - compile (correctly) failed when uncommented.
      ArrPtr2 = ArrPtr2 + 1;
	
      Arr[1] = 4;
	  Arr[1] = 7;  // mutability test on Arr
	}

I am looking for a mutable Arr but would like an immutable ArrPtr.

`Arr` is not immutable, so `ArrPtr` shouldn't point at it if it's immutable.

Surely there is no inconsistency - at run time the array is in a fixed place, so ArrPtr is (or at least should be) a constant, but the contents of the array
can vary as the program runs.

If you want only address, you can keep it as size_t:

ubyte[10] Arr;
immutable size_t Address;
static this() {
	Address = cast(size_t)(&Arr[0]);
}

On Thursday, 2 September 2021 at 17:17:15 UTC, DLearner wrote:

In the case of immutable(T)* ArrPtr, the contents of the pointed-to array cannot vary as the program runs. If it's immutable, nothing in the program ever mutates it. In the case of const(T)* ArrPtr, the contents of the pointed-to array can vary as the program runs, and the only restriction is that the array can't be mutated through ArrPtr.

If what you mean is that you want the pointer to never change, T * const ArrPtr in C syntax, but that you don't care if the pointed-to array changes via ArrPtr or any other reference, then I don't think D can express this. You could make ArrPtr a function:

void main() {
    int[] xs = [1, 2, 3, 4];
    int* p() { return &xs[2]; }
    p[0] = 0;
    assert(xs == [1, 2, 0, 4]);
    p++; // Error: ... not an lvalue and cannot be modified
}

On 9/2/21 1:17 PM, DLearner wrote:

Then you want const not immutable.

Here is the reason:

void main()
{
    int x = 5;
    immutable int *ptr = cast(immutable int *)&x;
    assert(*ptr == 5); // ok
    x = 6;
    assert(*ptr == 5); // what happens here?
}

Depending on optimizations and compiler constant folding, that second assert may pass.

immutable means "I can never change and everything I point at can never change". The compiler is free to use this knowledge to avoid redoing calculations it has already done. I tknows that *ptr == 5 already, and that can never change, so it just doesn't even bother with the second assert.

However, make ptr const, and now not only do you not need the cast, but the second assert will fail as expected.

`Arr` is not immutable, so `ArrPtr` shouldn't point at it if it's immutable.

In D, const and immutable are transitive, which means that you can't have a pointer that is const, but allows changing what it points at. So while a const pointer may work for your purposes, you may want a specialized type, or a property function. It depends on how you intend to use ArrPtr. Others have given good answers to this problem.

-Steve

On Thursday, 2 September 2021 at 23:12:28 UTC, Steven Schveighoffer wrote:

[...]

If that is how the language defines the keyword 'immutable' when used in the definition of a pointer variable, then so be it.

I would, however, suggest that the additional 'action-at-a-distance' implication (freezing not just the variable itself, but also it's target) is inconsistent with the definition of 'immutable' with other variable types.

Surely it would be better to reserve 'immutable' on a pointer to mean simply set-once on the pointer itself (with no implications for whatever the pointer is pointing to), and another keyword ('blocked'?) for the current definition?