Given the following minimal example:
#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <set>
#include <vector>
template<typename ContainerOut, typename X, typename Y, typename ContainerIn>
ContainerOut Map( const ContainerIn& xs, const std::function<Y( const X& )>& f )
{
ContainerOut ys;
std::transform( begin( xs ), end( xs ), std::inserter( ys, end( ys ) ), f );
return ys;
}
struct Foo {
Foo( int val ) : val_( val ) {}
int val_;
};
std::set<int> FooValsToIntSet( const std::list<Foo>& foos )
{
//Map<std::set<int>, Foo, int>
return Map( foos, []( const Foo& foo )
{
return foo.val_;
} );
}
int main()
{
std::list<Foo> foos = { 1, 2, 2, 3 };
std::set<int> vals = FooValsToIntSet( foos );
for ( auto& v : vals )
std::cout << v << std::endl;
}
The line
return Map( foos, []( const Foo& foo )
is not accepted by the compilers I tested.
It works if I write out the template arguments explicitly instead:
return Map<std::set<int>, Foo, int>( foos, []( const Foo& foo )
But I do not understand why this is necessary. Is there a way to avoid this verbosity?
Well, the compiler has no way of deducing the ContainerOut type - the return type doesn't participate in type deduction. However, you could let the compiler deduce everything except the return type. Just as a side note, at least in this case, there is no reason to use std::function - it's just adding unnecessary overhead.
This would be better:
template<typename ContainerOut, typename ContainerIn, typename F>
ContainerOut Map( const ContainerIn& xs, F&& f )
{
ContainerOut ys;
std::transform( begin( xs ), end( xs ), std::inserter( ys, end( ys ) ), f );
return ys;
}
and then you can call it as
return Map<std::set<int>>( foos, []( const Foo& foo )
{
return foo.val_;
} );
Collected from the Internet
Please contact [email protected] to delete if infringement.
Comments