Recipe for anonymous functions in python?

Question

I'm looking for the best recipie to allow inline definition of functions, or multi-line lambda, in python.

For example, I'd like to do the following:

def callfunc(func):
   func("Hello")

>>> callfunc(define('x', '''
...     print x, "World!"
... '''))
Hello World!

I've found an example for the define function in this answer:

def define(arglist, body):
    g = {}
    exec("def anonfunc({0}):\n{1}".format(
        arglist,
        "\n".join("    {0}".format(line) for line in body.splitlines())), g)
    return g["anonfunc"]

This is one possible solution, but it is not ideal. Desireable features would be:

• be smarter about indentation,
• hide the innards better (e.g. don't have anonfunc in the function's scope)
• provide access to variables in the surrounding scope / captures
• better error handling

and some things I haven't thought of. I had a really nice implementation once that did most of the above, but I lost in unfortunately. I'm wondering if someone else has made something similar.

Disclaimer:

I'm well aware this is controversial among Python users, and regarded as a hack or unpythonic. I'm also aware of the discussions regaring multi-line-lambdas on the python-dev mailing list, and that a similar feature was omitted on purpose. However, from the same discussions I've learned that there is also interest in such a function by many others.

I'm not asking whether this is a good idea or not, but instead: Given that one has decided to implement this, (either out of fun and curiosity, madness, genuinely thinking this is a nice idea, or being held at gunpoint) how to make anonymous define work as close as possible to def using python's (2.7 or 3.x) current facilities?

Examples:

A bit more as to why, this can be really handy for callbacks in GUIs:

# gtk example:
self.ntimes = 0
button.connect('clicked', define('*a', '''
    self.ntimes += 1
    label.set_text("Button has been clicked %d times" % self.ntimes)
''')

The benefit over defining a function with def is that your code is in a more logical order. This is simplified code taken from a Twisted application:

# twisted example:
def sayHello(self):
    d = self.callRemote(HelloCommand)
    def handle_response(response):
        # do something, this happens after (x)!
        pass
    d.addCallback(handle_response) # (x)

Note how it seems out of order. I usually break stuff like this up, to keep the code order == execution order:

def sayHello_d(self):
    d = self.callRemote(HelloCommand)
    d.addCallback(self._sayHello_2)
    return d

def _sayHello_2(self, response):
    # handle response
    pass

This is better wrt. ordering but more verbose. Now, with the anonymous functions trick:

d = self.callRemote(HelloCommand)
d.addCallback(define('response', '''
    print "callback"
    print "got response from", response["name"]
'''))

Answer 1

If you come from a javascript or ruby background, python's abilities to deal with anonymous functions may indeed seem limited, but this is for a reason. Python designers decided that clarity of code is more important than conciseness. If you don't like that, you probably don't like python at all. There's nothing wrong about that, there are many other choices - why not to try a language that tastes better to you?

Putting chunks of code into strings and interpreting them on the fly is definitely a wrong way to "extend" a language, just because none of tools you're working with - from syntax highlighters to the python interpreter itself - would be able to deal with "stringified" code in a sensible way.

To answer the question as asked: what you're doing there is essentially an attempt to construct some better-than-python programming language and compile it to python on the fly. The idea is not new in the world of scripting languages and can be productive or not (CoffeeScript is an example of a successful implementation), but your very approach is wrong. format() not the tool you're looking for when working with code. If you're writing a compiler, do it properly: use a parser (e.g. pyparsing) to read your code in an AST, walk through the AST to generate python code (or even bytecode), catch syntax errors as you go and take measures to provide better runtime feedback (e.g. error context, line numbers etc). Finally, make sure your compiler works across different python versions and implementations.

Or just use ruby.