C++ function accepting any callable of a given templated signature - c++

Question

If I understand it correctly, the standard way to write a function that accepts any callable as a parameter is:
template<typename Fn> void myFunction(Fn&& f) { ... }
I would like to do something similar, except I want to be able make Fn conform to a certain signature and I need to know the type of its parameter. For instance, something like:
template<typename T> void myFunction(std::function<void (T)>&& f) { ... }
The problem is this can't accept packaged_task or lambdas that capture move-only types like std::promise.
Update: Added an sample use case
Consider a simplified network request function:
template<typename T> void get(const Url& url,
const UrlQuery& params,
std::function<void (T)>&& callback) {
auto response = doGet(url, query);
callback(fromJson<T>(response));
}
This works reasonably well most of the time, but when I try to pass it a lambda that captures a std::promise it fails. I could use some workarounds to make that work, but I'm wondering if there is a more elegant way. Something closer to this pseudo code:
template<typename Fn<T>>
void get(const Url& url,
const UrlQuery& params,
Fn<T>&& callback) {
auto response = doGet(url, query);
callback(fromJson<T>(response));
}
Obviously that doesn't compile, but it sort of shows what I'd like.
To se the T parameter in the body of get while also keeping the Fn&& style parameter (eg. not specifying std::function or std::packaged_task as the type for callback) and also not needing to jump through any hoops when calling get.

Answer 1

The following, addressing the non-copyable-lambda part, works with MinGW g++ 7.2 and Visual C++ 2017:
#include <functional> // std::function
#include <memory> // std::shared_ptr
#include <utility> // std::move
template< class Type >
void foo( std::function<void (Type)>&& f )
{
f( 42 );
}
struct No_copy
{
No_copy( No_copy const& ) = delete;
auto operator=( No_copy const& ) -> No_copy& = delete;
No_copy() {}
No_copy( No_copy&& ) {}
auto operator=( No_copy&& ) -> No_copy& { return *this; }
};
template< class Type >
class Copyable
{
std::shared_ptr<Type> pf_;
public:
template< class... Args >
auto operator()( Args&&... args )
{ return (*pf_)( std::forward<Args>( args )... ); }
Copyable( Type&& o )
: pf_{ std::make_shared<Type>( std::move( o ) ) }
{}
};
// Necessary for Visual C++ 2017:
template< class Type >
auto copyable( Type&& o ) { return Copyable<Type>{ std::move( o ) }; }
#include <iostream>
using namespace std;
auto main()
-> int
{
No_copy o;
#ifdef DETAILED
auto lambda = [oh{move(o)}]( int x ){ cout << x << " " << &oh << endl; };
auto const c = copyable( move( lambda ) );
foo<int>( c );
#else
foo<int>( copyable( [oh{move(o)}]( int x ){ cout << x << " " << &oh << endl; } ) );
#endif
}
I haven't tried the particular types you mention, though.
Also, this code does not address the issue of deducing the argument type, if you want that (you'll have to add such deduction, if desired).
And, uhm, there's the issue of possible reference return type, not addressed here either.
:)