Suppose one has a pointer p of type T*.
Can on declare variable a of type T which is stored in the location pointed to by p?

As an example if we have:

struct S
{
  int x = 1234;
}

void main() {
   S s;
   //unknown construction of a using &(s.x)
   writeln(a); //displays 1234
   s.x = s.x+1;
   writeln(a); //displays 1235
   a = a +1;
   writeln(s.x); //displays 1236
}

Similar behavior can be achieved in the body of the lambda here

import std.stdio;

struct S
{
  int x = 1234;
}


void main() {
    S s;
    (ref a){
         writeln(a);
         s.x = s.x + 1;
         writeln(a);
         a = a +1;
         writeln(s.x);
    }(s.x);
}

On Friday, 13 August 2021 at 08:25:33 UTC, JG wrote:

struct S
{
  int x = 1234;
}

void main() {
   S s;
   //unknown construction of a using &(s.x)
   writeln(a); //displays 1234
   s.x = s.x+1;
   writeln(a); //displays 1235
   a = a +1;
   writeln(s.x); //displays 1236
}

import std.stdio;

struct S
{
  int x = 1234;
}


void main() {
    S s;
    (ref a){
         writeln(a);
         s.x = s.x + 1;
         writeln(a);
         a = a +1;
         writeln(s.x);
    }(s.x);
}

Umm is this what you want?

import std.stdio;

struct S
{
  int x = 1234;
}


void main() {
    S s;
    /*(ref a){
         writeln(a);
         s.x = s.x + 1;
         writeln(a);
         a = a +1;
         writeln(s.x);
    }(s.x);*/

    auto a = &(s.x);
    writeln(*a);
    s.x += 1;
    writeln(*a);
    *a += 1;
    writeln(s.x);


}

On Friday, 13 August 2021 at 09:10:18 UTC, Tejas wrote:

import std.stdio;

struct S
{
  int x = 1234;
}


void main() {
    S s;
    /*(ref a){
         writeln(a);
         s.x = s.x + 1;
         writeln(a);
         a = a +1;
         writeln(s.x);
    }(s.x);*/

    auto a = &(s.x);
    writeln(*a);
    s.x += 1;
    writeln(*a);
    *a += 1;
    writeln(s.x);


}

That's also what I thought, although at first I thought JG meant dereferencing a pointer to a type without reallocating the content.

In a way comparable to aliasing A* or having your original data be a union in the first place.
It seems however one can use . when using pointers, which is cool, though there seem to be some caveats: https://forum.dlang.org/post/hthxvxxsxdpkvwcwgisi@forum.dlang.org (note this is 2014...))

For anyone more experienced with C, I'm not well known with references but are those semantically similar to the idea of using a type at a predefined location?

Small sidenote, this would be cool:

int* ip = cast(int*)other_pointer;
int a = #a; // like a dereference but without allocating space for a elsewhere.
int b = #a; // Or something along those lines
a = 1;
b += 1;
assert(a==2);

struct S {
  int x = 1234;
}

void main() {
  import std.stdio;
   S s;
   //construction of a using &(s.x)
   auto a = Ref!(int)(&s.x);
   writeln(a); //displays 1234
   s.x += 1;
   writeln(a); //displays 1235
   a += 1;
   writeln(s.x); //displays 1236
}

struct Ref(T) {
  T* ptr;
  this(T* p) { ptr = p; }
  string toString() { import std.conv; return to!string(*ptr); }
  ref T var() { return *ptr; }
  alias var this;
}

On Saturday, 14 August 2021 at 20:50:47 UTC, Carl Sturtivant wrote:

struct S {
  int x = 1234;
}

void main() {
  import std.stdio;
   S s;
   //construction of a using &(s.x)
   auto a = Ref!(int)(&s.x);
   writeln(a); //displays 1234
   s.x += 1;
   writeln(a); //displays 1235
   a += 1;
   writeln(s.x); //displays 1236
}

struct Ref(T) {
  T* ptr;
  this(T* p) { ptr = p; }
  string toString() { import std.conv; return to!string(*ptr); }
  ref T var() { return *ptr; }
  alias var this;
}

Hi,

This is exactly the behaviour I was trying to obtain.

It however comes with a fair amount of overhead, as can be seen in the following llvm ir:

define i32 @_Dmain({ i64, { i64, i8* }* } %unnamed) #0 {
  %s = alloca %onlineapp.S, align 4               ; [#uses = 4, size/byte = 4]
  %a = alloca %"onlineapp.Ref!int.Ref", align 8   ; [#uses = 5, size/byte = 8]
  %1 = bitcast %onlineapp.S* %s to i8*            ; [#uses = 1]
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %1, i8* align 1 bitcast (%onlineapp.S* @onlineapp.S.__init to i8*), i64 4, i1 false)
  %2 = bitcast %"onlineapp.Ref!int.Ref"* %a to i8* ; [#uses = 1]
  call void @llvm.memset.p0i8.i64(i8* align 1 %2, i8 0, i64 8, i1 false)
  %3 = getelementptr inbounds %onlineapp.S, %onlineapp.S* %s, i32 0, i32 0 ; [#uses = 1, type = i32*]
  %4 = call %"onlineapp.Ref!int.Ref"* @pure nothrow ref @nogc @safe onlineapp.Ref!(int).Ref onlineapp.Ref!(int).Ref.__ctor(int*)(%"onlineapp.Ref!int.Ref"* nonnull returned %a, i32* %3) #4 ; [#uses = 0]
  %5 = load %"onlineapp.Ref!int.Ref", %"onlineapp.Ref!int.Ref"* %a, align 8 ; [#uses = 1]
  call void @@safe void std.stdio.writeln!(onlineapp.Ref!(int).Ref).writeln(onlineapp.Ref!(int).Ref)(%"onlineapp.Ref!int.Ref" %5) #4
  %6 = getelementptr inbounds %onlineapp.S, %onlineapp.S* %s, i32 0, i32 0 ; [#uses = 2, type = i32*]
  %7 = load i32, i32* %6, align 4                 ; [#uses = 1]
  %8 = add i32 %7, 1                              ; [#uses = 1]
  store i32 %8, i32* %6, align 4
  %9 = load %"onlineapp.Ref!int.Ref", %"onlineapp.Ref!int.Ref"* %a, align 8 ; [#uses = 1]
  call void @@safe void std.stdio.writeln!(onlineapp.Ref!(int).Ref).writeln(onlineapp.Ref!(int).Ref)(%"onlineapp.Ref!int.Ref" %9) #4
  %10 = call i32* @pure nothrow ref @nogc @safe int onlineapp.Ref!(int).Ref.var()(%"onlineapp.Ref!int.Ref"* nonnull %a) #4 ; [#uses = 2]
  %11 = load i32, i32* %10, align 4               ; [#uses = 1]
  %12 = add i32 %11, 1                            ; [#uses = 1]
  store i32 %12, i32* %10, align 4
  %13 = getelementptr inbounds %onlineapp.S, %onlineapp.S* %s, i32 0, i32 0 ; [#uses = 1, type = i32*]
  %14 = load i32, i32* %13, align 4               ; [#uses = 1]
  call void @@safe void std.stdio.writeln!(int).writeln(int)(i32 %14) #4
  ret i32 0
}