Recoverable Exceptions in Python

Recoverable Exceptions in PythonAuthor:Michael HudsonEmail:mwh@python.netApologies for the very simple slides, I had toolproblems, and ran out of time to try to fix them.This was largely because I kept changing my mindabout what I wanted to say, and then how I wanted tosay it...

What Do I Mean By A RecoverableException?Simply, an exception where it's possible to choosebetween various ways of dealing with the problem,including carrying on from the point where the problemwas found and returning the error to calling code (as inPython).[CL demo]

Why Would We Want This?It's hard to really give a good answer to this. Errorhandling is a 'programming in the large' topic, notsuited to simple demos in conference presentations.Part of the reason for this is that error handling islargely about protocol, and you don't really needprotocol if you've written all the code involved (more onthis later).

How Do We Do This?Think about how exception handling works in Pythontoday: control is transferred to different code afterunwinding the stack.To allow resumption after the error, we must transfercontrol to different code without unwinding the stack.This is just a function call.

Instead of:How Might We Use This?def divide(a, b):if b == 0:raise ZeroDivisionError()else: return a / bwe might write:def divide(a, b):if b == 0:return handle(ZeroDivisionError())else: return a / bhandle can raise the error or return some "infinite"value as it sees fit.

A Sidestep: zope.eventPart of Zope 3, the zope.event module allows you totell interested but unknown to you code aboutsituations you've encountered:def divide(a, b):if b == 0:zope.event.notify("dividing by zero")return HUGE_VALelse: return a / bIt isn't an error handling system because it's only anotification: it's not expected that the event handlerswill try to influence the course taken by the notifyingcode.

subscribers = []The Entire Code Of zope.eventdef notify(event):for subscriber in subscribers:subscriber(event)Pretty simple huh?

Why write zope.event if it's so simple?So What's The Point?It's about protocol again: You or I could writezope.event at the drop of a hat, but for it to be useful,the code doing the notifying and the code doing thenoticing have to use the same mechanism.zope.event is designed to impose the minimum amountof policy consistent with this goal (zope.app.event doessomething complicated with interfaces).

Another Sidestep: PEP 343Exception handlers in Python today have what is called"dynamic extent"; they are active for a period of timedetermined by where control is in a program.If we are to implement an error handling systemsupporting system in Python, we want the sameproperty and PEP 343 lets us do this.The system in a few slides time will let you write:with handler(a_handler):... handler active here ....

More about PEP 343Roughly speaking, part of PEP 343 proposes that:with expr as var:... code ...becomes:hidden_var = exprvar = hidden_var.__enter__()try:... code ...finally:var.__exit__()(ignoring some stuff about exceptions).

On With The CodeIt was a bit of a stretch to fit it onto slides, so...[Python demo]

RestartsEven harder to fit examples of onto one side,experience in the common lisp community shows thatthere is value in adding another abstraction to the mix:restarts.A restart is, essentially a means of continuing. Codecan arrange for restarts to be available, and a handlercan choose among them.[Demo This]

So ... what?Just after I realised that restartable exceptions werereally easy to implement, I'd originally intended todevelop a fancy, amazing restartable exception systemand show it off now.This didn't last very long; code written today that raisesan exception doesn't expect control to be coming backand would break mightily if it did.What I'd like you to take away from this talk is the ideathat when something goes wrong and you don't knowwhat to do, don't just give up, maybe you can asksomeone else what to do.

More ConclusionsAs to whether core Python would benefit from thisapproach, I find that really hard to say.As mentioned above, there should be at most onerestartable exception implementation so there wouldbe some advantage to bundling it with Python. Also, itwould be nice if the Python core allowed continuationafter some errors (NameErrors, anyone?), thoughlacking the ability to fix code while it's executing makesthis less useful.Anyway, I hope this talk was interesting!

Credits and ReferencesI should certainly credit two of Kent Pitman's papers:* "Condition Handling in theLisp Language Family"* "Exceptional Situations In Lisp"available on the web at:http://www.nhplace.com/kent/Papers/index.htmlI also read various things about error handling inSmalltalk, but ran out of time to research it properly (ortalk about them).Steve Alexander pointed out zope.event to me.

Questions?