No I'm not saying that at all, I'm just saying that if you need a function to handle all exceptions, the type system should be powerful enough to express that. E.g. in a webserver if you have a handler that needs a wrapper like:

    def wrapper():
        try:
            return handler()
        except Exception:
            logger.exception("unknown exception")
            webserver.status = 500

the type system needs to be able to determine that "f doesn't raise an exception". For example, one way to do this can be that all functions by default raise exception and we type:

    def handler() -> T: ...

    def wrapper() -> NeverRaises[T]: ...

then we have

    webserver_add('GET', '/handler', wrapper)

so that

    def webserver_add(method: str, path: str, handle_func: Callable[[], NeverRaises[T]]) -> None: ...

which is type safer.

Of course, here we need to specially handle `KeyboardInterrupt`, signals and exceptions returned by `logger` etc. I would personally recommend ignoring `KeyboardInterrupt`, and signals and type annotating `logger.exception` as `NeverRaises`. 95% is still better than 0%.