scope guards

[Jacob Carlborg via Digitalmars-d]

On Sunday, 3 August 2014 at 15:28:43 UTC, Manu via Digitalmars-d 
wrote:
> I'm trying to make better use of scope guards, but I find 
> myself belting
> out try/catch statements almost everywhere.
> I'm rather disappointed, because scope guards are advertised to 
> offer the
> promise of eliminating try/catch junk throughout your code, and 
> I'm just
> not finding that to be the practical reality.
>
> I think the core of the problem is that scope(failure) is 
> indiscriminate,
> but I want to filter it for particular exceptions. The other 
> issue is that
> you still need a catch() if you don't actually want the program 
> to
> terminate, which implies a try... :/
>
> One thing that may be leveraged to eliminate most catch blocks 
> is the
> existing ability to return from scope guard blocks, allowing to 
> gracefully
> return from a function while unwinding, akin to a catch.
> The problem then is that you can't handle specific exceptions.
>
> I'm thinking this would make all the difference:
>
> scope(failure, MyException e) // only executed for exceptions 
> of type
> MyException
> {
>   writeln(e.msg); // can refer to the exception in this failure 
> block
>   return failureValue; // and can gracefully return from the 
> function too
> }
>
> That would eliminate about 80% of my try/catch blocks.

That is exactly like a catch-block.

> The remaining suffer from the problem where I want to respond 
> to exceptions
> NOT of a specific type, ie, clean up in the case of an 
> unexpected/unknown
> exception.
>
> scope(failure, ~MyException)
> {
>   // clean up, because some unexpected exception occurred that I
> don't/can't handle.
> }

That I can agree would be useful, but within a catch-block 
instead. You can always manually check the type of the exception.

catch (Exception e)
{
     if (auto myException = cast(MyException) e)
         // handle
     else
         // cleanup
}

Of course this logic could be nicely handled with AST macros ;)

> Is there already some mechanism to do this? I couldn't find 
> anything in the
> docs.
> It seems like an obvious thing to want to do.

It seems like you want to have a catch-block without a try-block. 
I think that would be useful. A catch-block without a try-block 
would implicitly add a try-block to the same scope as the 
catch-block or to the closest function body. Ruby has this and 
it's quite nice.

void foo ()
{
     connectToDatabase();

     catch (DatabaseException e)
         cleanup();
}