On Thursday, 25 November 2021 at 15:05:55 UTC, zjh wrote:

The idea of scope is allowing @safe access to raw pointers/arrays with limited lifetime. RAII in C++ doesn't do anything to protect basic types like that.

What are you thinking of? If return scope and return ref used symbols such as ^% and ^$ (for example), that wouldn't make it simpler.

On Thursday, 25 November 2021 at 16:11:39 UTC, Dennis wrote:

struct S {
    ref int opIndex() return ref scope {

    }
}

Seems like we may be reaching the point where it's worth it to make the this parameter explicit, like it is in Python and Rust:

struct S {
    ref int opIndex(return ref scope this) {
        // ...
    }
}

On Thursday, 25 November 2021 at 16:11:39 UTC, Dennis wrote:

struct S {
    ref int opIndex() return ref scope {

    }
}

Jesus... Recall how, at that one DConf, Scott Meyers suggested that D would be wise to not require a Scott Meyers? Well what do you know, if you have

ref what() return;
ref the() return scope;
ref fuck() return ref scope;

all in the same language, then you'd need a Meyers-Sutter hybrids mass-cloned 24/7 in a specialized facility for the sole purpose of teaching this stuff, if you want the language to get anywhere. And some enslaved clones of Andrei locked away in a basement, churning out book after book titled "Writing code that don't not work". Something stinks something fierce here.

https://dlang.org/spec/function.html#parameters needs to get simpler, not turn into a PhD thesis, which it is already well on the way to.

On Thursday, 25 November 2021 at 20:45:41 UTC, Stanislav Blinov wrote:

My proposal (as mentioned in the issue) is that return in any other position than directly before scope refers to return-ref, so only return scope results in return-scope. Also I think lazy and out can go, though suggesting to remove a feature tends to bring out people who like the feature and oppose the removal.

What do you propose?

On Thursday, 25 November 2021 at 20:45:41 UTC, Stanislav Blinov wrote:

struct S {
    ref int opIndex() return ref scope {

    }
}

ref what() return;
ref the() return scope;
ref fuck() return ref scope;

Don't forget 😁

ref what() return;
ref the() return scope;
ref fuck() return ref scope;

auto ref what() return;
auto ref the() return scope;
auto ref fuck() return ref scope;

auto ref f1(int x)     { return x; }  // value return
auto ref f2()          { return 3; }  // value return
auto ref f3(ref int x) { return x; }  // ref return
auto ref f4(out int x) { return x; }  // ref return
auto ref f5() { static int x; return x; }

// etc

On Thursday, 25 November 2021 at 21:08:37 UTC, Imperatorn wrote:

ref what() return;
ref the() return scope;
ref fuck() return ref scope;

auto ref what() return;
auto ref the() return scope;
auto ref fuck() return ref scope;

auto ref f1(int x)     { return x; }  // value return
auto ref f2()          { return 3; }  // value return
auto ref f3(ref int x) { return x; }  // ref return
auto ref f4(out int x) { return x; }  // ref return
auto ref f5() { static int x; return x; }

// etc

Sorry I meant

@safe @nogc pure nothrow auto ref fuck(ref int x) return ref scope;

On Thursday, 25 November 2021 at 20:45:41 UTC, Stanislav Blinov wrote:

"Fools ignore complexity. Pragmatists suffer it. Some can avoid it. Geniuses remove it." - Alan Perlis, American Scientist .

We need more of these 'geniuses'.

On Thursday, 25 November 2021 at 21:07:50 UTC, Dennis wrote:

If I ever have to explain to someone in the Learn forum why scope return means something different from return scope, I will cry.

More seriously: this is exactly the kind of obscure "gotcha" that makes C++ so beginner-hostile, and IMO it is worth going to considerable lengths (including breaking changes) to avoid it.