On 16/11/2025 15:29, Frederik Bosch wrote:
On Sat, 15 Nov 2025 23:11:44 +0000, Rowan Tommins [IMSoP] wrote:
The Block Scoping RFC and the Context Manager RFC cover a lot of similar
use cases, and a lot of the discussion on both threads has been
explicitly comparing them.
To try to picture better how they compare, I have put together a set of
examples that implement the same code using both features, as well as
some other variations, in this git repo:
https://gitlab.com/imsop/raii-vs-cm
Another suggestion would be to follow the Java try-with-resources syntax. It does not require a new keyword to be introduced, as with the Context Manager syntax. Moreover, it aligns with current try-catch-finally usage already implemented by PHP developers.
try ($transaction = $db->newTransaction()) {
$db->execute('UPDATE tbl SET cell = :cell', ['cell'=>'value']);
}
blah(foo);
}
catch ( SomeException e ) {
whatever();
}
In C#, you can instead use a statement version of using within any existing block:
try {
using ( Something foo = new Something );
blah(foo);
}
catch ( SomeException e ) {
whatever();
}
Both are very similar to RAII, but because both languages use non-immediate garbage collection, the method is separate from the normal destructor / finalizer, and other references to the "closed"/"disposed" object may exist.
At the moment, I haven't included examples inspired by these, because I thought they would be too similar to the existing RAII examples and clutter the repo. But if there's a difference someone thinks is worth highlighting, I can add one in.
Any object that implements TryWithContext can be used with such syntax. The function returns the exit context operation as callback.
interface TryWithContext {
public function tryWith(): \Closure;
}
I can't find any reference to this in relation to Java; did you take it from a different language, or is it your own invention?
Either way, it looks like an interesting variation on the Python-based enterContext/exitContext. Do you have any thoughts on what it's advantages or disadvantages would be?
Rather auto-capture I'd suggest explicit complete scope capture, by using the use keyword without parenthesis.
This is a completely separate discussion I was hoping not to get into. Although I've personally advocated for "function() use (*) {}" in the past, I've used "fn() {}" in the "auto-capture" examples because it is the syntax most often proposed.
It's irrelevant for this example anyway, so I've edited it out below.
For a transaction it might look like this.
class Transaction implements TryWithContext {
public function tryWith(): \Closure
{
$this->db->beginTransaction();
return function (?\Throwable $e = null) {
if ($e) {
$this->db->rollbackTransaction();
return;
}
$this->db->commitTransaction();
};
}
}