You are viewing a plain text version of this content. The canonical link for it is here.

Posted to dev@mesos.apache.org by Dominic Hamon <dh...@twopensource.com> on 2014/03/25 19:29:28 UTC

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/
-----------------------------------------------------------

(Updated March 25, 2014, 11:29 a.m.)


Review request for mesos and Ben Mahler.


Changes
-------

rebased


Summary (updated)
-----------------

Ported libprocess system/stats.json endpoint to new metrics library.


Repository: mesos-git


Description
-------

see summary


Diffs (updated)
-----

  3rdparty/libprocess/include/process/metrics/metric.hpp PRE-CREATION 
  3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 

Diff: https://reviews.apache.org/r/19545/diff/


Testing
-------

make check and manually checked /system/stats.json against /metrics


Thanks,

Dominic Hamon

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Mesos ReviewBot <de...@mesos.apache.org>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/#review38661
-----------------------------------------------------------


Bad patch!

Reviews applied: [18718, 19545]

Failed command: make -j3 check GTEST_FILTER='' >/dev/null

Error:
 ev.c:1531:31: warning: 'ev_default_loop_ptr' initialized and declared 'extern' [enabled by default]
ev.c: In function 'evpipe_write':
ev.c:2160:17: warning: ignoring return value of 'write', declared with attribute warn_unused_result [-Wunused-result]
ev.c:2172:17: warning: ignoring return value of 'write', declared with attribute warn_unused_result [-Wunused-result]
ev.c: In function 'pipecb':
ev.c:2193:16: warning: ignoring return value of 'read', declared with attribute warn_unused_result [-Wunused-result]
ev.c:2207:16: warning: ignoring return value of 'read', declared with attribute warn_unused_result [-Wunused-result]
In file included from /usr/include/c++/4.6/ext/hash_set:61:0,
                 from src/glog/stl_logging.h:54,
                 from src/stl_logging_unittest.cc:34:
/usr/include/c++/4.6/backward/backward_warning.h:33:2: warning: #warning This file includes at least one deprecated or antiquated header which may be removed without further notice at a future date. Please use a non-deprecated interface with equivalent functionality instead. For a listing of replacement headers and interfaces, consult the file backward_warning.h. To disable this warning use -Wno-deprecated. [-Wcpp]
In file included from src/utilities.h:73:0,
                 from src/googletest.h:38,
                 from src/stl_logging_unittest.cc:48:
src/base/mutex.h:137:0: warning: "_XOPEN_SOURCE" redefined [enabled by default]
/usr/include/features.h:166:0: note: this is the location of the previous definition
In file included from src/process.cpp:63:0:
./include/process/system.hpp: In constructor 'process::System::System()':
./include/process/system.hpp:24:76: error: no matching function for call to 'defer(process::PID<process::System>, double (*)())'
./include/process/system.hpp:24:76: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:25:76: error: no matching function for call to 'defer(process::PID<process::System>, double (*)())'
./include/process/system.hpp:25:76: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:28:50: error: no matching function for call to 'defer(process::PID<process::System>, double (*)())'
./include/process/system.hpp:28:50: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:29:75: error: no matching function for call to 'defer(process::PID<process::System>, double (*)())'
./include/process/system.hpp:29:75: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:32:58: error: no matching function for call to 'defer(process::PID<process::System>, double (*)())'
./include/process/system.hpp:32:58: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:35:56: error: no matching function for call to 'defer(process::PID<process::System>, double (*)())'
./include/process/system.hpp:35:56: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
make[4]: *** [libprocess_la-process.lo] Error 1
make[4]: *** Waiting for unfinished jobs....
make[3]: *** [check-recursive] Error 1
make[2]: *** [check-recursive] Error 1
make[1]: *** [check] Error 2
make: *** [check-recursive] Error 1


- Mesos ReviewBot


On March 26, 2014, 7:43 p.m., Dominic Hamon wrote:
> 
> -----------------------------------------------------------
> This is an automatically generated e-mail. To reply, visit:
> https://reviews.apache.org/r/19545/
> -----------------------------------------------------------
> 
> (Updated March 26, 2014, 7:43 p.m.)
> 
> 
> Review request for mesos and Ben Mahler.
> 
> 
> Bugs: MESOS-1146
>     https://issues.apache.org/jira/browse/MESOS-1146
> 
> 
> Repository: mesos-git
> 
> 
> Description
> -------
> 
> see summary
> 
> 
> Diffs
> -----
> 
>   3rdparty/libprocess/include/process/metrics/metric.hpp PRE-CREATION 
>   3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 
> 
> Diff: https://reviews.apache.org/r/19545/diff/
> 
> 
> Testing
> -------
> 
> make check and manually checked /system/stats.json against /metrics
> 
> 
> Thanks,
> 
> Dominic Hamon
> 
>

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Mesos ReviewBot <de...@mesos.apache.org>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/#review40129
-----------------------------------------------------------


Bad patch!

Reviews applied: [19545]

Failed command: make -j3 check GTEST_FILTER='' >/dev/null

Error:
 ev.c:1531:31: warning: 'ev_default_loop_ptr' initialized and declared 'extern' [enabled by default]
ev.c: In function 'evpipe_write':
ev.c:2160:17: warning: ignoring return value of 'write', declared with attribute warn_unused_result [-Wunused-result]
ev.c:2172:17: warning: ignoring return value of 'write', declared with attribute warn_unused_result [-Wunused-result]
ev.c: In function 'pipecb':
ev.c:2193:16: warning: ignoring return value of 'read', declared with attribute warn_unused_result [-Wunused-result]
ev.c:2207:16: warning: ignoring return value of 'read', declared with attribute warn_unused_result [-Wunused-result]
In file included from /usr/include/c++/4.6/ext/hash_set:61:0,
                 from src/glog/stl_logging.h:54,
                 from src/stl_logging_unittest.cc:34:
