Boost logo

Boost :

Subject: Re: [boost] Formale Review: Callable Traits
From: Peter Dimov (lists_at_[hidden])
Date: 2017-04-10 21:21:54

Tim Song wrote:
> On Mon, Apr 10, 2017 at 2:48 PM, Peter Dimov via Boost
> <boost_at_[hidden]> wrote:
> > The obvious theoretically consistent approach here is
> >
> > void(foo::*)(float, char, int) -> tuple<foo, float, char, int>
> It depends on what the theory is.

What I wanted (and failed) to express by "theoretically consistent" wasn't
"consistent with a theory" but "consistent, in theory". That is, consistent,
but not necessarily a better choice in practice.

> If the model is "type of the implicit object parameter during overload
> resolution", then foo& is the correct choice (see [over.match.funcs]/4).

That would be useful if you want to perform overload resolution on the
tuple, which you probably don't.

I acknowledged that foo& is more useful. One example is when given a member
pointer pmf you want for some reason to derive its corresponding
std::function. That would be

function< apply_return_t<args_t<PMF>, return_type_t<PMF>> >

and here we do want foo&.

We'd prefer a reversible tuple if we wanted to manipulate the argument list
(assuming that the built-in facilities are removed) and then go from the
tuple back to a member pointer. Although in this case it would probably be
more convenient if we just drop the class and keep the original member
pointer to retain it (along with the return type and noexcept which can't go
in the tuple anyway.)

Boost list run by bdawes at, gregod at, cpdaniel at, john at