Slash Boxes
NOTE: use Perl; is on undef hiatus. You can read content, but you can't post it. More info will be forthcoming forthcomingly.

All the Perl that's Practical to Extract and Report

The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
More | Login | Reply
Loading... please wait.
  • I'm not sure what you're complaint is, exactly. I think negative indices are pretty useful, but you seemed to only test them on empty arrays. They're useful on longer arrays because -3 means "start at the right and go back three; if you get to the left, give up." So, given @foo = (1, 2, 3), $foo[-3] is 1, $foo[-2] is 2, and $foo[-10] is undef.

    I would've thought that C would do something horrid like (type)*(array - index), but my C is lousy.
    • I'm not complaining about negative arrays. I'm complaining that the behavior of arrays is inconsistent with regards to empty arrays and negative indices, specifically.
      • How is it inconsistent? Given @foo=(1,2,3); $foo[-10] does not exist. If fetched, it returns the "does not exist" value, which is undef. It's also C. It's not a valid lvalue, so it should throw an error.

        After all the -1 subscript is "first existing element from the right" not "a new element at the end." Or am I being thick?
        • You're talking about reference. I'm talking about assignment, e.g.

          @foo = ();
          $foo[10] = "foo"; # legal
          $foo[-10] = "foo"; # illegal

          In the former case, index 10 does not exist. I create it and indices 0 to 9 now exist as undef. In the latter case, index -10 does not exist, but I cannot assign to it. Why not allow me to assign to a negative index on an empty array?

          • $foo[10] = "foo" is the same as (assuming an empty @foo), @foo = ( (undef) x 9, "foo", (undef) x 0)

            You want $foo[-10] = "foo" to be the same as @foo = ( (undef) x $m, "foo", (undef) x $n ), but what are $m and $n ? (On reflection, $m should probably be zero and $n be 9? What's the benefit of this behavior?)

            Does $foo[-10] = $bar[-5] = "foo" result in @foo being a different size than @bar ? (Based on our reflection above, they would be different sizes.)

            If @foo is already defined, then what happens when we use a negative index that takes us off the left? (We are already allowed to use a positive index that takes us off the right--this maintains the symmetry we are seeking.) Do we pad the right with undefs? Or do we shift everything to the right by padding the left with undefs? How do we break the symmetry between the two selections (padding the right vs. padding the left/shifting to the right)? Both can be consistent with our desired behavior for previously empty arrays.