/usr/include/c++/4.6/backward/backward_warning.h:33:2: warning: #warning This file includes at least one deprecated or antiquated header which may be removed without further notice at a future date. Please use a non-deprecated interface with equivalent functionality instead. For a listing of replacement headers and interfaces, consult the file backward_warning.h. To disable this warning use -Wno-deprecated. [-Wcpp]
In file included from src/utilities.h:73:0,
                 from src/googletest.h:38,
                 from src/stl_logging_unittest.cc:48:
src/base/mutex.h:137:0: warning: "_XOPEN_SOURCE" redefined [enabled by default]
/usr/include/features.h:166:0: note: this is the location of the previous definition
In file included from src/process.cpp:63:0:
./include/process/system.hpp: In constructor 'process::System::System()':
./include/process/system.hpp:25:78: error: no matching function for call to 'defer(process::PID<process::System>, process::Future<double> (*)())'
./include/process/system.hpp:25:78: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:26:78: error: no matching function for call to 'defer(process::PID<process::System>, process::Future<double> (*)())'
./include/process/system.hpp:26:78: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:28:50: error: no matching function for call to 'defer(process::PID<process::System>, process::Future<double> (*)())'
./include/process/system.hpp:28:50: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:29:77: error: no matching function for call to 'defer(process::PID<process::System>, process::Future<double> (*)())'
./include/process/system.hpp:29:77: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:31:58: error: no matching function for call to 'defer(process::PID<process::System>, process::Future<double> (*)())'
./include/process/system.hpp:31:58: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:33:56: error: no matching function for call to 'defer(process::PID<process::System>, process::Future<double> (*)())'
./include/process/system.hpp:33:56: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
make[4]: *** [libprocess_la-process.lo] Error 1
make[4]: *** Waiting for unfinished jobs....
make[3]: *** [check-recursive] Error 1
make[2]: *** [check-recursive] Error 1
make[1]: *** [check] Error 2
make: *** [check-recursive] Error 1


- Mesos ReviewBot


On April 11, 2014, 3:48 a.m., Dominic Hamon wrote:
> 
> -----------------------------------------------------------
> This is an automatically generated e-mail. To reply, visit:
> https://reviews.apache.org/r/19545/
> -----------------------------------------------------------
> 
> (Updated April 11, 2014, 3:48 a.m.)
> 
> 
> Review request for mesos and Ben Mahler.
> 
> 
> Bugs: MESOS-1146
>     https://issues.apache.org/jira/browse/MESOS-1146
> 
> 
> Repository: mesos-git
> 
> 
> Description
> -------
> 
> see summary
> 
> 
> Diffs
> -----
> 
>   3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 
> 
> Diff: https://reviews.apache.org/r/19545/diff/
> 
> 
> Testing
> -------
> 
> make check and manually checked /system/stats.json against /metrics
> 
> 
> Thanks,
> 
> Dominic Hamon
> 
>

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Mesos ReviewBot <de...@mesos.apache.org>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/#review42147
-----------------------------------------------------------


Patch looks great!

Reviews applied: [19545]

All tests passed.

- Mesos ReviewBot


On May 2, 2014, 7:15 p.m., Dominic Hamon wrote:
> 
> -----------------------------------------------------------
> This is an automatically generated e-mail. To reply, visit:
> https://reviews.apache.org/r/19545/
> -----------------------------------------------------------
> 
> (Updated May 2, 2014, 7:15 p.m.)
> 
> 
> Review request for mesos and Ben Mahler.
> 
> 
> Bugs: MESOS-1146
>     https://issues.apache.org/jira/browse/MESOS-1146
> 
> 
> Repository: mesos-git
> 
> 
> Description
> -------
> 
> see summary
> 
> 
> Diffs
> -----
> 
>   3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 
>   3rdparty/libprocess/src/tests/metrics_tests.cpp 75f1f0e35fdb1ec707785d1ebb903af99551bdaa 
> 
> Diff: https://reviews.apache.org/r/19545/diff/
> 
> 
> Testing
> -------
> 
> make check and manually checked /system/stats.json against /metrics
> 
> 
> Thanks,
> 
> Dominic Hamon
> 
>

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Dominic Hamon <dh...@twopensource.com>.


> On May 27, 2014, 10:38 a.m., Vinod Kone wrote:
> > 3rdparty/libprocess/include/process/system.hpp, lines 81-85
> > <https://reviews.apache.org/r/19545/diff/13/?file=588085#file588085line81>
> >
> >     I know you just moved this, but the "avg_" prefix seems wrong? the metrics names don't have that prefix. also, there is no mention of mem_total_bytes and mem_free_bytes?

nice catch - i didn't even notice.


> On May 27, 2014, 10:38 a.m., Vinod Kone wrote:
> > 3rdparty/libprocess/src/tests/system_tests.cpp, lines 32-56
> > <https://reviews.apache.org/r/19545/diff/13/?file=588087#file588087line32>
> >
> >     the "tests/system_tests.cpp" seems a bit misleading. just add this test to the metrics_tests file as this is just the default metrics process behavior.

I added this because the MetricsInStatsEndpoint tests are in master_tests and slave_tests. This isn't testing the metrics process, it's testing that the API of the system process metrics hasn't changed. As such, it should probably be in a system_tests file.


- Dominic


-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/#review43993
-----------------------------------------------------------


On May 27, 2014, 10:49 a.m., Dominic Hamon wrote:
> 
> -----------------------------------------------------------
> This is an automatically generated e-mail. To reply, visit:
> https://reviews.apache.org/r/19545/
> -----------------------------------------------------------
> 
> (Updated May 27, 2014, 10:49 a.m.)
> 
> 
> Review request for mesos and Ben Mahler.
> 
> 
> Bugs: MESOS-1146
>     https://issues.apache.org/jira/browse/MESOS-1146
> 
> 
> Repository: mesos-git
> 
> 
> Description
> -------
> 
> see summary
> 
> 
> Diffs
> -----
> 
>   3rdparty/libprocess/Makefile.am fa9b4fd0bb2555c3372151f8b86c8a6457319d93 
>   3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 
>   3rdparty/libprocess/src/tests/metrics_tests.cpp 8a131218b858a6571bd520c470eac850a3fd345e 
>   3rdparty/libprocess/src/tests/system_tests.cpp PRE-CREATION 
> 
> Diff: https://reviews.apache.org/r/19545/diff/
> 
> 
> Testing
> -------
> 
> make check and manually checked /system/stats.json against /metrics
> 
> 
> Thanks,
> 
> Dominic Hamon
> 
>

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Vinod Kone <vi...@gmail.com>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/#review43993
-----------------------------------------------------------

