On Sun, Feb 28, 2010 at 1:28 AM, Eric Niebler wrote:

On 2/28/2010 7:17 PM, Manjunath Kudlur wrote:

...

I am trying to define operator()(...) for my expressions. I want to be able to form expression of the form Program_(a,b) and call Program_(a, b)(10,20). Here, 'a' and 'b' are terminals and I have a mechanism shown in the code below that somehow gets the type suitable for the parameter position. Suppose 'a' is terminal, I want the first parameter position in Program_(a,b) (pos1, pos2) to be of the type 'int'.

<snip>

OK.

...

template<int N> struct call_param_type   : proto::or_<     proto::when<     proto::function<     proto::terminal,     proto::varargproto::_  >  >  >,     var_type(proto::_child_c)>

...

{};

OK, the call_param_type grammar only matches expressions of the type Program_(a, b).

...

template<typename Expr> struct program_expr {   BOOST_PROTO_BASIC_EXTENDS(Expr, program_expr<Expr>, program_domain);   BOOST_PROTO_EXTENDS_SUBSCRIPT();

  typedef void result_type;

#if 0   result_type operator()(typename boost::result_of(const Expr&)>::type x) {     std::cout<<  "program with one arg\n";   }

<snip>

This function definition eagerly evaluates the call_param_type grammar's transform against Expr regardless of whether Expr matches call_param_type's grammar or not. Trouble. Look at how you define the Program_ function:

...

template<typename A0> typename proto::result_of::make_expr::type const Program_(A0 const &a0)

This creates an expression node with tag type "tag::function" and two children: a program_ terminal and A0. When make_expr turns program_ into a Proto terminal, it uses program_domain to wrap the terminal in a program_expr. That's bad news because a program_ terminal doesn't match the call_param_type grammar. You're violating the transform's precondition.

Yeah, got it. I realise now that the passing a domain to make_expr wraps all the components of the expression also with the corresponding expression class. What I am unable to figure out it how to wrap only the final expression I want with program_expr. In this case I want to wrap expr > with program_expr. Is there an example I can look at that does something similar? Or is this the wrong way to look at the problem? Basically, I want to add the function call operator to my expressions, but only to expressions of certain forms. My thinking is, if I only wrap expressions of that certain form with my expression class, I should be OK, no? Manjunath

Suggestion: when you are having problems with evaluating a transform, try adding an MPL assertion that the expression you're passing to it actually matches the grammar.

HTH,

-- Eric Niebler BoostPro Computing http://www.boostpro.com _______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users

On Sun, Feb 28, 2010 at 8:18 PM, Eric Niebler wrote:

On 3/1/2010 2:21 PM, Manjunath Kudlur wrote:

...

Yeah, got it. I realise now that the passing a domain to make_expr wraps all the components of the expression also with the corresponding expression class. What I am unable to figure out it how to wrap only the final expression I want with program_expr. In this case I want to wrap expr  >  with program_expr. Is there an example I can look at that does something similar? Or is this the wrong way to look at the problem? Basically, I want to add the function call operator to my expressions, but only to expressions of certain forms. My thinking is, if I only wrap expressions of that certain form with my expression class, I should be OK, no?

Ah, you want a different expression interface based on the structure of the expression being wrapped. There's a straightforward way to do that, but it's not obvious. See the program below.

Thanks, it seems obvious now :). I am including my code too, so that there is one more example for people to look at. I began wondering about a related problem when writing this code. Because of the way program_generator is defined below, any expression of the form Program_(a0, a1... an) gets wrapped in program_expr. Suppose I want to restrict the number of parameters to the function call operator to the number of arguments to Program_(). In other words, I want to make Program_(a0, a1)(10, 20, 30), Program_(a0, a1)(10) etc. illegal. I can invent one expression wrapper for every possible Program_(..) and in that wrapper class, define the function call operator with the correct number of arguments, i.e., wrap Program_(a0) in program1_expr, wrap Program_(a0, a1) in program2_expr etc., and define these classes. That would work of course. Is there a way to define member functions in the wrapper class that are valid only for certain kinds of expressions? I experimented a little with boost::enable_if, but that didn't seem to work. Any thoughts? Manjunath #include #include #include #include #include #include <iostream> #include <sstream> #include <string> namespace proto=boost::proto; namespace mpl=boost::mpl; unsigned int ids; template<typename VT> struct Var { unsigned int id; Var() { id = ++ids; } }; typedef proto::terminal::type int32_; typedef proto::terminal::type float_; struct program_ {}; template<class E> struct program_expr; struct call_grammar : proto::or_< proto::function< proto::terminal, proto::varargproto::_ > > >

