with-statement

I want to have developers write some custom apps for a site in Javascript but I want to sandbox it so they can't do anything naughty like redirect the user, set the body display to none etc etc. I have a namespace in Javascript where all the functions they'll ever need exist in there so I was thinking to create a sandbox would be a matter of: with(Namespace) { //App code goes here where they can only access Namespace.* } How is easy is it to get around this and what other methods can be done? Would rather not have to moderate every submitted app. To enforce a sandbox, you would have to inspect

Instead of this: FILE = open(f) do_something(FILE) FILE.close() it's better to use this: with open(f) as FILE: do_something(FILE) What if I have something like this? if f is not None: FILE = open(f) else: FILE = None do_something(FILE) if FILE is not None: FILE.close() Where do_something also has an "if FILE is None" clause, and still does something useful in that case - I don't want to just skip do_something if FILE is None. Is there a sensible way of converting this to with/as form? Or am I just trying to solve the optional file problem in a wrong way? If you were to just write it like this:

I was looking for a macro that will resemble the with-construct. The usage should be something like: with (lock(&x), unlock(&x)) { ... } It might be useful for some other purposes. I came up with this macro: #define __with(_onenter, _onexit, v) \ for (int __with_uniq##v=1; __with_uniq##v > 0; )\ for (_onenter; __with_uniq##v > 0; _onexit) \ while (__with_uniq##v-- > 0) #define _with(x, y, z) __with(x, y, z) #define with(_onenter, _onexit) _with(_onenter, _onexit, __COUNTER__) It has 3 nested loops because it should: Initialize loop counter (C99 only, of course) Possibly initialize variable

I have a simple question. Somehow I was unable to find a definitive answer. How much is WITH RECURSIVE syntax optimized in PostgreSQL? By that I mean: is it merely a syntactic sugar for a series of non recursive queries, OR is it more of a single statement that despite its complicated semantics has been optimized as a whole. A follow-up question - just about how much is it possible to optimize this kind of syntax? Of course some concrete data on the matter is most welcome. My experience is that it is indeed very well optimized. Check out the execution plan for your query generated by EXPLAIN