Ship it!



3rdparty/libprocess/include/process/system.hpp
<https://reviews.apache.org/r/19545/#comment78234>

    I know you just moved this, but the "avg_" prefix seems wrong? the metrics names don't have that prefix. also, there is no mention of mem_total_bytes and mem_free_bytes?



3rdparty/libprocess/src/tests/system_tests.cpp
<https://reviews.apache.org/r/19545/#comment78238>

    the "tests/system_tests.cpp" seems a bit misleading. just add this test to the metrics_tests file as this is just the default metrics process behavior.


- Vinod Kone


On May 22, 2014, 5:22 p.m., Dominic Hamon wrote:
> 
> -----------------------------------------------------------
> This is an automatically generated e-mail. To reply, visit:
> https://reviews.apache.org/r/19545/
> -----------------------------------------------------------
> 
> (Updated May 22, 2014, 5:22 p.m.)
> 
> 
> Review request for mesos and Ben Mahler.
> 
> 
> Bugs: MESOS-1146
>     https://issues.apache.org/jira/browse/MESOS-1146
> 
> 
> Repository: mesos-git
> 
> 
> Description
> -------
> 
> see summary
> 
> 
> Diffs
> -----
> 
>   3rdparty/libprocess/Makefile.am fa9b4fd0bb2555c3372151f8b86c8a6457319d93 
>   3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 
>   3rdparty/libprocess/src/tests/metrics_tests.cpp 8a131218b858a6571bd520c470eac850a3fd345e 
>   3rdparty/libprocess/src/tests/system_tests.cpp PRE-CREATION 
> 
> Diff: https://reviews.apache.org/r/19545/diff/
> 
> 
> Testing
> -------
> 
> make check and manually checked /system/stats.json against /metrics
> 
> 
> Thanks,
> 
> Dominic Hamon
> 
>

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Ben Mahler <be...@gmail.com>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/#review44154
-----------------------------------------------------------


I see this is already submitted, just noticed a few things we should follow up on below.


3rdparty/libprocess/include/process/system.hpp
<https://reviews.apache.org/r/19545/#comment78476>

    How about including the error messages in these strings?
    
    "Failed to get loadavg: " + load.error()
    
    Also, please don't end these with periods :)



3rdparty/libprocess/src/tests/metrics_tests.cpp
<https://reviews.apache.org/r/19545/#comment78481>

    Was the diff bad here? Why all the changes to this test?



