Scott Meyers wrote:

It will take me a few days to digest your comments

Hopefully not because they're confusing :-). I tried to increase conciseness with my second post.

(this is largely new territory for me), but I wanted to acknowledge your help now. Thanks very much.

Thanks too -- a reader who's new to the territory is most valuable to improve one's communication skills.

...

The problem comes down to that MPL can't know where one placeholder expression starts and where another one ends (denoted by uppercase identifiers, above):

Yes, I ran into this problem playing around as a result of the help posted earlier. As I said, it will take me a while to get a grasp on what you've done. I have to look a lot of stuff up and write a lot of test cases :-)

There's a slightly altered approach to this problem attached to this message for some additional fun. Regards, Tobias #include #include #include #include #include #include #include #include #include #include namespace mpl = boost::mpl; using namespace mpl::placeholders; using boost::is_same; // contains_if template struct contains_if : mpl::not_< boost::is_same::type, typename mpl::end<Seq>::type> > { }; // test it typedef mpl::vector<int> v1; BOOST_MPL_ASSERT(( contains_if > )); BOOST_MPL_ASSERT_NOT(( contains_if > )); // contains implemented on top of it // // other than mpl::contains this version takes a binary predicate to parametrize // comparison template > struct contains // uses 'lambda', because 'bind' requires a Metafunction Class instead of an // arbitrary Lambda Expressions : contains_if< S, mpl::bind > { }; // test it BOOST_MPL_ASSERT(( ::contains )); BOOST_MPL_ASSERT_NOT(( ::contains )); // a facility that allows to sustain the evaluation of placeholder expressions template<typename PlaceholderExpr> struct defer { template<typename IgnoredPlaceholder> struct get { typedef PlaceholderExpr type; }; // return a dummy placeholder expression that evaluates to the // original one (without substitution applied) typedef typename defer<PlaceholderExpr>::template get<_> type; }; // test it BOOST_MPL_ASSERT(( is_same::type ,int>::type, _1> )); BOOST_MPL_ASSERT(( is_same::type, int>::type,int>::type, int> )); // now implement includes on top of template > struct includes : mpl::not_< contains_if< SubSeq, mpl::not_< contains > > > { }; // test it typedef mpl::vector<int> v1; typedef mpl::vector v2; BOOST_MPL_ASSERT(( includes )); BOOST_MPL_ASSERT_NOT(( includes ));

Hi Ovanes, Ovanes Markarian wrote:

Tobias,

I looked in your code and have an additional question. Compiletime complexity of the algorithm is exponential as I see it.

Not quite - it's just quadratic in the worst case (I believe it's just about the wording: Although there's a constant exponent in O(N^2), "exponential complexity" is something with N being a factor of the exponent e.g. O(2^N)).

Isn't it probably better to convert the first vector into a set and make set lookups with amortized constant time?

Seems it's only possible to implement the "Pred = is_same<_1,_2> case", this way - not the "Pred = is_base_of<_1,_2> case" asked for by the OP. That issue aside, it seems an interesting idea. If you decide to give it a try I'd be interested to see your benchmarks! Regards, Tobias

David Abrahams wrote:

on Sat Mar 17 2007, Tobias Schwinger wrote:

...

The problem comes down to that MPL can't know where one placeholder expression starts and where another one ends (denoted by uppercase identifiers, above):

There is an inherent limitation in that regard. These kinds of problems come up repeatedly, so Aleksey and I agree the library should provide a solution. We had a long discussion on the boost-devel list where we talked about the same issues in terms of runtime lambda expressions:

http://lists.boost.org/Archives/boost/2005/01/78409.php

Oh, thanks! Incidentally, I provided something very similar to 'outer' (discussed in that thread) in the follow-up, called 'defer' (inspired by Chaos). It's so easy, that it's almost provocative: // returns an unspecified placeholder expression whose evaluation // results in the original argument, no placeholder substitution // applied template<typename PlaceholderExpr> struct defer { template<typename IgnoredPlaceholder> struct get { typedef PlaceholderExpr type; }; typedef typename defer<PlaceholderExpr>::template get<_> type; }; BOOST_MPL_ASSERT(( is_same::type ,int>::type, _1> )); Of course it still needs "typename...type-clutter" in template context, otherwise the lambda facility would have to be aware of its existence. outer<_1> == typename defer<_1>::type

As I said, this thread is long (it contains a whole thread attached to one message in the outer thread -- how appropriate!) but it's worth a read.

Incidentally, protect<> doesn't help as it does something different.

Yes, namely nested binds - I figured that out, by now :-). Regards, Tobias