On Tuesday, 11 February 2014 at 16:30:42 UTC, Rene Zwanenburg wrote:
> On Tuesday, 11 February 2014 at 16:26:06 UTC, Rene Zwanenburg wrote:
>> On Tuesday, 11 February 2014 at 03:10:02 UTC, Jonathan Dunlap wrote:
>>> Wow! This is GREAT stuff. My use-case is slightly more complex, and I'm not sure how to best apply this knowledge. The retro reverses the array which is problematic in itself as well as losing the starting index location. I have an array that I'd like to elegantly "rotate". Best way I can show this is by example of an imaginary rotate function:
>>>
>>> auto data = [1,2,3];
>>> assert( data.cycle.rotate(2) == [3,1,2] );
>>> assert( data.cycle.rotate(-2) == [2,3,1] );
>>>
>>> Perhaps what I'm doing is too complex requires me making my own iterator or something. In my quest of writing readable efficient code, I'm wondering what's the best route here. Thanks :)
>>
>> Perhaps something like this?
>> http://dpaste.dzfl.pl/d4b82b0b5cba
>
> Wait, we can avoid creating that closure and eliminate the map. This should be a bit faster and not use the GC:
>
> http://dpaste.dzfl.pl/78c65eacfeb1

Why not drop and take?
http://dpaste.dzfl.pl/0649b809c81e

Ooo.. I like the drop and take approach! I wonder if this could be something that makes it into the standard library (std.range?). What would be the best way to approach in suggesting that?

> Why not drop and take?
> http://dpaste.dzfl.pl/0649b809c81e

On Mon, 2014-02-10 at 09:16 +0000, Gary Willoughby wrote:
> On Monday, 10 February 2014 at 03:14:31 UTC, Jonathan Dunlap wrote:
> > (disclaimer: I'm new around here)
> > Is it possible to cycle backwards? If not, what's the best
> > approach?
> 
> import std.algorithm;
> import std.array;
> import std.range;
> import std.stdio;
> 
> void main(string[] args)
> {
> 	auto data = [1,2,3];
> 
> 	assert(data.cycle.take(5).array       == [1,2,3,1,2]);
> 	assert(data.retro.cycle.take(5).array == [3,2,1,3,2]);
> }


As Gary is aware, I posted this problem to ACCU asking for a C++ version. I think Steve Love has had a go with an added range library not just pure C++14. I'll post when I have looked at his code, and ensured it works. He is using Catch for testing so I suspect it will.

I had a quick go at doing a Python 3 version using PyTest:


def provide(sourceSequence, resultLength):
    return (sourceSequence[i % len(sourceSequence)] for i in range(resultLength))

def provideReverse(sourceSequence, resultLength):
    sourceLength = len(sourceSequence)
    return (sourceSequence[sourceLength - 1 - i % sourceLength] for i in range(resultLength))

data = [1, 2, 3]

def test_forward():
    assert tuple(provide(data, 5)) == (1,2,3,1,2)

def test_reverse():
    assert tuple(provideReverse(data, 5)) == (3,2,1,3,2)

-- 
Russel. ============================================================================= Dr Russel Winder      t: +44 20 7585 2200   voip: sip:russel.winder@ekiga.net 41 Buckmaster Road    m: +44 7770 465 077   xmpp: russel@winder.org.uk London SW11 1EN, UK   w: www.russel.org.uk  skype: russel_winder

On Mon, 2014-02-10 at 11:33 +0000, bearophile wrote:
> Russel Winder:
> 
> >This really needs to get onto the D website somewhere.
> 
> retro+cycle is very simple code, you can also combine them:
> 
> alias retroCycle = compose!(cycle, retro);

point-free composition. We like this :-)

> Ranges and algorithms can be combined together in so many ways :-) For an imperative/OO programmer writing code based on lazy ranges and higher order functions is a new kind of programming that should be learnt patiently, but it's not hard and it doesn't contain many low-level pitfalls :-)

Tell me about it. I run training courses trying to get people to do this higher-order stuff, and meta-object protocol stuff, in Python, Java and Groovy (with some Scala) and some get it and some don't.

Rule 1: don't mention monads.

