On 3/3/23 06:03, Joe wrote:

> My understanding was that since A, B and X[] are all reference types,
> this ought to work, but obviously something is missing.

Think may be due to D not having reference variables. Sometimes one needs to use pointers.

I find the following a simpler (and complete ;) ) example. foo() returns by ref and indeed, the change made to its return value is visible in main.

However, the same foo() is later called to initialize hopefullyRef but not the change made to that variables is not reflected in the array. (By the way, the example could be written without an array as well.)

struct S {
    int i;

    void change() {
        ++i;
    }
}

ref S foo(S[] arr) {
    return arr[0];
}

void main() {
    auto arr = [ S(1) ];

    // Ok, this operation changes arr[0]
    foo(arr).change();
    assert(arr[0].i == 2);

    // This one changes the local variable
    auto hopefullyRef = foo(arr);
    hopefullyRef.change();
    assert(hopefullyRef.i == 3);

    // The array is still 2
    assert(arr[0].i == 2);
}

hopefullyRef in just an int. The following definition of the hopefullyRef variable would cause the array element be changed:

    // Now an S* (note & on the rigth-hand side)
    auto hopefullyRef = &foo(arr);
    // Now hopefullyRef is an S*, not an S

    // Same as before
    hopefullyRef.change();
    assert(hopefullyRef.i == 3);

    // Now the array is affected (3, not 2)
    assert(arr[0].i == 3);

Ali

On 3/3/23 12:45, Joe wrote:

> I had tried changing B.x1() to:
>
>    `ref X x1() { return &xs[0]; }`
>
> but the compiler didn't accept it.

Yeah, that wouldn't work because the return expression is an X*.

Even though 'ref' is implemented as a pointer behind the scenes, that syntax is not legal.

> It's a bit weird that by taking the address of calling B.x1() and thus
> getting an X*

Agreed but that's how it is. Taking the address of a reference produces an X*.

> I had to *dereference* that to pass it to the helper
> function of A.mfd() which actually takes a `ref C` argument.

Yep, all of that makes sense. :)

Ali