Rafe said:In the name of self-education can anyone share some pointers, links,
modules, etc that I might use to begin learning how to do some
"metaprogramming".
Given that, can anybody think of an example that you could not do with
a class? (excepting the "stored procedure" aspect)
Hendrik said:I am not sure I understand the answer - if the input and output are both
bits of python source, then the output must be stored and evaluated or
imported to get it executed, right?
Now if this is the case, my question has to do with whether it is always
possible to put the equivalent code in a class, and instantiating it so that
it is either immediately executed or ready for immediate execution. My
gut feel tells me that it should always be possible, but I have often had
wrong hunches.
Not sure if this makes it any clearer.
"Given that, can anybody think of an example that you could not do
with a class?"
Generating a template for a specific script application. For example,
a script with pre-defined callbacks that only require the addition of
the contents.
I was really interested in exploring the idea of using python output,
instead of XML, to record something a user did in a GUI. I have seen
it done and it is really advantageous in the 3D industry because it
means the script files can be edited directly, in a pinch, to generate
something slightly different.
For example, say we have code which generates a cube by plotting it's
points. A user then changes a point position in the GUI. The change is
saved by outputting the function call to a file with new arguments
(the new point location). If I wanted to make 100s of copies of the
cube, but with a slightly different point position, I could edit the
custom cube's python code and hand it back for creation without using
the GUI. I could do this with XML, but it can be harder to work with
in a text editor (though I have seen some XML editors that make it a
bit easier.) In fact, in most 3D applications, the app prints
everything the user does to a log. Sometimes in a choice of languages,
so I guess I am looking to do the same thing with my own custom tools.
In a real situation the generated code file can build some pretty
complex 3D object hierarchies. It moves beyond simple storage of data
and becomes a real script that can be hacked as necessary.
It is nice to have everything as python scripts because we always have
a blend of GUI users and developers to get a job done.
- Rafe
I am not sure I understand the answer - if the input and output are both
bits of python source, then the output must be stored and evaluated or
imported to get it executed, right?
I am not sure I understand your question.
def iterize(recursive_function_text):
<code to parse input and fill a template>
return equivalent_iterative_function_text
where input and output are both Python code. If one were to implement
this by compiling the input to AST form and then walking the tree, the
AST node classes would be involved, but I would scarely say the
translation was done by the classes, as opposed to functions which might
or might not be attacked to a class as methods.
Aaron Brady said:folly...
The example I think of is the Visitor Pattern of Gamma and all. One
class's method calls another's method with its own class's name in the
name.
class Visitor:
def visit_A( self, arg ):...
def visit_B( self, arg ):...
class A:
def visit( self, vis ):
vis.visit_A( self )
class B:
def visit( self, vis ):
vis.visit_B( self )
As you can see, the 'visit' method is mechanical for classes A and B.
One might want to autogenerate those in some languages, but Python has
introspection:
class BaseAB:
def visit( self, vis ):
getattr( vis, 'visit_%s'% self.__class__.__name__ )( self )
And it's easier to modify the default behavior this way than in
autogenerated code too.
Then another thing - it strikes me that any problem that can be solved
by metaprogramming, can be solved by putting similar code into a class
and instanciating an instance.
Does anybody know if this is true?
If it is, it limits the usefulness of metaprogramming to the creation
of "stored procedures" for "later execution".
Steven D'Aprano said:GUI designer. You write a program to let the user create code by clicking
buttons, dragging objects, drawing lines, etc. The GUI designer may use
classes, but the purpose of those classes is to generate source code.
Testing code speed... you might have some functions with a loop, and you
want to unroll the loop as an optimization. If you have one function, you
can unroll it yourself. If you have a hundred such functions, you might
want to write a program to do it. (Yes, I'm stretching...)
Don't like that Python doesn't optimize tail-recursion? Then write a
source-code analyzer that detects tail-recursion and re-writes the
function using a while loop.
It's been 20-odd years, and the examples were pretty trivial... I don't
really recall exactly, but it would have been something like this:
* design a GUI involving lots of buttons on screen, each one with quite
similar but not identical code;
* since Hypercard didn't have a layout manager, write a script to
generate each button, place it where needed, and set the button's code.
Hypercard did have a message passing hierarchy (like inheritance for
objects), so often you could take the button's code and place it in a
higher level of the hierarchy (the card, the background, the stack), but
there were odd cases where that wasn't enough.
Another example: Hypercard had a very limited number of GUI elements
(text fields and buttons, basically) but I designed a slider control
using a few buttons, each button with a custom script. To avoid needing
to create and place the buttons by hand each time I wanted a slider, I
had a script that did it for me. The script not only created the buttons,
but it created the scripts used by the buttons. This wasn't as difficult
as it sounds -- it was basically taking a template and doing some text
replacements, then telling the button to use it as a script.
I just noticed that corepy 1.0 [1] has been released. Corepy is an
embedded DSL for synthesizing machine code from chaining Python
commands. This means it provides objects and exploits control
structures used to create machine code that can finally be executed
interactively.
Let's say you have an ordinary Python function that computes a CRC 32.
Now you could attempt to translate the function into other Python code
that expresses a corepy routine. You could create a decorator that
works as follows
1) reads the source of the decorated function
2) transforms the source into corepy source and compiles it or
3) if 2) fails it just returns the passed code object.
Kay
[1] http://www.corepy.org/
Michele Simionato said:The namedtuple recipe by Raymond Hettinger (http://
code.activestate.com/recipes/500261)
is an interesting example of code generation. My own decorator module
use a similar
trick. Here code generation (plus eval/exec) is needed since you need
control on
the signature of a function. If we could change the signature of a
function (I think
this is possible in Python 3.0, I have to check) then we would not
need code
generation.
This is kind of the wrong way around - this is an example of
OO jiggery pokery that will be difficult to do by generating the
source code - are there things that can be done by generating
the source code that cannot be done with OO?
snipbody = 'L.append(None)\n'
make_file('dumb.py', 'Create a big list the dumb way.',
'L = []\n', body*numitems)
make_file('smart.py', 'Create a big list the smart way.',
'', 'L = [None]*%d\n' % numitems)
At this point, I have two source files which I can do anything I like
with. It would have been a real pain to have written the first one by
hand, even with a clever editor. I can post-process them, run them
through other tools, even open them up in an editor and manipulate them
by hand (although that defeats the purpose of metaprogramming).
Yikes, this is getting hairy- If "the problem" is to generate source code,
then you have to generate source code...
Ok this one I'll buy - I can't think of a way to do this dynamically in a
class and get runnable code back. (but maybe I'm just not trying hard enough.)
This is like TJR's example (I think)
Ok I think I am beginning to get the picture - when you have to do stuff
that the language does not directly support, then you use the simple
available elements, and create source code that strings them together
to make more complex stuff. -in this case its probably not trivial to
do it at run time.
The "make the source code" then run it, introduces a kind of compiler
stage.
For an old assembler programmer, this is starting to sound like macros.
So a different meta law would read like:
One uses Code Generation Techniques when the language does not
have macros.
*ducks*
- Hendrik- Hide quoted text -
- Show quoted text -
Want to reply to this thread or ask your own question?
You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.