Questions and feedback can go here

[FeepingCreature]

hooray

[ntrel]

Hi, thanks for adding discussions!

There were a couple of things I don't understand. From the aliastest.nt test, how come a binary expression can be aliased? See c below:

struct S
{
    int a;
    int b;

    alias c = (a + b);
}

void main() {
    // FIXME assert(S(2, 3).c == 5);
    auto s = S(2, 3);
    assert(s.c == 5);
}

Also:

int a = 5;
auto add = b => a + b;
assert(add(2) == 7);

How come add can be initialized from a lambda - it says a lambda is a function template? How is the type known at that stage?

[FeepingCreature]

Haha! I am unreasonably proud of those.

Regarding structs, you can alias anything that's a symbol: types, functions, expressions. "Symbol" is a very expansive term in Neat. What happens there is just that the expression to the right side of the alias is compiled in the lexical context of a struct access. This works because the "frame pointer" of an access is freely assignable; so s.c is exactly equivalent to s.a + s.b: a and b are accessed in the context of s like they would be accessed in the context of this in a struct method. (It's the exact same mechanism.) I really like this idiom because it means you aren't fully reliant on the compiler for inlining struct property expressions.

How come add can be initialized from a lambda - it says a lambda is a function template? How is the type known at that stage?

Correct: it's a function template value. Consider it similar to a struct with a templated method: the struct has a value, even though the method isn't instantiated yet. In this case, the value of the lambda is just a pointer to the function frame; that's what gets actually stored in auto add. This works because nested functions aren't inspected for the variables they actually access, they just get the full frame at that point as a parameter.

This is one major difference to D, where the context has to be passed to the called function implicitly by hoisting it into the calling frame; that's why struct methods can't be instantiated with lambdas in D. D's approach is disgustingly clever, but I think Walter just went the wrong way here.