std::packaged_task mit Move-only-Typen

Hallo,

ich habe mit einem aktuellen gcc4.7 -Snapshot das Problem, dass std::packaged_task keine Move-Only-Typen akzeptiert. Ist das ein Bug oder ein "works as designed"?
Im Standard und Netz konnte ich jetzt keine eindeutige, passende Antwort finden.

Danke.

#include <future>
#include <iostream> 
#include <thread> 

struct Foo
{
 Foo()=default;
 Foo(Foo&&)=default;
 Foo& operator=(Foo &&)=default;
 void operator() () { std::cout << "Foo called\n";}
};

int main()
{

 std::thread t{Foo()};  //klappt
 t.join();
 auto fut =std::async(Foo()); //klappt
 fut.wait();
 std::packaged_task<void()> task{Foo()}; //geht nicht
 task();
 return 0;
}

camper

Das scheint mir ein Bug im Standard zu sein. In den ursprünglichen Vorschlägen wurde immer eine Kopie des Funktionsobjektes gespeichert, das ist erst relativ spät geändert worden. Dabei scheint aber zumindest

30.6.9.1 packaged_task member functions [futures.task.members]
packaged_task() noexcept;
1 Effects: constructs a packaged_task object with no shared state and no stored task.
template <class F>
packaged_task(F&& f);
template <class F, class Allocator>
explicit packaged_task(allocator_arg_t, const Allocator& a, F&& f);
2 Requires: INVOKE(f, t1, t2, ..., tN, R), where t1, t2, ..., tN are values of the corresponding types in ArgTypes..., shall be a valid expression. Invoking a copy of f shall behave the same as invoking f.

übersehen worden zu sein. Jedenfalls liest sich das, als ob f CopyConstructible sein müsste, obwohl dafür ansonsten keine Notwendigkeit zu bestehen scheint.

Danke camper.
Muss sich sich dann der Bibliothek-Programmierer strikt an den Standard halten oder kann er auch offensichtliche Bugs im Standard (wenn es denn wirklich einer ist) in der Implementierung geradebiegen?
In jedem Fall muss ich mir für den Augenblick eigene "packaged_task"-Klasse schreiben, welche mir die promise-future-Konstruktion kapselt und auch für Move-Only Typen gilt.