[ruby-talk:5697] Re: Array#insert

Mark Slagell wrote:
> 
> "Guy N. Hurst" wrote:
> >
> > Aleksi Niemelwrote:
> > > ...
> > >   a=[1,2,3]; a.insert(-1, [4,5]); p a;
> > >   [1, 2, [4, 5], 3]
> > >
> >
> > I don't like this because it implies there is no way
> > to use the 'insert' method to put something at the end.
> 
> Right.
> 
> > I would prefer that using -1 would result in:
> >
> > [1, 2, 3, [4, 5]]
> 
> But it muddies the semantics, right? "insert before" for non-negative
> indices, "insert after" for negative. 

I don't think it muddies the semantics at all.

It is always "insert before" - it's just a matter of which direction
you are traversing the elements. And using the negative sign indicates
you are moving right-to-left, so you would still be following the
"insert-before" semantic, albeit the mirror image of it.


[*** Note: the rest of this long email simply belabors this point,
and can be disregarded if you get the drift already ]



> I don't know that there's a good
> solution, because it would seem that some kinds of asymmetry are
> unavoidable when 0 can refer to the first element of something and -1 to
> the last.

What has muddied it, perhaps, is using zero as the starting index. ;-)

Otherwise, we would have:
1,2,3,... for the left-to-right movement, which allows you to specify
the first element
and
-1,-2,-3,.... for the right-to-left movement, which allows you to specify
the last element without knowing how many total elements.

But with zero, who should get it? It can't be in both places because then
there would be an ambiguity since +0 == -0.
For that you would have to have two different commands to distinguish
from which direction you wish to start.

But the case I am interested in is using a single command, with the
negative sign to indicate the direction of traversal.

So, since it is so common to start indexing with zero and move
left-to-right, that ONLY LEAVES us with the option of starting
the right-to-left movement at index -1.

It is very logical - more so than our local-var/dyna-var semantic.

If this functionality is not built-in, then it will probably be an
add-on module implemented using a bunch of pop's etc.


[***  Note: this email merely continues to belabor the point - no need to read 
further unless you have the time and inclination]



Let me repeat...

I don't focus on 'insert before' or 'insert after', I pay attention to
the direction I am traversing it in.

 0 1 2 3
[a,b,c,d,...]

   -3 -2 -1
[...x, y, z]


-1 means first element when starting from the right. You can't use
zero because that is already taken. NOTHING ELSE makes sense.
(otherwise please dispel my ignorance :-)

Likewise, if you need to identify insertion points, zero is already
taken:

 0   1   2   3 ...
[  a,  b,  c,  d...]

So to be able to use the same command and start from the opposite end
you must use the following scheme:

  -4  -3  -2  -1
[... x,  y,  z  ]

Regardless of what might be used elsewhere, no one can possibly be
confused (for long) with this approach, because there is no other
workable solution.

In fact, I think if zero were ever put at the end, I *would* be confused.
There is no need to do that, even if regular indexing started at +1 instead
of zero.
...

In PHP, the last element is identified by -1, the second-last as -2, etc.
The first element is 0, second is 1, etc.
That is really the only way it can work without causing confusion.
What else could the last element be? 0? 9999999999? _LAST_?
(ok, using _LAST_ is reasonable)


[*** Warning! It isn't getting any shorter - stop now unless you still have time ;-) ]



As a matter of fact, let me lengthen this email to demonstrate just what
PHP does to make handy use of such semantics with the substr() function:


substr ("string", start [, length])
http://www.php.net/manual/function.substr.php
>>
Substr returns the portion of string specified by the 
start and length parameters. 

If start is positive, the returned string will start at 
the start'th position in string, counting from zero. 

For instance, in the string 'abcdef', the character at position 0 is 'a', 
the character at position 2 is 'c', and so forth. 

Examples: 

$rest = substr ("abcdef", 1);    // returns "bcdef"
$rest = substr ("abcdef", 1, 3); // returns "bcd"
                                
If start is negative, the returned string will start at 
the start'th character from the end of string.

Examples: 

$rest = substr ("abcdef", -1);    // returns "f"
$rest = substr ("abcdef", -2);    // returns "ef"
$rest = substr ("abcdef", -3, 1); // returns "d"
                                

If length is given and is positive, the string returned will 
end length characters from start. If this would result in a string with
negative length (because the start is past the end of the string), 
then the returned string will contain the single character at start. 

If length is given and is negative, the string returned will 
end length characters from the end of string. If this would result in a
string with negative length, then the returned string will contain 
the single character at start. 

Examples: 

$rest = substr ("abcdef", 1, -1); // returns "bcde"
<<
                               
(note: PHP isn't perfect, and other functions aren't as exemplary
as substr(), nor is there an array_insert() function, but still...)

I don't think semantics needs to be a concern when there is no other 
workable way to think about something. Likewise it shouldn't be an 
issue that the last element should start with -1 and move to the left.

Semantics is definable, and should be geared towards how the language 
is most likely to be used, I think.


Guy N. Hurst

[ Ok, it's over. :-) ]
-- 
HurstLinks Web Development    http://www.hurstlinks.com/
Norfolk, VA - [phone]
PHP/MySQL - Ruby/Perl - HTML/Javascript