Hi there,

I was wondering why I should ever prefer std.range.lockstep over std.range.zip. In my (very limited) tests std.range.zip offered the same functionality as std.range.lockstep, i.e. I was able to iterate using `foreach(key, value; std.range.zip(...)) {}` which, according to the docs, is what std.range.lockstep was supposed to be designed for. On top of that, std.range.zip is capable of producing a RandomAccessRange, but std.range.lockstep only produces something with opApply.

Cheers

On Wednesday, 2 March 2016 at 08:51:07 UTC, Manuel Maier wrote:
> Hi there,
>
> I was wondering why I should ever prefer std.range.lockstep over std.range.zip. In my (very limited) tests std.range.zip offered the same functionality as std.range.lockstep, i.e. I was able to iterate using `foreach(key, value; std.range.zip(...)) {}` which, according to the docs, is what std.range.lockstep was supposed to be designed for. On top of that, std.range.zip is capable of producing a RandomAccessRange, but std.range.lockstep only produces something with opApply.
>
> Cheers

I'm not entirely sure, but I get the impression lockstep is a special case of zip. I suspect if you don't need anything zip offers over lockstep (mutability, random access) you won't gain anything from using it.

I'm usually using zip in this circumstance, but if all you're doing is iterating there doesn't seem to be a reason to not use lockstep.

On Wednesday, 2 March 2016 at 08:51:07 UTC, Manuel Maier wrote:
> Hi there,
>
> I was wondering why I should ever prefer std.range.lockstep over std.range.zip. In my (very limited) tests std.range.zip offered the same functionality as std.range.lockstep, i.e. I was able to iterate using `foreach(key, value; std.range.zip(...)) {}` which, according to the docs, is what std.range.lockstep was supposed to be designed for. On top of that, std.range.zip is capable of producing a RandomAccessRange, but std.range.lockstep only produces something with opApply.
>
> Cheers
zip uses the InputRange protocol, and bundles up all the values in a Tuple.

lockstep uses the opApply protocol, and doesn't bundle the values.

Lockstep is useful for foreach loops since you don't need to unpack a tuple, but zip is compatible with all of the std.range and std.algorithm functions that take ranges.

On Thursday, 3 March 2016 at 15:00:10 UTC, Alex Parrill wrote:
> On Wednesday, 2 March 2016 at 08:51:07 UTC, Manuel Maier wrote:
>> Hi there,
>>
>> I was wondering why I should ever prefer std.range.lockstep over std.range.zip. In my (very limited) tests std.range.zip offered the same functionality as std.range.lockstep, i.e. I was able to iterate using `foreach(key, value; std.range.zip(...)) {}` which, according to the docs, is what std.range.lockstep was supposed to be designed for. On top of that, std.range.zip is capable of producing a RandomAccessRange, but std.range.lockstep only produces something with opApply.
>>
>> Cheers
> zip uses the InputRange protocol, and bundles up all the values in a Tuple.
>
> lockstep uses the opApply protocol, and doesn't bundle the values.
>
> Lockstep is useful for foreach loops since you don't need to unpack a tuple, but zip is compatible with all of the std.range and std.algorithm functions that take ranges.

That helps a lot - it is funny that the documentation shows an example with foreach an `zip`. Your insights also helped me and I thought it should also help other people, so I made a PR ;-)

https://github.com/D-Programming-Language/phobos/pull/4054