Re: [boost] [range] adaptors vs. rvalue to lvalue& binding

Subject: Re: [boost] [range] adaptors vs. rvalue to lvalue& binding
From: Bronek Kozicki (brok_at_[hidden])
Date: 2012-03-22 06:30:06

On 22/03/2012 06:40, Arno Schödl wrote:
> Hello,
>
> ideally I would like to use range-adapted lvalue ranges like any
> other lvalue ranges. Writing it down naively, as below, does not
> compile because LoadRefRange takes (and should take?) the range it
> modifies by lvalue&, while adaptor expressions are rvalues.
>
> template<typename Range>
> void modifies_range( Range&  rng );
>
> A a[5];
>
> main() {
>        // modifies all elements of a
> 	modifies_range ( a );
>
>        // modifies all elements (except for one) of a
> 	// adaptor is rvalue, does not compile:
>        modifies_range (
> 		boost::range::join(
> 			boost::adaptors::slice( a, 0, 1 ),
> 			boost::adaptors::slice( a, 2, countof(a) )
> 		)
>        );
>
> 	// compiles, but ugly:
> 	auto rng=boost::range::join(
> 		boost::adaptors::slice( a, 0, 1 ),
> 		boost::adaptors::slice( a, 2, countof(a) )
> 	);
> 	modifies_range(rng);
> }
>
>
> Any thoughts? Should adaptors receiving lvalues offer an
>
> operator adaptor&()&&; // overload on rvalue-ness

Hello

you don't want to add such operator to any class, as it would trigger 
automatic conversion of rvalue of given type to lvalue. Sometimes this 
is not right thing to do, but with added operator you will have no means 
of disabling this behaviour. Apart from that, ref-qualifiers 
unfortunately are not yet widely implemented and such code won't be very 
portable anyway (I only know of 2 compilers implementing this feature).

What you want to do instead is to change the signature of your function 
to accept both lvalue and rvalue reference:

   template<typename Range>
   void modifies_range(Range && rng);

I know it seems counter-intuitive since only && is used above, but it 
will work with both lvalues and rvalues thanks to reference collapsing 
rules. When Range is a reference type, && following it will do nothing 
(being collapsed) and lvalue binding will apply; when Range is an rvalue 
you will have proper rvalue binding; in both cases parameter "rng" is 
always an lvalue when used inside the function, since it's named; also 
in both cases rvalue-sness or lvalue-sness of actual function parameter 
is preserved in type Range, so it can be "recovered" e.g. with 
std::forward<Range>(rng).

You can find more detailed explanation of how this works on Thomas 
Becker's explanation of rvalue-references:

http://thbecker.net/articles/rvalue_references/section_08.html

B.