On 1/2/2025 6:32 AM, Derek Fawcus wrote:
> The closest native equivalent in D, would seem to be the following, making use of the new facility.
> 
> ```D
> struct outer {
>      int a;
>      struct inner_ {
>              int b;
>              int c;
>      }
>      inner_ inner;
>      int d;
>      alias b = inner.b;
>      alias c = inner.c;
> };
> ```
> 
> Or is there a nicer way to write that in D?

```
struct outer {
    int a;
    struct {
        int b;
        int c;
    }
    int d;
}
```

On 1/2/2025 12:56 AM, Richard (Rikki) Andrew Cattermole wrote:
> Its a feature that once you learn that it exists, but not in D, you long for it, even if it isn't worth making noise over.

It's expected when one is an expert in a previous language to long for characteristics not in the current language.

But adding all this stuff in makes the language unwieldy and impractical to learn. Gotta draw the line somewhere.

On Thursday, 2 January 2025 at 19:08:06 UTC, Walter Bright wrote:
> On 1/2/2025 6:32 AM, Derek Fawcus wrote:
>> The closest native equivalent in D, would seem to be the following, making use of the new facility.
>> 
>> ```D
>> struct outer {
>>      int a;
>>      struct inner_ {
>>              int b;
>>              int c;
>>      }
>>      inner_ inner;
>>      int d;
>>      alias b = inner.b;
>>      alias c = inner.c;
>> };
>> ```
>> 
>> Or is there a nicer way to write that in D?
>
> ```
> struct outer {
>     int a;
>     struct {
>         int b;
>         int c;
>     }
>     int d;
> }
> ```

That does not yield the ability to reference the inner part as an entity/group.  Whereas that is possible with the D struct I proposed.

e.g. using the prior C definition, I can reference it from C as:

```C
#include <stdio.h>

#include "group.c"

void main() {
	struct outer o;

	o.a = 1; o.b = 2; o.c = 3; o.d = 4;
	printf("inner b = %d, inner c = %d\n", o.inner.b, o.inner.c);
	printf("sizeof outer = %lu, sizeof inner = %lu\n", sizeof o, sizeof o.inner);
}
```

or from D as:

```D
import core.stdc.stdio;

import group;

void main() {
	outer o;

	o.a = 1; o.b = 2; o.c = 3; o.d = 4;
	printf("inner b = %d, inner c = %d\n", o.inner.b, o.inner.c);
	printf("sizeof outer = %lu, sizeof inner = %lu\n", o.sizeof, o.inner.sizeof);
}
```

Or more likely, passing the address of o.inner to some other function.

On 03/01/2025 8:21 AM, Walter Bright wrote:
> But adding all this stuff in makes the language unwieldy and impractical to learn. Gotta draw the line somewhere.

In this particular case I have a concern with the grammar.

Identifier ';'

It is easily ambiguous, I don't think we can copy it even if we wanted to.

On Sunday, 29 December 2024 at 04:08:19 UTC, Walter Bright wrote:
> Sorry, but I missed it or it wasn't in the forums.

Never mind, it's impossible for a man to track everything. It came up recently in the context of `@property ref x() => inner.y;` vs `alias x = inner.y;` or something.

On 1/2/2025 11:58 AM, Derek Fawcus wrote:
> That does not yield the ability to reference the inner part as an entity/group.  Whereas that is possible with the D struct I proposed.

True, but it is a very minor convenience and there is still a simple way to do the equivalent.

D doesn't have a separate tag name space for C struct tags, either. Please don't ask for it :-/