Python AST as XML

[Oleg Paraschenko]

Hello,

maybe of some interest:

http://pysch.sourceforge.net/ast.html

XML can be considered as an external representation of in-memory
tree-like structures, and XML-related standards — as methods of
processing such data. Some types of applications may benefit
from this approach. One of the examples are compilers with
theirs parse trees.

The Pysch distribution contains an example of representing Python
parse trees (abstract syntax trees, AST) as XML and applying an
XSLT transformation to these trees.

At the moment the whole code should be considered as a toy,
not as a production version. Anyway, it works.

....

 

[Andy Dingley]

maybe of some interest:

Maybe 5 years ago, before we realised what a bad idea it was.

http://pysch.sourceforge.net/ast.html

XML can be considered as an external representation of in-memory
tree-like structures,

Yes. But why would I want to ? XML is a clumsy _internal_
representation and it's only useful as an external representation if
you need some lowest-common-denominator more than you need a good and
appropriate representation. The best external representation of
Python is some Python source, not some over-abstracted XML version.

and XML-related standards as methods of processing such data.

XML-related protocols don't process data, they process an XML
representation of that data. Their ability to do so is based on the
XML aspect of it, not the underlying data model. This makes them
somewhere between clumsy to develop wiith, or simply incapable of
addressing the problem.

"Lets make all our data standards interwork by using XSLT" was the
theme of late '99. It didn't work.

 

[Oleg Paraschenko]

Hello,

Maybe 5 years ago, before we realised what a bad idea it was.

Definitely, I'm not from this "we" set.

http://pysch.sourceforge.net/ast.html

XML can be considered as an external representation of in-memory
tree-like structures,

Yes. But why would I want to ?

Have you used XPath to navigate in a tree? Have you wrote functions
to navigate in a tree manually, using some DOM-like interface? If yes,
then you know the difference. It is like using regexps vs manual string
processing.

XML is a clumsy _internal_
representation and it's only useful as an external representation if
you need some lowest-common-denominator more than you need a good and
appropriate representation.

No, I don't worry about lowest-common-denominator. I know a silver
bullet for tree processing (xpath + xslt) and want to use it.

The best external representation of
Python is some Python source, not some over-abstracted XML version.

It depends. How can you, for example, eliminate tail recursion
in the Python source form representation?

XML-related protocols don't process data, they process an XML
representation of that data.

While data and XML representation are isomorphic, it is not
important.

Their ability to do so is based on the
XML aspect of it, not the underlying data model. This makes them
somewhere between clumsy to develop wiith, or simply incapable of
addressing the problem.

When data is tree, a gap between XML and data is minimal.

 

[Paul Boddie]

Maybe 5 years ago, before we realised what a bad idea it was.

Actually, it's something I've considered before myself, and there are
apparently various extensions to GCC (the compiler suite, not just the
C compiler) which support similar concepts, so I suppose it's the
royal "we" you're using.

http://pysch.sourceforge.net/ast.html

XML can be considered as an external representation of in-memory
tree-like structures,

Yes. But why would I want to ? XML is a clumsy _internal_
representation and it's only useful as an external representation if
you need some lowest-common-denominator more than you need a good and
appropriate representation. The best external representation of
Python is some Python source, not some over-abstracted XML version.

Unless you're writing tools in other languages. I personally find the
various Python modules for source code inspection to be adequate, but
you can't just import the compiler package in Java, for example.

XML-related protocols don't process data, they process an XML
representation of that data. Their ability to do so is based on the
XML aspect of it, not the underlying data model. This makes them
somewhere between clumsy to develop wiith, or simply incapable of
addressing the problem.

"Lets make all our data standards interwork by using XSLT" was the
theme of late '99. It didn't work.

It may not have worked in the royal court, but XSLT has lots of
interesting and productive uses provided you choose your problems
carefully. I can imagine that transforming various sections of Python
code (for simple macro implementations, for example) *is* one of those
problem areas in which XSLT can usefully be used. Moreover, by
choosing XML, the developer(s) have at least opened an area up to
various effective tools (including XSLT) which could not have been
readily used in that area before; that in itself suggests that the
project was worth undertaking, if only for the benefits subsequent
projects can derive from it.

Paul

 

[Dimitre Novatchev]

Hello,

maybe of some interest:

http://pysch.sourceforge.net/ast.html

This is definitely of interest.

An AST as any tree is a perfect fit for XSLT processing. Many people
overlook the fact that XSLT operates on generic trees, which do not have to
necessarily originate from an XML document.

My personal experience in implementing graph-processing algorithms in XSLT
(e.g. Eulerisation of a graph -- the chinese postman and the N.Y street
sweeper algorithms) shows that XSLT is efficient programming language for
such problems -- similarly it will be efficient in rewriting and
optimization.

Do keep the good work, Oleg!


Cheers,

Dimitre.

XML can be considered as an external representation of in-memory
tree-like structures, and XML-related standards - as methods of
processing such data. Some types of applications may benefit
from this approach. One of the examples are compilers with
theirs parse trees.

The Pysch distribution contains an example of representing Python
parse trees (abstract syntax trees, AST) as XML and applying an
XSLT transformation to these trees.

At the moment the whole code should be considered as a toy,
not as a production version. Anyway, it works.

...