-- 
Russel. ============================================================================= Dr Russel Winder      t: +44 20 7585 2200   voip: sip:russel.winder@ekiga.net 41 Buckmaster Road    m: +44 7770 465 077   xmpp: russel@winder.org.uk London SW11 1EN, UK   w: www.russel.org.uk  skype: russel_winder

On Monday, 10 February 2014 at 03:14:31 UTC, Jonathan Dunlap wrote:
> (disclaimer: I'm new around here)
> Is it possible to cycle backwards? If not, what's the best approach?
>
> Example of some ideal "takeBack" function:
> data = cycle([1,2,3][])
> take(data, 4) is [1,2,3,1][]
> takeBack(data, 4) would be [1,3,2,1][]
>
> Thoughts?

We've had a discussion about this recently with Andrej Mitrovic.

The question was basically: Should Cycle (keeping in mind it is an infinite range) be bidirectional? And if yes, what should be the first last?

There is fundamentally nothing preventing us from making Cycle bidirection (though maybe as opt-in CycleBidirectional, due to extra costs). We'd just need a use case, and specifications I guess. For example:

auto s = cycle([1, 2, 3]);
auto last = cycle.back;

What's last's value? I think it should be 3. If we can agree and file an ER, it can be done.

Russel Winder:

> I had a quick go at doing a Python 3 version using PyTest:
>
>
> def provide(sourceSequence, resultLength):
>     return (sourceSequence[i % len(sourceSequence)] for i in range(resultLength))
>
> def provideReverse(sourceSequence, resultLength):
>     sourceLength = len(sourceSequence)
>     return (sourceSequence[sourceLength - 1 - i % sourceLength] for i in range(resultLength))

Take also a look at itertools.cycle.

Bye,
bearophile

On Thu, 2014-02-13 at 18:03 +0000, bearophile wrote:
[…]
> Take also a look at itertools.cycle.

Indeed. I keep forgetting about itertools when rushed, which is a definite error.

-- 
Russel. ============================================================================= Dr Russel Winder      t: +44 20 7585 2200   voip: sip:russel.winder@ekiga.net 41 Buckmaster Road    m: +44 7770 465 077   xmpp: russel@winder.org.uk London SW11 1EN, UK   w: www.russel.org.uk  skype: russel_winder

On Thu, 2014-02-13 at 18:03 +0000, bearophile wrote:
[…]
> Take also a look at itertools.cycle.

How about this:


        #! /usr/bin/env py.test-3.3

        from itertools import cycle, islice

        data = [1, 2, 3]

        def test_forward():
            assert tuple(islice(cycle(data), 5)) == (1,2,3,1,2)

        def test_reverse():
            assert tuple(islice(cycle(reversed(data)), 5)) ==
        (3,2,1,3,2)



-- 
Russel. ============================================================================= Dr Russel Winder      t: +44 20 7585 2200   voip: sip:russel.winder@ekiga.net 41 Buckmaster Road    m: +44 7770 465 077   xmpp: russel@winder.org.uk London SW11 1EN, UK   w: www.russel.org.uk  skype: russel_winder

On Monday, 10 February 2014 at 03:14:31 UTC, Jonathan Dunlap wrote:
> (disclaimer: I'm new around here)
> Is it possible to cycle backwards? If not, what's the best approach?
>
> Example of some ideal "takeBack" function:
> data = cycle([1,2,3][])
> take(data, 4) is [1,2,3,1][]
> takeBack(data, 4) would be [1,3,2,1][]
>
> Thoughts?

I don't think it is currently possible, but it shouldn't be hard to make retro work with cycle.

On Thursday, 13 February 2014 at 20:40:21 UTC, Tobias Pankrath wrote:
> On Monday, 10 February 2014 at 03:14:31 UTC, Jonathan Dunlap wrote:
>> (disclaimer: I'm new around here)
>> Is it possible to cycle backwards? If not, what's the best approach?
>>
>> Example of some ideal "takeBack" function:
>> data = cycle([1,2,3][])
>> take(data, 4) is [1,2,3,1][]
>> takeBack(data, 4) would be [1,3,2,1][]
>>
>> Thoughts?
>
> I don't think it is currently possible, but it shouldn't be hard to make retro work with cycle

Yep, I've missed three pages of this discussion.

@monarch_dodra
I'd say a bidirectional cycle should be a consistent to the random access version, so popBack becomes essentially a index-- and back == front initially.