Make product iterator iterate in a more natural fashion.

[kmsquire]

Before:

julia> f = ['A', 'B', 'C']
4-element Char Array:
 'A'
 'B'
 'C'

julia> [product(f, f)...]
9-element (Any...,) Array:
 ('A','A')
 ('B','A')
 ('C','A')
 ('A','B')
 ('B','B')
 ('C','B')
 ('A','C')
 ('B','C')
 ('C','C')

After:

julia> [product(f,f)...]
9-element (Any...,) Array:
 ('A','A')
 ('A','B')
 ('A','C')
 ('B','A')
 ('B','B')
 ('B','C')
 ('C','A')
 ('C','B')
 ('C','C')

[StefanKarpinski]

Makes more sense to me.

[JeffBezanson]

Wait a minute, I'm not so sure about this. I believe the old version was consistent with indexes and comprehensions, where the first index varies fastest.

[staticfloat]

I see it as an arbitrary decision: You just have to decide which is better, iteration over the first variable fastest, or slowest.

The only thing that tips things in one favor or the other is that we already have a corpus of code that uses the comprehensions one way, so I don't feel that we should change this as (Illustrated by #1492) it can cause unexpected problems.

I personally like the first variable being the slowest, but in the end, I don't believe there's a big difference between the two.

[JeffBezanson]

I agree it is arbitrary by itself, but I'm going for consistency here. For example product(1:size(a,1),1:size(a,2)) might as well iterate over an array in address order.

[staticfloat]

Right, so we can either revert this change to make product() consistent with array comprehensions, or make further changes to make comprehensions consistent with this product(). I'm in favor of the former.

[toivoh]

I have a feeling that making everything consistent with the new product() order would need a change from column major to row major order for Array. I also think it would be best to revert.

[kmsquire]

I'm using product to exhaustively produce DNA sequences. For things that are presented to the user, iterating over the last element usually makes more sense, but I can certainly see the reasoning if it is used for iterating over array indices. The new order is consistent with Python, but Python also uses row-major order.

Right now, iterators.jl is in extras, and doesn't seem to have any other uses in the code base (outside of test--sorry, should have checked that). So I guess the question is, is it better to revert so it can iterate over arrays efficiently and maintain consistency with array comprehensions, or leave it for consistency with Python and my convenience. ;-)

[staticfloat]

Why not define an rproduct() or a product(..., :reverse) so that you can have your cake and eat it too?

[JeffBezanson]

I reverted it to be consistent with comprehensions and arrays. I would say anything that's related to presentation should just be handled at that level.