Re: [boost] lisp similarity? (was Re: [proto]purpose of binary_expr<T, L, R>::type ?

From: Eric Niebler (eric_at_[hidden])
Date: 2008-03-24 16:40:48

Larry Evans wrote:
> On 03/23/08 16:02, Larry Evans wrote:
>> On 03/22/08 22:12, Eric Niebler wrote:
>>  > Larry Evans wrote:
>> [snip]
>>  >> The following grammar I think summarizes the difference between
>>  >> grammar and expression:
>>  >>
>>  >> expr //describes an expression.
>>  >>    = terminal
>>  >>    | expr+
>>  >>      //i.e. 1 or more expressions (e.g. expr<tag::plus,expr0,expr1>)
>>  >>    ;
>>
>> In addition, I wanted some way to tell what's
>> a valid 1st arg to matches.  The above description of expr is for a
>> grammar.  Now a valid 1st arg to matches would apply ::type to each
>> node in the above tree, AFAICT.  At first, I thought of:
>>
>>    expr_type
>>       = terminal::type
>>       | expr_type+
>>       ;
>>
>> but that would make:
>>
>>       ( terminal::type, terminal::type, terminal::type )
>>
>> a valid expresion when what's needed is:
>>
>>       ( terminal::type, terminal::type, terminal::type )::type
>>
> 
> OOPS (again).  I guess this would produce what's needed:
> 
>    expr_type
>       = terminal::type
>       | (expr_type+)::type
>       ;

I'm confused by your syntax, so I can't say whether this is right or 
not. I'm pretty sure the use of ::type is wrong. Let me see if I can put 
in words what an expression is, and what a grammar is, and what the 
relationship is between the two. Maybe you can combine this with your 
understanding of morphisms to formulate this.

An expression is one of:
* expr<tag::terminal, args0<X> >
* expr<Tag, argsN<A0,A1,...> > where A0,A1,... are expressions
* ref_<E> where E is an expression
* Some class type T that inherits from extends<E,T,D>, where E
   is an expression, and D is the domain of T.
* Some class type T that uses BOOST_PROTO_EXTENDS(E,T,D) to
   extend an expression type E in the domain D.

A grammar is:
* _
* An expression
* expr<tag::terminal, args0<exact<X> > >
* expr<tag::terminal, args0<convertible_to<X> > >
* expr<Tag, argsN<A0,A1,...> > where A0,A1,... are grammars
* expr<_, argsN<A0,A1,...> > where A0,A1,... are grammars
* expr<Tag, argsN<A0,A1,...,vararg<B> > > where A0,A1,... are
   grammars, and B is a grammar.
* expr<_, argsN<A0,A1,...,vararg<B> > > where A0,A1,... are
   grammars, and B is a grammar.
* or_<A0,A1,...> where A0,A1,... are grammars
* and_<A0,A1,...> where A0,A1,... are grammars
* switch_<C> where C is class type representing a set
   of grammars.
* if_<T> where T is a transform that yields a compile-time
   Boolean
* if_<T,Then> where T is a transform that yields a compile-time
   Boolean and Then is a grammar
* if_<T,Then,Else> where T is a transform that yields a compile-
   time Boolean and Then and Else are grammars
* not_<A> where A is a grammar
* Some type T for which T::proto_base_expr is a grammar
  (e.g., negate<X>)

-- 
Eric Niebler
Boost Consulting
www.boost-consulting.com