[
https://issues.apache.org/jira/browse/MESOS-3188?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14650129#comment-14650129
]
Michael Park commented on MESOS-3188:
-------------------------------------
An alternative design would be to introduce an {{unpacked}} adaptor that takes
any function {{F}} and returns a new function that takes a tuple and invokes
{{F}} by unpacking the elements of the tuple. A sketch of the function:
{code}
template <typename F>
auto unpacked(const F& f) { return [f](auto &&args) { return std::apply(f,
std::forward<decltype(args)>(args)); } }
{code}
Since we generally prefer to be explicit in Mesos, this may be a preferred
design. Furthermore, I think this is a more generic utility to have compared to
embedding implicit unpacking behavior to {{Future}}. If we had another place
that we wanted to support the implicit unpacking behavior, we would have to go
and update that feature as well. With {{unpacked}}, we would simply pass
{{unpacked(F)}} instead.
Sample usage:
{code}
{
// Subprocess example.
await(s.get().status(),
io::read(s.get().out().get()),
io::read(s.get().err().get()))
.then(unpacked(defer(self(), &Self::continue, lambda::_1)));
}
void continue(
Future<Option<int>> status,
Future<string> output,
Future<string> error)
{
...
}
{code}
> Add tuple-awareness to Future callbacks.
> ----------------------------------------
>
> Key: MESOS-3188
> URL: https://issues.apache.org/jira/browse/MESOS-3188
> Project: Mesos
> Issue Type: Improvement
> Components: libprocess
> Reporter: Benjamin Mahler
>
> Future is currently single-valued and so the only way to create a multi-value
> Future is to use a custom struct or a tuple. Since Future is not currently
> "tuple-aware", continuations have to take a tuple as well, and manually
> unpack:
> {code}
> {
> // Subprocess example.
> await(s.get().status(),
> io::read(s.get().out().get()),
> io::read(s.get().err().get()))
> .then(defer(self(), &Self::continue, lambda::_1));
> }
> void continue(std::tuple<
> Future<Option<int>>,
> Future<string>,
> Future<string>> results)
> {
> Future<Option<int>> status = std::get<0>(results);
> Future<string> output = std::get<1>(results);
> Future<string> error = std::get<2>(results);
> }
> {code}
> Since multi-value Future (i.e. Future<T1, T2, ...>) seems to be a bad design
> choice, being tuple aware can improve the code cleanliness by unpacking the
> tuple automatically for the continuation:
> {code}
> {
> // Subprocess example.
> await(s.get().status(),
> io::read(s.get().out().get()),
> io::read(s.get().err().get()))
> .then(defer(self(), &Self::continue, lambda::_1));
> }
> void continue(
> Future<Option<int>> status,
> Future<string> output,
> Future<string> error)
> {
> ...
> }
> {code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
