On Tue, 31 May 2011 11:10:59 -0400, eles <e...@eles.com> wrote:
if (i1 > i2) swap(i1, i2);
That will affect further values from that point onward, which could
not be necessarily intended.
Also, is a bit of overhead for solving such a little issue. OK, it is
simple to swap but... why to be force to do it?
Or:
T[] arbitrarySlice(T)(T[] data, size_t i1, size_t i2) // rename as desired
{
return (i2 < i1) ? data[i2..i1] : data[i1..i2];
}
b = a.arbitrarySlice(i1, i2);
Not perfect, but doable.
In any case, it's not a common need to reverse indexes.
The "war" between open-right and closed-right limit has been waged
ever
since Fortran was first invented. It may seem that closed-right
limits
are more natural, but they are marred by problems of varied degrees
of
subtlety. For example, representing an empty interval is tenuous.
Particularly if you couple it with liberal limit swapping, what is a
[1
.. 0]? An empty slice or the same as the two-elements a[0 .. 1]?
Experience has shown that open-right has "won".
Andrei
I agree that the issue is not simple (else, there would have been no
"war"). I know no other examples where open-right limits are used. I
use (intensively) just another language capable of slicing, that is
Matlab. It uses the closed-left and closed-right limits and I tend to
see it as a winner in the engineering field, precisely because of its
ability to manipulate arrays (its older name is MATrix LABoratory and
this is exaxtly why I am using it for). Some examples of syntax
(arrays are 1-based in Matlab):
a=[1,2,3,4]; % array with elements: 1, 2, 3, 4 (of length 4)
b=a(1:3); %b is an array with elements: 1, 2, 3 (of length 3)
c=a(end-1:end); %c is an array with elements: 3, 4 (of length 2)
d=a(2:1); %d is empty
e=a(1:end); %e is an array with elements: 1,2,3,4 (of length 4)
f=a(1:10); %ERROR (exceeds array dimension)
g=a(1:1); %g is an array with elements: 1 (of length 1)
Although there is no straight way to represent an empty array using
the close-left&right syntax, I doubt this is important in real world.
Matlab has a special symbol (which is "[]") for representing empty
arrays. Where the need to represent an empty interval using slice
syntax in D?
An "empty" slice does not have length but it does have position. For
example, a binary search feature may return an empty slice indicating
where an element *would* be.
Moreover, when writing in D: a[1..1] is this an empty or a non-empty
array? One convention says that the element a[1] is part of the
slice, since the left limit is included and the other convention says
a[1] is not part of the slice precisely because the right limit is
excluded. So, which one weights more? So, is a[1..1] an empty array
or an array with one element?
This really is simply a matter of taste and experience. It's like
learning a new language, some words may sound or be spelled similarly, but
have completely different meanings. You just have to learn the nuances.
Here there is truly no "right" answer. To me, the Matlab syntax looks as
strange as the D syntax looks to you :) I also have trouble with 1-based
array languages. But that doesn't mean it's "wrong", just something I'm
not used to.
One thing I will say though, being able to refer to the element after the
interval makes things easier to code in containers. For example, in C++
STL, there is always an end iterator, even if it's not represented by the
length. It gives you an extra anchor at which you can insert elements,
meaning you don't need the "insertAfter" primitive as well as the insert
primitive. Always having an open interval on the right allows for nice
flow in code.
-Steve
