Manuel Jung wrote:
Eric Niebler wrote:
Manuel Jung wrote:
Could you give a pointer or a list, what changed in the trunk?
Lots changes in trunk all the time. What are you referring to? The recent problems with Boost.Test? Changes to Proto? Something else?
Oh, I mean the changes to Proto since the review.
A lot has changed. First the simple things: * Proto lives at boost/proto/, not boost/xpressive/proto * boost/proto/proto.hpp now includes all of proto with the exception of the typeof registrations. That includes the contexts, the transforms and the debugging utilities. If you just want the core of proto without the other stuff, there is boost/proto/core.hpp * s/posit/unary_plus/ * s/arg/child, s/arg_c/child_c/, s/_argN/_childN * s/bind/lazy/ * s/_visitor/_data/ * The proto::transform namespace is no more. * There is a new _default transform, that is analogous to the default_context. Some bigger changes: The protocol for defining a primitive transform has changed. Previously, primitive transforms were just ternary function objects like this: struct MyTransform : proto::callable { template<class Sig> struct result; template<class This, class Expr, class State, class Data> struct result<This(Expr, State, Data)> { typedef ... type; }; template<class Expr, class State, class Data> typename result<void(Expr, State, Data)>::type operator()(Expr const &expr, State const &state, Data &data) const { return ...; } }; You would now write this as: struct MyTransform : proto::transform<MyTransform> { template<class Expr, class State, class Data> struct impl : proto::transform_impl<Expr, State, Data> { typedef ... result_type; result_type operator()( typename impl::expr_param expr , typename impl::state_param state , typename impl::data_param data ) const { return ...; } }; }; With proto v4, the Expr, State, and Data parameters may be reference types. With v3 they could not. Along with the change to the transform protocol comes the ability to leave off the state and data parameters when invoking a transform. With v3, you had to pass dummy state and data parameters, even if your transform didn't need them. In a related change, when using result_of to calculate the return type of a transform, you need to think about the constness and lvalue-ness of the arguments you pass. So instead of: result_of<MyTransform(E, S, V)>::type you might have to say result_of<MyTransform(E const &, S const &, V &)>::type Finally, the behavior of result_of::child_c (formerly known as result_of::arg_c) has changed. It is now sensitive to const and reference. Old ------------------------------------------ 1) result_of::arg_c<Expr, N>::type 2) result_of::arg_c<Expr, N>::reference 3) result_of::arg_c<Expr, N>::const_reference New ------------------------------------------ 1) result_of::child_c<Expr, N>::type 2) result_of::child_c<Expr &, N>::type 3) result_of::child_c<Expr const &, N>::type These are some internal changes that probably should affect anybody: * ref_ is no more. Children are held by plain reference, not by reference wrapper. * s/args0/term, s/argsN/listN/ That's it, I think. The result is a *much* more expressive, powerful and optimal system of transforms. -- Eric Niebler BoostPro Computing http://www.boostpro.com