3rdparty/libprocess/src/tests/metrics_tests.cpp
<https://reviews.apache.org/r/19545/#comment78480>

    :( why did we make the test more complicated in this review? Was the JSON equality insufficient? Isn't this unrelated to this change?



3rdparty/libprocess/src/tests/metrics_tests.cpp
<https://reviews.apache.org/r/19545/#comment78478>

    s/std:://



3rdparty/libprocess/src/tests/metrics_tests.cpp
<https://reviews.apache.org/r/19545/#comment78479>

    s/std:://


- Ben Mahler


On May 27, 2014, 5:49 p.m., Dominic Hamon wrote:
> 
> -----------------------------------------------------------
> This is an automatically generated e-mail. To reply, visit:
> https://reviews.apache.org/r/19545/
> -----------------------------------------------------------
> 
> (Updated May 27, 2014, 5:49 p.m.)
> 
> 
> Review request for mesos and Ben Mahler.
> 
> 
> Bugs: MESOS-1146
>     https://issues.apache.org/jira/browse/MESOS-1146
> 
> 
> Repository: mesos-git
> 
> 
> Description
> -------
> 
> see summary
> 
> 
> Diffs
> -----
> 
>   3rdparty/libprocess/Makefile.am fa9b4fd0bb2555c3372151f8b86c8a6457319d93 
>   3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 
>   3rdparty/libprocess/src/tests/metrics_tests.cpp 8a131218b858a6571bd520c470eac850a3fd345e 
>   3rdparty/libprocess/src/tests/system_tests.cpp PRE-CREATION 
> 
> Diff: https://reviews.apache.org/r/19545/diff/
> 
> 
> Testing
> -------
> 
> make check and manually checked /system/stats.json against /metrics
> 
> 
> Thanks,
> 
> Dominic Hamon
> 
>

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Dominic Hamon <dh...@twopensource.com>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/
-----------------------------------------------------------

(Updated May 27, 2014, 10:49 a.m.)


Review request for mesos and Ben Mahler.


Bugs: MESOS-1146
    https://issues.apache.org/jira/browse/MESOS-1146


Repository: mesos-git


Description
-------

see summary


Diffs (updated)
-----

  3rdparty/libprocess/Makefile.am fa9b4fd0bb2555c3372151f8b86c8a6457319d93 
  3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 
  3rdparty/libprocess/src/tests/metrics_tests.cpp 8a131218b858a6571bd520c470eac850a3fd345e 
  3rdparty/libprocess/src/tests/system_tests.cpp PRE-CREATION 

Diff: https://reviews.apache.org/r/19545/diff/


Testing
-------

make check and manually checked /system/stats.json against /metrics


Thanks,

Dominic Hamon

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Dominic Hamon <dh...@twopensource.com>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/
-----------------------------------------------------------

(Updated May 22, 2014, 10:22 a.m.)


Review request for mesos and Ben Mahler.


Changes
-------

fix bad rebase and added new tests.


Bugs: MESOS-1146
    https://issues.apache.org/jira/browse/MESOS-1146


Repository: mesos-git


Description
-------

see summary


Diffs (updated)
-----

  3rdparty/libprocess/Makefile.am fa9b4fd0bb2555c3372151f8b86c8a6457319d93 
  3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 
  3rdparty/libprocess/src/tests/metrics_tests.cpp 8a131218b858a6571bd520c470eac850a3fd345e 
  3rdparty/libprocess/src/tests/system_tests.cpp PRE-CREATION 

Diff: https://reviews.apache.org/r/19545/diff/


Testing
-------

make check and manually checked /system/stats.json against /metrics


Thanks,

Dominic Hamon

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Vinod Kone <vi...@gmail.com>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/#review43662
-----------------------------------------------------------


Can you also add a test that verifies that system stats end up in metrics endpoint?


3rdparty/libprocess/src/tests/metrics_tests.cpp
<https://reviews.apache.org/r/19545/#comment77951>

    ASSERT_SOME(responseJSON);



3rdparty/libprocess/src/tests/metrics_tests.cpp
<https://reviews.apache.org/r/19545/#comment77952>

    Where is 'responseJSON' declared? How did this even compile!?
    
    


- Vinod Kone


On May 15, 2014, 6:15 p.m., Dominic Hamon wrote:
> 
> -----------------------------------------------------------
> This is an automatically generated e-mail. To reply, visit:
> https://reviews.apache.org/r/19545/
> -----------------------------------------------------------
> 
> (Updated May 15, 2014, 6:15 p.m.)
> 
> 
> Review request for mesos and Ben Mahler.
> 
> 
> Bugs: MESOS-1146
>     https://issues.apache.org/jira/browse/MESOS-1146
> 
> 
> Repository: mesos-git
> 
> 
> Description
> -------
> 
> see summary
> 
> 
> Diffs
> -----
> 
>   3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 
>   3rdparty/libprocess/src/tests/metrics_tests.cpp 8a131218b858a6571bd520c470eac850a3fd345e 
> 
> Diff: https://reviews.apache.org/r/19545/diff/
> 
> 
> Testing
> -------
> 
> make check and manually checked /system/stats.json against /metrics
> 
> 
> Thanks,
> 
> Dominic Hamon
> 
>

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Dominic Hamon <dh...@twopensource.com>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/
-----------------------------------------------------------

(Updated May 15, 2014, 11:15 a.m.)


Review request for mesos and Ben Mahler.


Changes
-------

rebased


Bugs: MESOS-1146
    https://issues.apache.org/jira/browse/MESOS-1146


Repository: mesos-git


Description
-------

see summary


Diffs (updated)
-----

  3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 
  3rdparty/libprocess/src/tests/metrics_tests.cpp 8a131218b858a6571bd520c470eac850a3fd345e 

Diff: https://reviews.apache.org/r/19545/diff/


Testing
-------

make check and manually checked /system/stats.json against /metrics


Thanks,

Dominic Hamon

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Dominic Hamon <dh...@twopensource.com>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/
-----------------------------------------------------------

(Updated May 2, 2014, 12:15 p.m.)


Review request for mesos and Ben Mahler.


Changes
-------

fixed to work for more than just clang
changed metrics tests that check JSON as the libprocess metrics show up there now. as such we can't make assumptions about it being empty at the start of the test.


Bugs: MESOS-1146
    https://issues.apache.org/jira/browse/MESOS-1146


Repository: mesos-git


Description
-------

see summary


Diffs (updated)
-----

  3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 
  3rdparty/libprocess/src/tests/metrics_tests.cpp 75f1f0e35fdb1ec707785d1ebb903af99551bdaa 

Diff: https://reviews.apache.org/r/19545/diff/


Testing
-------

make check and manually checked /system/stats.json against /metrics


Thanks,

Dominic Hamon

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Mesos ReviewBot <de...@mesos.apache.org>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/#review42013
-----------------------------------------------------------


Bad patch!

Reviews applied: [19545]

Failed command: make -j3 distcheck GTEST_FILTER='' >/dev/null

Error:
 configure: WARNING: can not find python-boto
-------------------------------------------------------------------
mesos-ec2 services will not function.
-------------------------------------------------------------------
ev.c:1531:31: warning: 'ev_default_loop_ptr' initialized and declared 'extern' [enabled by default]
ev.c: In function 'evpipe_write':
ev.c:2160:17: warning: ignoring return value of 'write', declared with attribute warn_unused_result [-Wunused-result]
ev.c:2172:17: warning: ignoring return value of 'write', declared with attribute warn_unused_result [-Wunused-result]
ev.c: In function 'pipecb':
ev.c:2193:16: warning: ignoring return value of 'read', declared with attribute warn_unused_result [-Wunused-result]
ev.c:2207:16: warning: ignoring return value of 'read', declared with attribute warn_unused_result [-Wunused-result]
In file included from /usr/include/c++/4.6/ext/hash_set:61:0,
                 from src/glog/stl_logging.h:54,
                 from src/stl_logging_unittest.cc:34:
/usr/include/c++/4.6/backward/backward_warning.h:33:2: warning: #warning This file includes at least one deprecated or antiquated header which may be removed without further notice at a future date. Please use a non-deprecated interface with equivalent functionality instead. For a listing of replacement headers and interfaces, consult the file backward_warning.h. To disable this warning use -Wno-deprecated. [-Wcpp]
In file included from src/utilities.h:73:0,
                 from src/googletest.h:38,
                 from src/stl_logging_unittest.cc:48:
src/base/mutex.h:137:0: warning: "_XOPEN_SOURCE" redefined [enabled by default]
/usr/include/features.h:166:0: note: this is the location of the previous definition
In file included from ../../../3rdparty/libprocess/src/process.cpp:63:0:
../../../3rdparty/libprocess/include/process/system.hpp: In constructor 'process::System::System()':
../../../3rdparty/libprocess/include/process/system.hpp:25:75: error: no matching function for call to 'defer(process::PID<process::System>, process::Future<double> (&)())'
../../../3rdparty/libprocess/include/process/system.hpp:25:75: note: candidates are:
../../../3rdparty/libprocess/include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
../../../3rdparty/libprocess/include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/system.hpp:26:75: error: no matching function for call to 'defer(process::PID<process::System>, process::Future<double> (&)())'
../../../3rdparty/libprocess/include/process/system.hpp:26:75: note: candidates are:
../../../3rdparty/libprocess/include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
../../../3rdparty/libprocess/include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/system.hpp:27:78: error: no matching function for call to 'defer(process::PID<process::System>, process::Future<double> (&)())'
../../../3rdparty/libprocess/include/process/system.hpp:27:78: note: candidates are:
../../../3rdparty/libprocess/include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
../../../3rdparty/libprocess/include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/system.hpp:28:78: error: no matching function for call to 'defer(process::PID<process::System>, process::Future<double> (&)())'
../../../3rdparty/libprocess/include/process/system.hpp:28:78: note: candidates are:
../../../3rdparty/libprocess/include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
../../../3rdparty/libprocess/include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/system.hpp:31:49: error: no matching function for call to 'defer(process::PID<process::System>, process::Future<double> (&)())'
../../../3rdparty/libprocess/include/process/system.hpp:31:49: note: candidates are:
../../../3rdparty/libprocess/include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
../../../3rdparty/libprocess/include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/system.hpp:34:48: error: no matching function for call to 'defer(process::PID<process::System>, process::Future<double> (&)())'
../../../3rdparty/libprocess/include/process/system.hpp:34:48: note: candidates are:
../../../3rdparty/libprocess/include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
../../../3rdparty/libprocess/include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
../../../3rdparty/libprocess/include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
../../../3rdparty/libprocess/include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
make[5]: *** [libprocess_la-process.lo] Error 1
make[5]: *** Waiting for unfinished jobs....
make[4]: *** [all-recursive] Error 1
make[3]: *** [all-recursive] Error 1
make[2]: *** [all] Error 2
make[1]: *** [all-recursive] Error 1
make: *** [distcheck] Error 1


- Mesos ReviewBot


On May 2, 2014, 3:05 a.m., Dominic Hamon wrote:
> 
> -----------------------------------------------------------
> This is an automatically generated e-mail. To reply, visit:
> https://reviews.apache.org/r/19545/
> -----------------------------------------------------------
> 
> (Updated May 2, 2014, 3:05 a.m.)
> 
> 
> Review request for mesos and Ben Mahler.
> 
> 
> Bugs: MESOS-1146
>     https://issues.apache.org/jira/browse/MESOS-1146
> 
> 
> Repository: mesos-git
> 
> 
> Description
> -------
> 
> see summary
> 
> 
> Diffs
> -----
> 
>   3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 
> 
> Diff: https://reviews.apache.org/r/19545/diff/
> 
> 
> Testing
> -------
> 
> make check and manually checked /system/stats.json against /metrics
> 
> 
> Thanks,
> 
> Dominic Hamon
> 
>

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Dominic Hamon <dh...@twopensource.com>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/
-----------------------------------------------------------

(Updated May 1, 2014, 8:05 p.m.)


Review request for mesos and Ben Mahler.


Changes
-------

rebased and updated as per benm's comments on 19504


Bugs: MESOS-1146
    https://issues.apache.org/jira/browse/MESOS-1146


Repository: mesos-git


Description
-------

see summary


Diffs (updated)
-----

  3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 

Diff: https://reviews.apache.org/r/19545/diff/


Testing
-------

make check and manually checked /system/stats.json against /metrics


Thanks,

Dominic Hamon

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Dominic Hamon <dh...@twopensource.com>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/
-----------------------------------------------------------

(Updated April 30, 2014, 11:18 a.m.)


Review request for mesos and Ben Mahler.


Changes
-------

rebased


Bugs: MESOS-1146
    https://issues.apache.org/jira/browse/MESOS-1146


Repository: mesos-git


Description
-------

see summary


Diffs (updated)
-----

  3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 

Diff: https://reviews.apache.org/r/19545/diff/


Testing
-------

make check and manually checked /system/stats.json against /metrics


Thanks,

Dominic Hamon

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Dominic Hamon <dh...@twopensource.com>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/
-----------------------------------------------------------

(Updated April 15, 2014, 12:27 p.m.)


Review request for mesos and Ben Mahler.


Changes
-------

rebased


Bugs: MESOS-1146
    https://issues.apache.org/jira/browse/MESOS-1146


Repository: mesos-git


Description
-------

see summary


Diffs (updated)
-----

  3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 

Diff: https://reviews.apache.org/r/19545/diff/


Testing
-------

make check and manually checked /system/stats.json against /metrics


Thanks,

Dominic Hamon

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Mesos ReviewBot <de...@mesos.apache.org>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/#review40400
-----------------------------------------------------------


Bad patch!

Reviews applied: [19545]

Failed command: make -j3 check GTEST_FILTER='' >/dev/null

Error:
 ev.c:1531:31: warning: 'ev_default_loop_ptr' initialized and declared 'extern' [enabled by default]
ev.c: In function 'evpipe_write':
ev.c:2160:17: warning: ignoring return value of 'write', declared with attribute warn_unused_result [-Wunused-result]
ev.c:2172:17: warning: ignoring return value of 'write', declared with attribute warn_unused_result [-Wunused-result]
ev.c: In function 'pipecb':
ev.c:2193:16: warning: ignoring return value of 'read', declared with attribute warn_unused_result [-Wunused-result]
ev.c:2207:16: warning: ignoring return value of 'read', declared with attribute warn_unused_result [-Wunused-result]
In file included from /usr/include/c++/4.6/ext/hash_set:61:0,
                 from src/glog/stl_logging.h:54,
                 from src/stl_logging_unittest.cc:34:
/usr/include/c++/4.6/backward/backward_warning.h:33:2: warning: #warning This file includes at least one deprecated or antiquated header which may be removed without further notice at a future date. Please use a non-deprecated interface with equivalent functionality instead. For a listing of replacement headers and interfaces, consult the file backward_warning.h. To disable this warning use -Wno-deprecated. [-Wcpp]
In file included from src/utilities.h:73:0,
                 from src/googletest.h:38,
                 from src/stl_logging_unittest.cc:48:
src/base/mutex.h:137:0: warning: "_XOPEN_SOURCE" redefined [enabled by default]
/usr/include/features.h:166:0: note: this is the location of the previous definition
In file included from src/process.cpp:63:0:
./include/process/system.hpp: In constructor 'process::System::System()':
./include/process/system.hpp:25:75: error: no matching function for call to 'defer(process::PID<process::System>, Option<double> (&)())'
./include/process/system.hpp:25:75: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:26:75: error: no matching function for call to 'defer(process::PID<process::System>, Option<double> (&)())'
./include/process/system.hpp:26:75: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:29:50: error: no matching function for call to 'defer(process::PID<process::System>, Option<double> (*)())'
./include/process/system.hpp:29:50: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:30:74: error: no matching function for call to 'defer(process::PID<process::System>, Option<double> (&)())'
./include/process/system.hpp:30:74: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:33:57: error: no matching function for call to 'defer(process::PID<process::System>, Option<double> (&)())'
./include/process/system.hpp:33:57: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:36:55: error: no matching function for call to 'defer(process::PID<process::System>, Option<double> (&)())'
./include/process/system.hpp:36:55: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
make[4]: *** [libprocess_la-process.lo] Error 1
make[4]: *** Waiting for unfinished jobs....
make[3]: *** [check-recursive] Error 1
make[2]: *** [check-recursive] Error 1
make[1]: *** [check] Error 2
make: *** [check-recursive] Error 1


- Mesos ReviewBot


On April 14, 2014, 8:19 p.m., Dominic Hamon wrote:
> 
> -----------------------------------------------------------
> This is an automatically generated e-mail. To reply, visit:
> https://reviews.apache.org/r/19545/
> -----------------------------------------------------------
> 
> (Updated April 14, 2014, 8:19 p.m.)
> 
> 
> Review request for mesos and Ben Mahler.
> 
> 
> Bugs: MESOS-1146
>     https://issues.apache.org/jira/browse/MESOS-1146
> 
> 
> Repository: mesos-git
> 
> 
> Description
> -------
> 
> see summary
> 
> 
> Diffs
> -----
> 
>   3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 
> 
> Diff: https://reviews.apache.org/r/19545/diff/
> 
> 
> Testing
> -------
> 
> make check and manually checked /system/stats.json against /metrics
> 
> 
> Thanks,
> 
> Dominic Hamon
> 
>

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Dominic Hamon <dh...@twopensource.com>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/
-----------------------------------------------------------

(Updated April 14, 2014, 1:19 p.m.)


Review request for mesos and Ben Mahler.


Bugs: MESOS-1146
    https://issues.apache.org/jira/browse/MESOS-1146


Repository: mesos-git


Description
-------

see summary


Diffs (updated)
-----

  3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 

Diff: https://reviews.apache.org/r/19545/diff/


Testing
-------

make check and manually checked /system/stats.json against /metrics


Thanks,

Dominic Hamon

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Dominic Hamon <dh...@twopensource.com>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/
-----------------------------------------------------------

(Updated April 10, 2014, 8:48 p.m.)


Review request for mesos and Ben Mahler.


Changes
-------

rebased to master.


Bugs: MESOS-1146
    https://issues.apache.org/jira/browse/MESOS-1146


Repository: mesos-git


Description
-------

see summary


Diffs (updated)
-----

  3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 

Diff: https://reviews.apache.org/r/19545/diff/


Testing
-------

make check and manually checked /system/stats.json against /metrics


Thanks,

Dominic Hamon

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Mesos ReviewBot <de...@mesos.apache.org>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/#review38846
-----------------------------------------------------------


Bad patch!

Reviews applied: [18718, 19545]

Failed command: make -j3 check GTEST_FILTER='' >/dev/null

Error:
 ev.c:1531:31: warning: 'ev_default_loop_ptr' initialized and declared 'extern' [enabled by default]
ev.c: In function 'evpipe_write':
ev.c:2160:17: warning: ignoring return value of 'write', declared with attribute warn_unused_result [-Wunused-result]
ev.c:2172:17: warning: ignoring return value of 'write', declared with attribute warn_unused_result [-Wunused-result]
ev.c: In function 'pipecb':
ev.c:2193:16: warning: ignoring return value of 'read', declared with attribute warn_unused_result [-Wunused-result]
ev.c:2207:16: warning: ignoring return value of 'read', declared with attribute warn_unused_result [-Wunused-result]
In file included from /usr/include/c++/4.6/ext/hash_set:61:0,
                 from src/glog/stl_logging.h:54,
                 from src/stl_logging_unittest.cc:34:
/usr/include/c++/4.6/backward/backward_warning.h:33:2: warning: #warning This file includes at least one deprecated or antiquated header which may be removed without further notice at a future date. Please use a non-deprecated interface with equivalent functionality instead. For a listing of replacement headers and interfaces, consult the file backward_warning.h. To disable this warning use -Wno-deprecated. [-Wcpp]
In file included from src/utilities.h:73:0,
                 from src/googletest.h:38,
                 from src/stl_logging_unittest.cc:48:
src/base/mutex.h:137:0: warning: "_XOPEN_SOURCE" redefined [enabled by default]
/usr/include/features.h:166:0: note: this is the location of the previous definition
In file included from src/process.cpp:63:0:
./include/process/system.hpp: In constructor 'process::System::System()':
./include/process/system.hpp:25:76: error: no matching function for call to 'defer(process::PID<process::System>, Option<double> (*)())'
./include/process/system.hpp:25:76: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:26:76: error: no matching function for call to 'defer(process::PID<process::System>, Option<double> (*)())'
./include/process/system.hpp:26:76: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:29:50: error: no matching function for call to 'defer(process::PID<process::System>, Option<double> (*)())'
./include/process/system.hpp:29:50: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:30:75: error: no matching function for call to 'defer(process::PID<process::System>, Option<double> (*)())'
./include/process/system.hpp:30:75: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:33:58: error: no matching function for call to 'defer(process::PID<process::System>, Option<double> (*)())'
./include/process/system.hpp:33:58: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/system.hpp:36:56: error: no matching function for call to 'defer(process::PID<process::System>, Option<double> (*)())'
./include/process/system.hpp:36:56: note: candidates are:
./include/process/defer.hpp:387:29: note: process::Deferred<void()> process::defer(const std::tr1::function<void()>&)
./include/process/defer.hpp:387:29: note:   candidate expects 1 argument, 2 provided
./include/process/defer.hpp:436:1: note: template<class A0> process::Deferred<void(A0)> process::defer(const std::tr1::function<void(A0)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0> process::Deferred<process::Future<T>(A0)> process::defer(const std::tr1::function<process::Future<T>(A0)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1> process::Deferred<void(A0, A1)> process::defer(const std::tr1::function<void(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1> process::Deferred<process::Future<X>(A0, A1)> process::defer(const std::tr1::function<process::Future<X>(A0, A1)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2> process::Deferred<void(A0, A1, A2)> process::defer(const std::tr1::function<void(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2> process::Deferred<process::Future<R>(A0, A1, A2)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3> process::Deferred<void(A0, A1, A2, A3)> process::defer(const std::tr1::function<void(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3> process::Deferred<process::Future<X>(A0, A1, A2, A3)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4> process::Deferred<void(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<void(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::Deferred<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)> process::defer(const std::tr1::function<process::Future<R>(A0, A1, A2, A3, A4, A5, A6, A7, A8)>&)
./include/process/defer.hpp:436:1: note: template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<void(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:436:1: note: template<class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::Deferred<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> process::defer(const std::tr1::function<process::Future<X>(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>&)
./include/process/defer.hpp:42:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::PID<T>&, void (T::*)())
./include/process/defer.hpp:52:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>&, void (T::*)())
./include/process/defer.hpp:60:1: note: template<class T> process::_Defer<void (*(process::PID<T>, void (T::*)()))(const process::PID<T>&, void (T::*)())> process::defer(const process::Process<T>*, void (T::*)())
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::PID<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>&, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class A0> process::_Defer<void (*(process::PID<T>, void (T::*)(P0), A0))(const process::PID<T>&, void (T::*)(P0), P0)> process::defer(const process::Process<T>*, void (T::*)(P0), A0)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class A0, class A1> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1), A0, A1))(const process::PID<T>&, void (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, void (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, void (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:118:1: note: template<class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<void (*(process::PID<T>, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, void (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:139:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::PID<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:149:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>&, process::Future<T> (T::*)())
./include/process/defer.hpp:157:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, process::Future<T> (T::*)()))(const process::PID<T>&, process::Future<T> (T::*)())> process::defer(const process::Process<T>*, process::Future<T> (T::*)())
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0), A0))(const process::PID<T>&, process::Future<R> (T::*)(P0), P0)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0), A0)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1), A0, A1))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:218:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, process::Future<R> (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:239:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::PID<T>&, R (T::*)())
./include/process/defer.hpp:249:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>&, R (T::*)())
./include/process/defer.hpp:257:1: note: template<class R, class T> process::_Defer<process::Future<T> (*(process::PID<T>, R (T::*)()))(const process::PID<T>&, R (T::*)())> process::defer(const process::Process<T>*, R (T::*)())
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::PID<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>&, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class A0> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0), A0))(const process::PID<T>&, R (T::*)(P0), P0)> process::defer(const process::Process<T>*, R (T::*)(P0), A0)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::PID<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>&, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class A0, class A1> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1), A0, A1))(const process::PID<T>&, R (T::*)(P0, P1), P0, P1)> process::defer(const process::Process<T>*, R (T::*)(P0, P1), A0, A1)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class A0, class A1, class A2> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2), A0, A1, A2))(const process::PID<T>&, R (T::*)(P0, P1, P2), P0, P1, P2)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2), A0, A1, A2)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class A0, class A1, class A2, class A3> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3), P0, P1, P2, P3)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3), A0, A1, A2, A3)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class A0, class A1, class A2, class A3, class A4> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4), P0, P1, P2, P3, P4)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4), A0, A1, A2, A3, A4)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class A0, class A1, class A2, class A3, class A4, class A5> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5), P0, P1, P2, P3, P4, P5)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5), A0, A1, A2, A3, A4, A5)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class A0, class A1, class A2, class A3, class A4, class A5, class A6> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6), P0, P1, P2, P3, P4, P5, P6)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6), A0, A1, A2, A3, A4, A5, A6)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), P0, P1, P2, P3, P4, P5, P6, P7)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7), A0, A1, A2, A3, A4, A5, A6, A7)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), P0, P1, P2, P3, P4, P5, P6, P7, P8)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8), A0, A1, A2, A3, A4, A5, A6, A7, A8)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
./include/process/defer.hpp:318:1: note: template<class R, class T, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> process::_Defer<process::Future<R> (*(process::PID<T>, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))(const process::PID<T>&, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> process::defer(const process::Process<T>*, R (T::*)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)
make[4]: *** [libprocess_la-process.lo] Error 1
make[4]: *** Waiting for unfinished jobs....
make[3]: *** [check-recursive] Error 1
make[2]: *** [check-recursive] Error 1
make[1]: *** [check] Error 2
make: *** [check-recursive] Error 1


- Mesos ReviewBot


On March 27, 2014, 11:27 p.m., Dominic Hamon wrote:
> 
> -----------------------------------------------------------
> This is an automatically generated e-mail. To reply, visit:
> https://reviews.apache.org/r/19545/
> -----------------------------------------------------------
> 
> (Updated March 27, 2014, 11:27 p.m.)
> 
> 
> Review request for mesos and Ben Mahler.
> 
> 
> Bugs: MESOS-1146
>     https://issues.apache.org/jira/browse/MESOS-1146
> 
> 
> Repository: mesos-git
> 
> 
> Description
> -------
> 
> see summary
> 
> 
> Diffs
> -----
> 
>   3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 
> 
> Diff: https://reviews.apache.org/r/19545/diff/
> 
> 
> Testing
> -------
> 
> make check and manually checked /system/stats.json against /metrics
> 
> 
> Thanks,
> 
> Dominic Hamon
> 
>

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Dominic Hamon <dh...@twopensource.com>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/
-----------------------------------------------------------

(Updated March 27, 2014, 4:27 p.m.)


Review request for mesos and Ben Mahler.


Changes
-------

ported to latest metrics version. Mostly here for illustrative purposes of how to use the API.


Bugs: MESOS-1146
    https://issues.apache.org/jira/browse/MESOS-1146


Repository: mesos-git


Description
-------

see summary


Diffs (updated)
-----

  3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 

Diff: https://reviews.apache.org/r/19545/diff/


Testing
-------

make check and manually checked /system/stats.json against /metrics


Thanks,

Dominic Hamon

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Dominic Hamon <dh...@twopensource.com>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/
-----------------------------------------------------------

(Updated March 26, 2014, 12:43 p.m.)


Review request for mesos and Ben Mahler.


Changes
-------

added dependency. again.


Bugs: MESOS-1146
    https://issues.apache.org/jira/browse/MESOS-1146


Repository: mesos-git


Description
-------

see summary


Diffs
-----

  3rdparty/libprocess/include/process/metrics/metric.hpp PRE-CREATION 
  3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 

Diff: https://reviews.apache.org/r/19545/diff/


Testing
-------

make check and manually checked /system/stats.json against /metrics


Thanks,

Dominic Hamon

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Mesos ReviewBot <de...@mesos.apache.org>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/#review38654
-----------------------------------------------------------


Bad patch!

Reviews applied: [19545]

Failed command: git apply --index 19545.patch

Error:
 error: 3rdparty/libprocess/include/process/metrics/metric.hpp: does not exist in index


- Mesos ReviewBot


On March 26, 2014, 6:55 p.m., Dominic Hamon wrote:
> 
> -----------------------------------------------------------
> This is an automatically generated e-mail. To reply, visit:
> https://reviews.apache.org/r/19545/
> -----------------------------------------------------------
> 
> (Updated March 26, 2014, 6:55 p.m.)
> 
> 
> Review request for mesos and Ben Mahler.
> 
> 
> Bugs: MESOS-1146
>     https://issues.apache.org/jira/browse/MESOS-1146
> 
> 
> Repository: mesos-git
> 
> 
> Description
> -------
> 
> see summary
> 
> 
> Diffs
> -----
> 
>   3rdparty/libprocess/include/process/metrics/metric.hpp PRE-CREATION 
>   3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 
> 
> Diff: https://reviews.apache.org/r/19545/diff/
> 
> 
> Testing
> -------
> 
> make check and manually checked /system/stats.json against /metrics
> 
> 
> Thanks,
> 
> Dominic Hamon
> 
>

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Dominic Hamon <dh...@twopensource.com>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/
-----------------------------------------------------------

(Updated March 26, 2014, 11:55 a.m.)


Review request for mesos and Ben Mahler.


Changes
-------

added reference to jira


Bugs: MESOS-1146
    https://issues.apache.org/jira/browse/MESOS-1146


Repository: mesos-git


Description
-------

see summary


Diffs
-----

  3rdparty/libprocess/include/process/metrics/metric.hpp PRE-CREATION 
  3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 

Diff: https://reviews.apache.org/r/19545/diff/


Testing
-------

make check and manually checked /system/stats.json against /metrics


Thanks,

Dominic Hamon

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Mesos ReviewBot <de...@mesos.apache.org>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/#review38593
-----------------------------------------------------------


Bad patch!

Reviews applied: [18718]

Failed command: git apply --index 18718.patch

Error:
 error: patch failed: 3rdparty/libprocess/Makefile.am:85
error: 3rdparty/libprocess/Makefile.am: patch does not apply


- Mesos ReviewBot


On March 25, 2014, 10:30 p.m., Dominic Hamon wrote:
> 
> -----------------------------------------------------------
> This is an automatically generated e-mail. To reply, visit:
> https://reviews.apache.org/r/19545/
> -----------------------------------------------------------
> 
> (Updated March 25, 2014, 10:30 p.m.)
> 
> 
> Review request for mesos and Ben Mahler.
> 
> 
> Repository: mesos-git
> 
> 
> Description
> -------
> 
> see summary
> 
> 
> Diffs
> -----
> 
>   3rdparty/libprocess/include/process/metrics/metric.hpp PRE-CREATION 
>   3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 
> 
> Diff: https://reviews.apache.org/r/19545/diff/
> 
> 
> Testing
> -------
> 
> make check and manually checked /system/stats.json against /metrics
> 
> 
> Thanks,
> 
> Dominic Hamon
> 
>

Re: Review Request 19545: Ported libprocess system/stats.json endpoint to new metrics library.

Posted by Dominic Hamon <dh...@twopensource.com>.

-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/19545/
-----------------------------------------------------------

(Updated March 25, 2014, 3:30 p.m.)


Review request for mesos and Ben Mahler.


Changes
-------

rebased and added back old statistics gathering for comparison.


Repository: mesos-git


Description
-------

see summary


Diffs (updated)
-----

  3rdparty/libprocess/include/process/metrics/metric.hpp PRE-CREATION 
  3rdparty/libprocess/include/process/system.hpp fbd1eaa1de44eb419cef4c78efd6d138eabc7b44 

Diff: https://reviews.apache.org/r/19545/diff/


Testing
-------

make check and manually checked /system/stats.json against /metrics


Thanks,

Dominic Hamon