{};

struct program_generator : proto::or_< proto::when(proto::_expr) >, proto::otherwiseproto::_expr

{};

struct program_domain : proto::domain {}; struct _var_type : proto::callable { template<typename Sig> struct result; template struct result { typedef T type; }; }; struct var_type : proto::or_< proto::whenproto::_ >, _var_type(proto::_value)> > {}; template<int N> struct call_param_type : proto::or_< proto::when< proto::function< proto::terminal, proto::varargproto::_ > > >, var_type(proto::_child_c)> > {}; template <typename Expr> struct program_expr { BOOST_PROTO_BASIC_EXTENDS(Expr, program_expr<Expr>, program_domain); BOOST_PROTO_EXTENDS_SUBSCRIPT(); typedef void result_type; result_type operator()(typename boost::result_of(const Expr &)>::type x) const { std::cout << "program with one arg\n"; } result_type operator()(typename boost::result_of(const Expr &)>::type x, typename boost::result_of(const Expr &)>::type y) const { std::cout << "program with two args\n"; } }; template<typename A0> typename proto::result_of::make_expr::type const Program_(A0 const &a0) { return proto::make_expr( program_(), boost::ref(a0)); } template typename proto::result_of::make_expr::type const Program_(A0 const &a0, A1 const &a1) { return proto::make_expr( program_(), boost::ref(a0), boost::ref(a1)); } int main() { int32_ a,b,c; //Program_(a)(10); Program_(a, b)(10, 20); Program_(a, b)(10); }

On 3/2/2010 6:24 PM, Joel Falcou wrote:

Manjunath Kudlur wrote:

...

Is there a way to define member functions in the wrapper class that are valid only for certain kinds of expressions? I experimented a little with boost::enable_if, but that didn't seem to work. Any thoughts?

Look at how the proto calculator works. You just need to compute () ariy using a transform adn then juse a static assert in the expression evaluation

It's not actually quite that simple in this case. Manjunath has defined his function call overloads as follows: result_type operator()( typename boost::result_of(const Expr &)>::type x, typename boost::result_of(const Expr &)>::type y) This function is *not* a template, so the types mentioned in its signature are evaluated eagerly. The call_param_type transform extracts the Nth child from Expr. If Expr doesn't have enough child nodes, it violates the transform's preconditions. Compiler errors are sure to result. One solution would be to rewrite the overloads as: template result_type operator()(A0 const &a0, A1 const &a0) const and then within the function add compile-time assertions that (a) the number of arguments is currect, and (b) that each argument type is implicitly convertible to the expected types. The other option would be to move the function call overloads into a CRTP base that is partially specialized on the number of arguments, like: template struct program_expr_base; template<class Expr> struct program_expr_base { void operator()( typename boost::result_of< call_param_type<0>(Expr const &) >::type x ) const { ... } }; // more specializations. See docs for BOOST_PROTO_LOCAL_ITERATE // and friends Then your program_expr inherits from program_expr_base. At this point, I would also give up on making program_expr a POD and just use proto::extends. Finally, there'll be an ambiguity because both program_expr_base and boost::extends will define operator(). To resolve that, you'll need "using program_expr_base<Expr>::operator();" in program_expr. HTH, -- Eric Niebler BoostPro Computing http://www.boostpro.com

One solution would be to rewrite the overloads as:

