Re: [ANN] an EBNF parser and coding pattern tool (LGPL)

[Hyman Rosen <hyrosen@mail.com>]

Stephen Leake wrote:
> Is there any language whose generics do this?

Not that I know of, except maybe for the lisp-like ones.
But Java is certainly able to do it at runtime.

> You've lost me here. If I need to navigate a tree, I first have to
> build the tree, presumably using a tree class. Then the tree class
> must provide a "walker" (aka "iterator"). Where do "generics" or
> "templates" come into it?

When things are known at compile time, they can be generated
at compile time. You need to read up on what's being done in
the world of C++ templates. Here's a cursory synopsis:

     struct Nil { };

     template <typename T1, typename T2>
     struct TList
     {
         typedef T1 first;
         typedef T2 rest;
     };

Now, given an arbitrary class, like

     struct A { int a; double c; char *p; };

I could reasonably ask the compiler to provide me with

     Introspect<A>::FieldTypes

which would be a typedef for

     TList<int, TList<double, TList<char *, Nil> > >

and then I could write "recursive" templates which would
work on this typelist. If I had a similar list of integers
that gave the offset of each field within A, I could then
use the pair of lists to build a serialization mechanism
as a generic function that would wotk for arbitrary classes.
(I'd need something similar for the base classes, but you
get the idea.) The actual code that would wind up being
generated by an instantiation for a particular type would
be a straightforward set of operations on each field, which
is why it's so desirable for this to be in templates.

So you see, this answers your question. The "tree" is built
by the compiler, and is represented by the TList<...> type.
The walker/iterator is done through template partial
specializations (which I realize I haven't shown, so here's
an example).

     // Get the Nth type of a typelist
     template <int N, typename T>
     struct Select;

     template <typename T1, typename T2>
     struct Select<0, TList<T1, T2> >
     { typedef T1 Type; };

     template <int N, typename T1, typename T2>
     struct Select<N, TList<T1, T2> >
     { typedef typename Select<N - 1, T2>::Type Type; };