How to do conditional scope(exit) ?

[Jonathan M Davis]

On Wednesday, December 18, 2024 3:16:45 PM MST John Dougan via Digitalmars-d-learn wrote:
> As the subject. The obvious way:
>
> ```D
> import std;
>
> int test(int val)
> {
>      writeln("A");
>      if (val % 2 == 0)
>      {
>          writeln("b");
>          scope (exit)
>              writeln("scope exit ", val);
>          writeln("c");
>      }
>      writeln("F");
>      return 2 * val;
> }
>
> void main()
> {
>      writeln("== start =========================");
>      int v1 = test(1);
>      writeln("== 2 ==============================");
>      int v2 = test(2);
>      writeln("== end ===========================");
> }
> ```
> results in:
>
> ```
> == start =========================
> A
> F
> == 2 ==============================
> A
> b
> c
> scope exit 2
> F
> == end ===========================
> ```
>
> which isn't what I want. The case for `test(1)` is fine. For
> `test(2))` I want the  `scope exit 2` to come after the `F`. Is
> there a way to tell it that I want to use an enclosing scope or
> make it ignore the scope on the `if`?

scope statements are run when the scope that they're in exits (with
scope(exit) always running, scope(failure) running only when the scope is
exited via an exception being thrown, and scope(success) only being run when
no exception is thrown). There is no way to control whether they run beyond
whether it's exit, failure, or success, and trying to insert if statements
around scope statements is just going to change which scope that they refer
to, since you can't put a scope statement in an inner scope and then have it
be run for an outer scope. It's always for the scope that the scope
statement is in.

Now, you _can_ put an if statement within the scope statement to control
what's run within the scope statement, but that condition will be checked
when the scope statement is run. So, you may be able to get what you want
that way, but scope statements themselves are quite simple and not
particularly flexible. Ultimately, they're just a way to not have to
manually write a try-catch block when you don't care about actually looking
at the exception being thrown and just want to write code that runs or
doesn't run based on whether the scope is exited normally or via an
exception being thrown.

One thing to remember is that scope statements are implemented as try-catch
blocks. So, if you have something like

{
    scope(exit) doStuff();
    runCode();
}

it'll be lowered to something along the lines of

{
    try
    {
        runCode();
        doStuff();
    }
    catch(Exception e)
    {
        doStuff();
        throw e;
    }
}

and

{
    scope(failure) doStuff();
    runCode();
}

will be lowered to something like

{
    try
    {
        runCode();
    }
    catch(Exception e)
    {
        doStuff();
        throw e;
    }
}

whereas

{
    scope(success) doStuff();
    runCode();
}

will be lowered to something like

{
    runCode();
    doStuff();
}

So, when you're considering what can or can't be done with scope statements,
thinking about how they're lowered to try-catch blocks may help you
understand why they work the way that they do. And if you can't do what you
want to do with a try-catch block, then you definitely can't do it with
scope statements, since that's what they ultimately are.

- Jonathan M Davis