In the discussion of hygienic macros, a couple of people
mentioned one particularly common family of macros: ones
that let you say things like
withlock my_lock:
do some stuff
and have it turn into
my_lock.acquire()
try:
do some stuff
finally:
my_lock.release()
or something of the kind. Tim Peters even suggested (tongue
presumably in cheek) a "withlock" macro for this. Here's a
simple generalization that I've been wondering about for a
while.
Introduce a new keyword. Call it "with", for the moment,
though people who are used to "with" meaning "let me abbreviate
stuff in such-and-such a namespace" may find that strange.
Now say that
with LHS=EXPR:
BODY
is the same as
TEMPNAME=EXPR
LHS=TEMPNAME.begin()
try:
BODY
finally:
TEMPNAME.end()
except that TEMPNAME isn't exposed and maybe except that
variables named in LHS might want to live in a scope that
includes only BODY. The "LHS=" part can be omitted, with
the obvious effect.
Example 1 (rather unnecessary, of course):
class OpenFile:
def __init__(self, *args):
self._args = args
def begin(self):
self._f = open(*self._args)
return self._f
def end(self):
self._f.close()
with f=OpenFile("foo.ps", "w"):
f.write("%!PS\n")
f.write("%%EOF\n")
Example 2:
class HtmlTag:
def __init__(self, name, **attrs):
self._name = name
self._attrs = attrs
def begin(self):
write_open_tag(self._name, self._attrs)
def end(self):
write_close_tag(self._name)
with HtmlTag("table", border=1):
for id,x,y in data:
with HtmlTag("tr"):
with HtmlTag("th"): write_text(id)
with HtmlTag("td"): write_text(x)
with HtmlTag("td"): write_text(y)
Example 3:
class AcquiredLock:
def __init__(self, lock):
self._lock = lock
def begin(self):
self._lock.acquire()
def end(self):
self._lock.release()
with AcquiredLock(my_lock):
mutate_my_data()
provoke_race_condition()
Alternative names, if "with" is bad for the reason
I mentioned above: "using", "with_object", "where",
"locally". I think "using" is the best of these,
but I like "with" better.
Bernhard Herzog suggested something similar, under
the name "under". That has a more complicated
interpretation, which feels a bit too specialized
to me. On the other hand, "under" is certainly
capable of saving more code than "with". On the
other other hand, it's more "implicit" and less
"explicit".
--
g
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4