Writing C++11 LINQ-style Select - c++

Question

I'm trying to write LINQ-style methods for my base class Iterator, which List and Sequence will inherit from, but those two containers will have their own implementations of these methods. The "Where" method was pretty straight forward. The "Select" method is very tricky; you can't have virtual template methods.
template <typename T>
class Iterator {
public:
virtual ~Iterator() {};
// This is illegal, but if it weren't, it would be the functionality I want.
template <typename R>
virtual shared_ptr<IIterator<R>> Select(const function<R(T)>& func) = 0;
virtual shared_ptr<IIterator<T>> Where(const function<bool(T)>& func) = 0;
};
"Select" will allow you to transform a Iterator of type "ham sandwich" to a Iterator of type "lettuce" for example.
HamSandwiches->Select<'Lettuce'>([] (shared_ptr<'HamSandwich'> hs) { return hs->Lettuce; });
Ignore the single quotes.
Since we can't have virtual template functions, I would have to, of course, not make the function virtual. In that case, we have a plain old function, which we should never "hide" its implementation by writing implementations in List and Sequence compared to a virtual function; it would be considered a design flaw.
template <typename T>
class Iterator {
public:
virtual ~Iterator() {};
template <typename R>
shared_ptr<Iterator<R>> Select(const function<R(T)>& func);
virtual shared_ptr<Iterator<T>> Where(const function<bool(T)>& func) = 0;
};
template <typename T>
template <typename R>
shared_ptr<Iterator<R>> Iterator<T>::Select(const function<R(T)>& func) {
//Implementation - What would it be?
}
Now we have to have implementation in our base class, which this implementation needs to be somewhat specific for List and Sequence. From what I've seen, you would start to create protected "implementation functions" to do certain actions within the "Select" that could be overriden by List or Sequence.
I'm not looking for an exact answer here, I'm looking for something that would help me get where I may/should want to be. Does anyone spot any common gotchas or things I may be doing wrong to begin with?

Answer 1

Option 1
The ideas I have seen for implementing LINQ in C++ were not relying on virtual methods at all. Instead each result was returned wrapped in a template class, approximately like this:
template <class T>
class RangeWrapper
{
public:
template <class U>
Select(U u) -> decltype(...) {
return RangeWrapper<SelectRange, U>(_myRange, u);
}
private:
T& _myRange;
};
If you chain a few of those, the return type may become quite big, but that's the price to pay to get everything done at compile time.
Option 2
You could implement type erasure to always return an iterator of type Iterator<T>. This should be pretty easy to achieve using a type erased iterator library on the web (there are many, you could have a look at boost.TypeErasure which is accepted but not yet released).
Alternatively you could use any_range in boost, if you're OK to work with ranges (they map to LINQ more naturely than iterators).
Option 3
If you are not doing this as a training exercise, there are several solutions that are already implemented. Use google. Notably, Microsoft itself is working on a C++ Linq to implement the reactive extensions on top of it.