Why is it that a try block is defined to establish a scope?

    try {
        auto x = frgl();
    }
    // ...
    // x undefined here

What is the benefit of this? If try (like static if/foreach) did NOT establish a scope, then this annoyance would go away. And if a scope was desired for some reason, then an extra pair of braces could be written within.

Right now rewriting the above requires getting the return type of frgl and declaring x to be of that type before the try block.

Design error?

On Sunday, 10 October 2021 at 16:12:31 UTC, Carl Sturtivant wrote:

A block not introducing a scope is weird, and my first reaction to the {{ }} workaround was disgust. That's with version and static foreach blocks where not introducing a scope has very clear benefits. Try/catch meanwhile is a familiar construct and people are already used to working around issues like this.

typeof(frgl()) x;
try {
    x = frgl;
} catch (Exception e) { }

I'd consider also if you can use std.exception.ifThrown or a scope statement instead:

auto x = frgl().ifThrown(typeof(frgl()).init);

On Sunday, 10 October 2021 at 16:12:31 UTC, Carl Sturtivant wrote:

    try {
        auto x = frgl();
    }
    // ...
    // x undefined here

Sidenote, do you know about scope guard?
https://tour.dlang.org/tour/en/gems/scope-guards

On Sunday, 10 October 2021 at 16:12:31 UTC, Carl Sturtivant wrote:

    try {
        auto x = frgl();
    }
    // ...
    // x undefined here

One of the main reasons to use a try block is to ensure a destructor is called at the end of the try block. If try didn't create a new scope, these things don't go out of scope, so they wouldn't be cleaned up.

On Sunday, 10 October 2021 at 16:12:31 UTC, Carl Sturtivant wrote:

    try {
        auto x = frgl();
    }
    // ...
    // x undefined here

I do not deny that my heart has greatly desired this.

Proposal:

export try {
    auto x = frgl();
}
catch (Exception) {
    return false;
}

shall be equivalent to

typeof(frgl()) x = void;
try {
    frgl().moveEmplace(x);
}
catch (Exception) {
    __EXCEPTION_BODY__
    assert(false, "`export` specified: all catch blocks must exit scope");
}
POST

Here, auto frgl dominates POST and is thus correct.

Scope guards directly in try{} should be lifted into the surrounding context, but this is confusing, so they are an error.

On Sunday, 10 October 2021 at 16:12:31 UTC, Carl Sturtivant wrote:

    try {
        auto x = frgl();
    }
    // ...
    // x undefined here

In that case you would just declare x outside and do the call in the try

On Monday, 11 October 2021 at 08:55:56 UTC, Imperatorn wrote:

Thus once again demonstrating that for a language that had a major version change over it, D2 really doesn't care about immutable.

On Monday, 11 October 2021 at 09:21:48 UTC, FeepingCreature wrote:

I don't know about that. But it's pretty standard for try to introduce a scope.

On Monday, 11 October 2021 at 09:23:27 UTC, Imperatorn wrote:

The problem is if you want to use immutable types at all, this forces you to either use awkward nested function idioms with tuple returns for more than one variable, put the entire remaining function body in the try block. It makes it impossible to keep try small.

One possible solution would be a way to try/catch as an expression:

auto x = frgl().tryCatch(Exception exc: return exc;);

But D has no precedent for statements embedded in expressions like this, so it'd be a major language shift.

export try is the only feasible approach I can see offhand.