David Hall wrote:
> Tzu-Chien Chiu wrote:
> 
>> Any boost library can make me write the expression like
>>
>>  int x = 3;
>>  if ( x in list(3, 5, 6, 7) ) {
>>   ...
>>  }
>>
>>  
>>
> I don't know about the boost libraries, but I quickly sketched out 
> something you might be interested in, based on something I saw on one of 
> the news groups. All you have to do is to write a binary predicate 
> functor with bool operator()(int,). It's 
> untested, but a quick syntax check with g++ 3.4.2 works fine.
> 
> Usage will be
> if (x  list(3,5,6,7) ) { ... }
> 
> I hope that's more or less what you're after; I don't know if you want 
> that list type/function as well.
> 
> The code itself is attached. Be sure to fix the template parameter in 
> the unnamed namespace..
> 
> David Hall
> 
> 
> ------------------------------------------------------------------------
> 
> _______________________________________________
> Boost-users mailing list
> Boost-users@lists.boost.org
> http://lists.boost.org/mailman/listinfo.cgi/boost-users
Huh.. I never thought to overload them that way, I like it!
Some small issues with the implementation:
* in operator_t: your ctor init is... dodgy at best. Rename the 
parameter _f or something (ie: operator_t(F _f = F()) : f(_f) {})
* Cleaner layout! indent evenly, return types and init lists on their 
own lines, not seperating & from types, spaces after comma's in 
parameter lists, etc... Makes comprehension easier, for you _and_ your 
readers.
* related note: more meaningful template parameter names: BinFn instead 
of F, ValueT instead of T, etc...
* It should be designed as an expression template library, 'in' is 
something that operator< can recognise as an infix op, and generate some 
  binder functional that when it sees an operator> can call the op on 
the values to its left (stored) and right. I'd have to take a look at 
what some of the expression template functions do to come up with an 
implementation. This way  works for everything, and, if you are 
careful, you could generalise to pretty much operator that you want, and 
the same operator< template function can create the right thing. I'll 
play around with it over the weekend and see what I can come up with.
Boost.Infix?

Simon Buchan wrote:

Played around a bit, try this. It only defines is_in (which wraps 'std::find(rhs.begin(), rhs.end(), lhs) != rhs.end()' ), but should be easily generalisable to any operation, say: if(x vec) {while(int i vec) cout << i;} (I don't know if you could do the last one, or what syntax would be better suited, but you get the idea)

Anything like "while(int i vec) cout << i;" isn't all that feasible (without being really hackish), since you need to maintain some sort of state inside of something that lives beyond each while statement, but specifically not in for_all_in, since we want to be able to iterate over the same container twice. The best I can come up with is this: (This could be prettified if we had auto, with the added bonus of allowing for autoselection of const versus non-const iterators.) for_all_in_iterator i; while( i vec) std::cout << *i << std::endl; where for_all_in_iterator is essentially a specialized form of boost::optional<>. I don't think you can get around using an iterator, unless you're willing to sacrifice either for_all_in's reentry or status as pseudo-keyword. Either way, I added my code in, with a few edits to yours, to allow for non-const RhsT. Ideally, there'd be a for_all_in_const_iterator version, but that's pretty easy. David Hall #include <vector> #include <algorithm> #include <iostream> #include <cassert> namespace boost { namespace infix { namespace detail { template struct binder { explicit binder(LhsT& _lhs) : lhs(_lhs) {} template <typename RhsT> typename Operator::template sig::type operator > (RhsT& rhs) { return Operator::apply(lhs, rhs); } template <typename RhsT> typename Operator::template sig::type operator > (const RhsT& rhs) { return Operator::apply(lhs, rhs); } // SFINAE version of the above using ::result_type // ... private: LhsT& lhs; }; // lots of other things } struct is_in_operator { template static bool apply(const ValueT& val, const Cont& cont) { return std::find ( cont.begin() , cont.end() , val ) != cont.end(); } template struct sig { typedef bool type; }; } is_in; // Ugly version of the adapter pattern, perhaps too similar to boost::optional // A state of valid implies that for_all_in has been applied to this iterator at least once. template <class Cont> class for_all_in_iterator { typedef typename Cont::iterator real_iter_t; typedef typename Cont::value_type value_type; public: for_all_in_iterator():valid(false) {} for_all_in_iterator(const for_all_in_iterator & rhs) : valid(rhs.valid), iter(rhs.iter) {} for_all_in_iterator(const real_iter_t & rhs) : valid(false), iter(rhs) {} for_all_in_iterator & operator=(const real_iter_t & rhs) { iter = rhs; return *this; } real_iter_t & operator->() { return iter; } const real_iter_t & operator->() const { return iter; } value_type & operator*() { return *iter; } const value_type & operator*() const { return *iter; } for_all_in_iterator & operator++() { ++iter; return *this; } for_all_in_iterator operator++(int) { for_all_in_iterator tmp(*this); operator++(); return tmp; } bool operator==(const for_all_in_iterator & rhs) const { return iter == rhs.iter; } bool operator!=(const for_all_in_iterator & rhs) const { return iter != rhs.iter; } bool operator<(const for_all_in_iterator & rhs) const { return iter < rhs.iter; } bool operator>(const for_all_in_iterator & rhs) const { return iter > rhs.iter; } bool operator<=(const for_all_in_iterator & rhs) const { return iter <= rhs.iter; } bool operator>=(const for_all_in_iterator & rhs) const { return iter >= rhs.iter; } // Let's not be picky here. template <class OtherIter> bool operator==(const OtherIter & rhs) const { return iter == rhs; } template <class OtherIter> bool operator!=(const OtherIter & rhs) const { return iter != rhs; } template <class OtherIter> bool operator<(const OtherIter & rhs) const { return iter < rhs; } template <class OtherIter> bool operator>(const OtherIter & rhs) const { return iter > rhs; } template <class OtherIter> bool operator<=(const OtherIter & rhs) const { return iter <= rhs; } template <class OtherIter> bool operator>=(const OtherIter & rhs) const { return iter >= rhs; } private: bool valid; real_iter_t iter; friend class for_all_in_operator; }; struct for_all_in_operator { template <typename Cont> static bool apply (for_all_in_iterator<Cont> & iter, Cont& cont) { if(!iter.valid) { iter.iter = cont.begin(); iter.valid = true; return true; } if(iter.iter == cont.end()) return false; return ++iter != cont.end(); } template struct sig { typedef bool type; }; } for_all_in; // Lots of other infix operators template detail::binder operator < (LhsT& lhs, Operator rhs) { return detail::binder(lhs); } }} int main() { using namespace boost::infix; std::vector<int> vec; int val = 6; vec.push_back(4); vec.push_back(7); vec.push_back(6); assert(val vec); // The following could be a lot prettier with auto, oh well. for_all_in_iterator i; while( i vec) std::cout << *i << std::endl; }