Since ceasing my use of D out of concern for the direction and health of the project, I've nonetheless been following these forums and have seen what I consider to be sincere efforts to improve things.

So I've started doing a bit of D work again and ran into this:

import std.stdio;

struct Foo {
    int bar;
    int baz;
}

void bletch(alias field)(Foo s, int x) {
	s.field = x;
	writeln("%d", s.field);
}

int main(string[] args)
{
    Foo s;
    bletch!bar(s);
    bletch!baz(s);
    return 0;
}

Compiling with dmd 2.106.0 on an up-to-date NixOS system results in

(dmd-2.106.0)dca@giovanni:/home/dca/Software/d_tests$ dmd test.d
test.d(16): Error: undefined identifier `bar`
test.d(17): Error: undefined identifier `baz`

So it appears that symbols passed to a function template alias parameter need to be in scope at the instantiation site as opposed to within the instantiated code.

This makes no sense to me. The symbols at the instantiation site are not being evaluated in that scope. They will be evaluated by the compiler when it gets its hands on the instantiated code. If a simple compile-time substitution were done in the above code, those symbols would both be defined in the instantiated code.

Reading the documentation, I'm guessing that template mixins can be used to address this problem, so it's probably the case (I haven't tried it) that I can achieve what I want that way.

But I'm failing to understand why the problem exists in the first place. Perhaps inherited from C++, which I do not know, having had some early exposure to it and concluded it was awful?

I'm probably missing something here, perhaps some important cases where the behavior I'm seeing does make sense. I'd be interested in the comments of those who know D (and perhaps C++) better than I do.

On Tuesday, 12 December 2023 at 19:02:11 UTC, Don Allen wrote:

Your imagining aliases as words rather than references to definitions

As far as I know, aliases are optimized to work with "overload sets"

void foo(int);
void foo(bool);

template bar(alias A){}
bar!foo;

A is now all foo's, foo's need to exist, and foo mostly pretends to stop knowing where it comes from

do:

struct Foo {
    int bar;
    int baz;
}

void bletch(alias field)(int x) {
	field = x;
	writeln("%d", s.field);
}

int main(string[] args)
{
    Foo s;
    bletch!(s.bar);
    bletch!(s.baz);
    return 0;
}

On Tuesday, 12 December 2023 at 19:50:25 UTC, monkyyy wrote:

void foo(int);
void foo(bool);

template bar(alias A){}
bar!foo;

struct Foo {
    int bar;
    int baz;
}

void bletch(alias field)(int x) {
	field = x;
	writeln("%d", s.field);
}

int main(string[] args)
{
    Foo s;
    bletch!(s.bar);
    bletch!(s.baz);
    return 0;
}

I regard templates as a form of more hygienic macros than simple text substitution. To me, they are a form of meta-programming -- code writing code. My view may be wrong and if so, I'd like to know why. If not, I have not seen an answer that explains why a symbol passed to an alias parameter needs a definition in the scope of the template instantiation, as opposed to within the instantiated template body.

What you have suggested above is a way to make my little example work. While less interested in that, I'm not un-interested :-) So I played with this a bit.

Taking your approach, cleaned up a bit (the bletch calls need the int argument), I tried

import std.stdio;

struct Foo {
    int bar;
    int baz;
}

void bletch(alias field)(int n) {
	field = n;
	writeln("%d", field);
}

int main(string[] args)
{
    Foo s;
    bletch!(s.bar)(5);
    bletch!(s.baz)(6);
    return 0;
}

This results in

[nix-shell:~/Software/d_tests]$ dmd test.d
test.d(16): Error: calling non-static function `bletch` requires an instance of type `Foo`
test.d(17): Error: calling non-static function `bletch` requires an instance of type `Foo`
(dmd-2.106.0)

Since field is aliased to s.bar or s.baz, I tried this:

import std.stdio;

struct Foo {
    int bar;
    int baz;
}

void bletch(alias field)(Foo s, int n) {
	field = n;
	writeln("%d", field);
}

int main(string[] args)
{
    Foo s;
    bletch!(s.bar)(s, 5);
    bletch!(s.baz)(s, 6);
    return 0;
}

Same complaints from the compiler:

[nix-shell:~/Software/d_tests]$ dmd test.d
test.d(16): Error: calling non-static function `bletch` requires an instance of type `Foo`
test.d(17): Error: calling non-static function `bletch` requires an instance of type `Foo`
(dmd-2.106.0)

On Wednesday, 13 December 2023 at 03:37:25 UTC, Don Allen wrote:

This works (the explicit template is due to a 'need this' bug):

import std.stdio;

struct Foo {
    int bar;
    int baz;
}

template bletch(alias field)
{
    static void bletch(T)(ref T self, int x) {
        auto pField = &__traits(child, self, field);
        *pField = x;
        writefln("%d", *pField);
    }
}

int main(string[] args)
{
    Foo s;
    bletch!(s.bar)(s, 1);
    bletch!(s.baz)(s, 2);
    return 0;
}

On Wednesday, 13 December 2023 at 03:37:25 UTC, Don Allen wrote:

Try this, it works since dmd 2.087:

struct Foo {
    int bar;
    double baz;

	void bletch(alias field)(typeof(field) newValue) {
        field = newValue;
	}
}

void main(string[] args) {
    import std.stdio;

    Foo s;
    s.bletch!(Foo.bar)(3);
    s.bletch!(s.baz)(4); // this also works - the same as above
    writeln(s);

    auto setBar = &s.bletch!(Foo.bar);
    auto setBaz = &s.bletch!(Foo.baz);

    pragma (msg, typeof(setBar));
    pragma (msg, typeof(setBaz));
    setBar(18);
    setBaz(19.5);
    writeln(s);
}

By making bletch a member function of Foo it will naturally have "an instance of type Foo" - the implicit this parameter that all member functions receive. Afterwards, you can see that we can take the address of the member function template instance &s.bletch!(Foo.bar) which results in a delegate (and not a function pointer). This allows us to call bletch through this delegate as it will supply s as the context pointer.