David Abrahams wrote:
> > How would you call an 'apply' counterpart that takes a
> > metafunction class and a _sequence_ of arguments, i.e.:
> >
> > typedef list_c<int,5,0> args;
> > typedef apply_tuple< plus<>, args >::type sum; // this one
> > BOOST_STATIC_ASSERT(sum::value == 5);
> >
> > ?
>
> I don't know. In Python, the one that takes an argument tuple is
> called "apply", and the other one is called "function call syntax" ;-)
I knew about the former, but I wondered how the second one is called :).
>
> > If it was run-time C++, I would be happy with 'apply_tuple',
> > but in MPL domain "tuple" isn't really the right word, and I
> > don't like 'apply_seq' or, worse yet, 'apply_sequence'. Or
> > should it be 'seq_apply' (from an English language standpoint)?
> >
> > Anyway, suggestions and opinions are welcome!
>
> I'm afraid I'm stumped also.
> If you were willing to make a massive change, I'd suggest:
>
> call this one 'apply'
> call the other one 'call' or 'invoke'
>
> Though I don't particularly like it.
Me too, but thanks for the suggestion.
> Why is 'apply' more appropriate
> for this one, other than consistency with some other language?
It's not indeed.
> I think 'apply_args' sounds right, though they both let you specify
> arguments.
I thought of this one too, and had the same concern...
> Maybe 'apply_arg_sequence' is appropriate?
This one is not bad, although 'apply_arg_sequence<F,args>' probably too long
for a metafunction invocation syntax. May be a shorter abbreviation of it,
'apply_arg_seq'?
Hmm, actually, come to think about it more, there is no reason to stick
arguments unfolding _and_ consequent function application into the same
metafunction. In fact, separating those two, besides conceptual clarity,
might yield some practical benefits as well - one might want to adapt a
metafunction class and just pass it on, with the invocation happening later
on, if at all.
So, instead of single 'apply_arg_seq' construct that does this
apply_arg_seq<F,Args>::type ==
apply<F,Args[0],Args[1],...,Args[n]>::type
we can just have ordinary 'apply' + a metafunction class adaptor that
unrolls the argument sequence:
unroll_args<F> == adapted_F
apply< unroll_args<F>,Args >::type
== apply<F,Args[0],Args[1],...,Args[n]>::type
where 'adapted_F' implements the actual unrolling:
struct adapted_F
{
template< typename Args > struct apply
: apply<F,Args[0],Args[1],...,Args[n]>
{
};
};
So, now the question is, how to name the adaptor? :) Does 'unroll_args'
sound right/good enough?
Aleksey
_______________________________________________
Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost
