Can you write proposal about std::shift? Need you any help= with writing proposal and/or implementation?

=D1=87=D0=B5=D1=82=D0= =B2=D0=B5=D1=80=D0=B3, 13 =D0=B8=D1=8E=D0=BB=D1=8F 2017 =D0=B3., 14:41:34 U= TC+3 =D0=BF=D0=BE=D0=BB=D1=8C=D0=B7=D0=BE=D0=B2=D0=B0=D1=82=D0=B5=D0=BB=D1= =8C Dan Raviv =D0=BD=D0=B0=D0=BF=D0=B8=D1=81=D0=B0=D0=BB:

Thanks for ph= rasing the motivation so well Nicol.

Arthur, regar= ding specific use cases, any algorithm doing time series analysis (e.g. tem= perature the last 20 days) could use this.

(A cycl= ical buffer is an alternative, but one which isn't always preferrable.)=

On 13 Jul 2017, at 4:43, Nicol Bolas <jmck...@gmail.com&g= t; wrote:

On W= ednesday, July 12, 2017 at 7:47:05 PM UTC-4, Arthur O'Dwyer wrote:
On Wednesday, July 12, = 2017 at 2:53:19 AM UTC-7, d...@soundradix.com wrote:
Hi,

Would anyon= e be interested in adding std::shift to <algorithm>?=C2=A0
=
It would be similar to both:
- std::rotate, but wi= thout moving the head elements back to the tail. This would allow a more ef= ficient implementation and clearer semantics in case rotation is not needed= as well as correctness in case rotation is undesired.
- <algo= rithm>'s std::move/std::move_backward (depending on the shift direct= ion).

std::shift should probably accommodate both = left and right shifts by one of:
- giving it either begin() and e= nd(), or rbegin() and rend(), similar to how std::rotate works for both lef= t and right rotations. The advantage is compactness of the implementation.<= /div>
- allowing the shift count parameter to be either positive or neg= ative. The advantage is compactness, though it might not be clear which dir= ection is which - to be consistent with rotate, positive integers should sh= ift to the left.
- having std::shift_right and std::shif= t_left functions. The advantage is clarity when calling the methods, althou= gh the same argument could be made for having separate std::rotate_left and= std::rotate_right instead of std::rotate, which we don't have.

std::rotate is actually just a r= otation; it doesn't need "left" or "right" qualific= ation because they're 100% equivalent. Consider a classroom globe with = London in front, facing you. Now "rotate" the globe until Beijing= is in front. It doesn't matter if you rotate left or rotate right; the= outcome is exactly the same either way.
=C2=A0
Here's a sample imple= mentation of a shift to the right direction:

template<class BidirIt> void shift_right(BidirIt first, BidirIt<= /span> last, <= span style=3D"color:#008">unsigned int n = =3D 1) { =C2=A0 =C2=A0 std:= :move_backward(first, last -= n, last); } <= /div>

This demonstrates that while std::shi= ft is implementable with std::move/std::move_backward,
1) It isn&= #39;t immediately clear from the code (at least to my eyes) that this is a = shift right, unless you are intimately familiar with std::move_backward.
2) Different calls, either to std::move or to std::move_backward, a= re required, depending on the shift direction.

If you're shifting the whole container's contents, = you could use either of these:
=C2=A0 =C2=A0 std::move(ctr.rbegin= () + n, ctr.rend(), ctr.rbegin());
=C2=A0 =C2=A0 std::move_backwa= rd(ctr.begin(), ctr.end() - n, ctr.end())?
I don't curre= ntly see the use-case for this "shift just a piece of a container"= ; algorithm, I mean as distinct from std::move and std::move_backward which= already exist. Do you have a use-case?

Th= e use-case would be anytime you'd want to use the code you just wrote. = When you have a range and N, and you want to do a shift N units in that dir= ection.

The point of having it is one of clarification and user expe= ctations. Yes, you can use `move` and `move_backward` to accomplish a shift= .. But consider the two function calls:

//A std::shift(rng.begin(), rng.end(), N); //B auto rrng =3D std::make_reverse_range(rng); std::move(rrng.begin() + N, rrng.end(), rrng.begin());
=
A and B both do the same thing. But it's a lot easier to fig= ure out what the code is actually accomplishing from looking at A than B.
B gets even more obtuse confusing in a range-based world:

/= /A std::shift(rng,= N); //= B au= to rrng =3D std::make_reverse_range(rng); std::move(std::make_range(rrng.begin + N, rrng.end()), rrng.begin());

--
You received this message because you are subscribed to the Google Groups &= quot;ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e= mail to std-proposal...@isocpp.org.
To post to this group, send email to std-pr...@isocpp.org.
To view this discussion on the web visit https://groups.google.com= /a/isocpp.org/d/msgid/std-proposals/c722a201-5c9c-4ac5-a1bd-= e50beb6d7860%40isocpp.org.