the fact that exception handlers aren't reusable and composable is really bothering me so I would like to propose something to make them reusable and composable. for example, if I have this mess:     def get_property_values(self, prop):         try:             factory = self.get_supported_properties()[prop]         except KeyError as exc:             raise PropertyError from exc         iterator = factory(self._obj)         try:             first = next(iterator)         except StopIteration:             return (x for x in ())         except abdl.exceptions.ValidationError as exc:             raise LookupError from exc         return itertools.chain([first], iterator) I get to refactor it into:     def keyerror_handler(exc):         raise PropertyError from exc     def other_handler(exc):         if isinstance(exc, StopIteration):             return (x for x in ())         raise LookupError from exc     def get_property_values(self, prop):         try:             factory = self.get_supported_properties()[prop]         except KeyError with keyerror_handler:             pass         iterator = factory(self._obj)         try:             first = next(iterator)         except (StopIteration, abdl.exceptions.ValidationError) with other_handler as result:             return result         return itertools.chain([first], iterator) and the handlers become reusable! another idea would be to use semicolons:     def get_property_values(self, prop):         try:             factory = self.get_supported_properties()[prop]         except KeyError with keyerror_handler;         iterator = factory(self._obj)         try:             first = next(iterator)         except abdl.exceptions.ValidationError with validation_handler;         except StopIteration:             return (x for x in ())         return itertools.chain([first], iterator) but nobody likes semicolons