|  | Home | Libraries | People | FAQ | More | 
boost::proto::reverse_fold_tree — A PrimitiveTransform that recursively applies the 
          proto::reverse_fold<> transform to
          sub-trees that all share a common tag type.
// In header: <boost/proto/transform/fold_tree.hpp> template<typename Sequence, typename State0, typename Fun> struct reverse_fold_tree : proto::transform< reverse_fold_tree<Sequence, State0, Fun> > { // member classes/structs/unions template<typename Expr, typename State, typename Data> struct impl : proto::reverse_fold<Sequence, State0, recurse_if_<typename Expr::proto_tag, Fun> > ::template impl<Expr, State, Data> { }; };
            proto::reverse_fold_tree<> is useful for flattening trees
            into lists; for example, you might use proto::reverse_fold_tree<>
            to flatten an expression tree like a | b | c into a Fusion list like
            cons(a, cons(b, cons(c))).
          
            proto::reverse_fold_tree<> is easily understood in terms of
            a recurse_if_<> helper, defined as follows:
            
template<typename Tag, typename Fun> struct recurse_if_ : proto::if_< // If the current node has type type "Tag" ... boost::is_same<proto::tag_of<proto::_>, Tag>(), // ... recurse, otherwise ... proto::reverse_fold<proto::_, proto::_state, recurse_if_<Tag, Fun> >, // ... apply the Fun transform. Fun > {};
            With recurse_if_<> as defined above,
            proto::reverse_fold_tree<Sequence, State0, Fun>()(expr, state, data)
            is equivalent to:
            
proto::reverse_fold< Sequence, State0, recurse_if_<typename Expr::proto_tag, Fun> >()(expr, state, data).
It has the effect of folding a tree back-to-front, recursing into child nodes that share a tag type with the parent node.