Re: [RFC] Context Managers

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 = fopen($this->filename, $this->mode); return $this->handle; } public function __exit(?Throwable $e = null) { if ($this->handle) { fclose($this->handle); } } } $ctx = new FileContext('example.txt', 'w'); $f = $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 impossible. 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 exitContext() 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 enterContext() 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 proposal. 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–catch * less control-flow code It would be strange to demand that with be safer than the rest of PHP code. That’s an odd requirement. Of course, if PHP were a compiled language, many checks could be done at compile time. But we have static analysis for that. --- Best regards, Ed