#include <algorithm>
#include <iostream>
#include <type_traits>
#include <vector>
using namespace std;
 
// The forward_as template
template<typename T, typename U>
auto forward_as( U&& u ) -> typename std::conditional<
        std::is_reference<T>::value, 
        typename std::remove_reference<U>::type&, 
        typename std::remove_reference<U>::type&&>::type
{
    return static_cast<decltype(forward_as<T, U>(u))>(u);
}
 
// Structs for testing
struct  X {};
struct Y {
	vector<X> range;
	Y() : range(1) {}
};
 
// bar will tell us the actual reference type of the forwarding reference
struct Bar {
    void operator()(X&& t) { cout << "t is a r-value reference\n"; }
    void operator()(X& t) { cout << "t is an l-value reference\n"; }
    void operator()(const X& t) { cout << "t is passed by const reference\n"; }
} bar;
 
// Elementwise perfect forwarding of a member range
template<typename T>
void foo( T&& t ) {
	for (auto& r : t.range)
		bar(forward_as<T>(r));
}
 
// Elementwise perfect forwarding of a member range
template<typename T>
void algo_foo( T&& t ) {
	std::for_each(std::begin(std::forward<T>(t).range), std::end(std::forward<T>(t).range), bar);
}
 
// Naive and non-working attempt
template<typename T>
void naive_foo( T&& t ) {
	for (auto&& r : forward<T>(t).range)
		bar(r);
}
 
int main() {
	// Pass by r-value reference.
	cout << "foo(Y()):\n\t";
	foo(Y());
	cout << "naive_foo(Y()):\n\t";
	naive_foo(Y());
	cout << "algo_foo(Y()):\n\t";
	algo_foo(Y());
 
	// Pass by l-value reference.
	Y y;
	cout << "foo(y):\n\t";
	foo(y);
	cout << "naive_foo(y):\n\t";
	naive_foo(y);
	cout << "algo_foo(y):\n\t";
	algo_foo(y);
}

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