Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:129187
Precedence: list
MIME-Version: 1.0
References: <a087d9fa-112a-4631-9c84-3efae641e0db@app.fastmail.com> <AM8P250MB0170975953345DCE66B6B9B6E2C5A@AM8P250MB0170.EURP250.PROD.OUTLOOK.COM>
In-Reply-To: <AM8P250MB0170975953345DCE66B6B9B6E2C5A@AM8P250MB0170.EURP250.PROD.OUTLOOK.COM>
Date: Mon, 10 Nov 2025 09:13:27 +0200
Message-ID: <CAMW7n8AZ0-TzMgcVdJnPjx92AZcar78hU8npr3MtAiCbjTV7yQ@mail.gmail.com>
Subject: Re: [PHP-DEV] [RFC] Context Managers
To: Bob Weinand <bobwei9@hotmail.com>
Cc: Larry Garfield <larry@garfieldtech.com>, php internals <internals@lists.php.net>, 
	=?UTF-8?Q?Tim_D=C3=BCsterhus?= <tim@bastelstu.be>, 
	Arnaud Le Blanc <arnaud.lb@gmail.com>, Seifeddine Gmati <azjezz@carthage.software>
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
From: edmond.ht@gmail.com (Edmond Dantes)

Hello all.

> It makes it very easy to not call the exitContext() method when calling
> enterContext() manually

Consider the code below:

```php

class FileContext {
    private $handle;

    public function __construct(private string $filename, private
string $mode) {}

    public function __enter() {
        $this->handle =3D fopen($this->filename, $this->mode);
        return $this->handle;
    }

    public function __exit(?Throwable $e =3D null) {
        if ($this->handle) {
            fclose($this->handle);
        }
    }
}

$ctx =3D new FileContext('example.txt', 'w');
$f =3D $ctx->__enter();

try {
    fwrite($f, "Hello world");
} finally {
    $ctx->__exit();
}
```

Question: what is the probability of making a mistake in this code?
What is the likelihood that a programmer will forget to call enter and exit=
?

```php
...

with (new FileContext('example.txt', 'w')) as $f {
    fwrite($f, "Hello world");
}

```

In this case, the probability of forgetting to call enter or exit is
zero, since the language now supports this paradigm at the syntax
level.

Question: what is the probability of accidentally calling a method
instead of not calling it?

```php
...

with (new FileContext('example.txt', 'w')) as $f {
    $f->__enter(); // Error!
    fwrite($f, "Hello world");
}

```

I believe that finding a clear mathematical proof in this case is impossibl=
e.
But if we look at studies on error statistics, it is the absence of a
call that is the most common problem.
(https://tomgu1991.github.io/assets/files/19compsac.pdf)

> Thus, we have a big pitfall, wherein APIs may expect enterContext() and e=
xitContext()
Is it really a big pitfall? If so, then functions like `fopen` and
`fclose` should be removed from the language altogether,
because their existence is an even bigger pitfall.

> Ultimately you definitely will need the capability of calling enterContex=
t() and exitContext() manually too (i.e. restricting that is not realistic =
either)

Of course, they can be restricted: make the methods private, so that
only PHP itself can call them, and they cannot be accidentally called
anywhere else outside the class.
But I don't see any convincing reasons for doing that.

> The proposed approach only allows nesting contexts, but not interleaving =
them.
Why does this need to be done at all?
I don't know what "interleaving contexts" means in practice.
But even if they do exist, that goes beyond the scope of the current propos=
al.

Nevertheless, it is worth noting that studying Python bugs for this
RFC is a good thing:
https://bugs.python.org/issue29988 - with statements are not ensuring
that __exit__ is called if __enter__ succeeds.

Also:
https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager

Total:
**Advantages of `with`:**
* better semantics than try=E2=80=93catch
* less control-flow code

It would be strange to demand that `with` be safer than the rest of PHP cod=
e.
That=E2=80=99s an odd requirement. Of course, if PHP were a compiled langua=
ge,
many checks could be done at compile time.
But we have static analysis for that.

---
Best regards, Ed