 template  result_type operator()(A0 const &a0, A1 const &a0) const

and then within the function add compile-time assertions that (a) the number of arguments is currect, and (b) that each argument type is implicitly convertible to the expected types.

Here is the code as per the above suggestion, preserved for posterity : #include #include #include #include #include #include #include #include #include <iostream> #include <sstream> #include <string> namespace proto=boost::proto; namespace mpl=boost::mpl; unsigned int ids; template<typename VT> struct Var { unsigned int id; Var() { id = ++ids; } }; typedef proto::terminal::type int32_; typedef proto::terminal::type float_; struct program_ {}; template<class E> struct program_expr; struct call_grammar : proto::or_< proto::function< proto::terminal, proto::varargproto::_ > > >

{};

struct _var_arity : proto::or_< proto::whenproto::_ >, proto::make > >

{};

struct _prog_arity : proto::or_< proto::when< proto::function, proto::varargproto::_ > > >, proto::fold >, proto::make > > >

{};

template<typename Expr> struct prog_arity : boost::result_of<_prog_arity(Expr)> {}; struct program_generator : proto::or_< proto::when(proto::_expr) >, proto::otherwiseproto::_expr

{};

struct program_domain : proto::domain {}; struct _var_type : proto::callable { template<typename Sig> struct result; template struct result { typedef T type; }; }; struct var_type : proto::or_< proto::whenproto::_ >, _var_type(proto::_value)> > {}; template<int N> struct call_param_type : proto::or_< proto::when< proto::function< proto::terminal, proto::varargproto::_ > > >, var_type(proto::_child_c)> > {}; template <typename Expr> struct program_expr { BOOST_PROTO_BASIC_EXTENDS(Expr, program_expr<Expr>, program_domain); BOOST_PROTO_EXTENDS_SUBSCRIPT(); typedef void result_type; template<typename A0> result_type operator()(A0 a0) const { BOOST_MPL_ASSERT_RELATION(1, ==, prog_arity<Expr>::type::value); BOOST_MPL_ASSERT((boost::is_same(const Expr &)>::type>)); std::cout << "program with one arg\n"; } template result_type operator()(A0 a0, A1 a1) const { BOOST_MPL_ASSERT_RELATION(2, ==, prog_arity<Expr>::type::value); BOOST_MPL_ASSERT((boost::is_same(const Expr &)>::type>)); BOOST_MPL_ASSERT((boost::is_same(const Expr &)>::type>)); std::cout << "program with two args\n"; } template result_type operator()(A0 a0, A1 a1, A2 a2) const { BOOST_MPL_ASSERT_RELATION(3, ==, prog_arity<Expr>::type::value); BOOST_MPL_ASSERT((boost::is_same(const Expr &)>::type>)); BOOST_MPL_ASSERT((boost::is_same(const Expr &)>::type>)); BOOST_MPL_ASSERT((boost::is_same(const Expr &)>::type>)); std::cout << "program with three args\n"; } }; template<typename A0> typename proto::result_of::make_expr::type const Program_(A0 const &a0) { return proto::make_expr( program_(), boost::ref(a0)); } template typename proto::result_of::make_expr::type const Program_(A0 const &a0, A1 const &a1) { return proto::make_expr( program_(), boost::ref(a0), boost::ref(a1)); } template typename proto::result_of::make_expr::type const Program_(A0 const &a0, A1 const &a1, A2 const &a3) { return proto::make_expr( program_(), boost::ref(a0), boost::ref(a1), boost::ref(a3)); } int main() { int32_ a,b,c; int p1 = 10, p2 = 20, p3 = 30; Program_(a)(p1); Program_(a,b)(10, p2); Program_(a,b,c)(10, 20, p3); }