Why does array.slice behave differently for (length, n)

Question

If I have an array a:

1. a[a.length] returns nil. Good.
2. a[a.length, x] returns []. Good.
3. a[a.length+x, y] returns nil. Inconsistent with 2.

While this behavior is documented, it seems odd.

Can anybody explain the reasons behind this design?

Answer 1

Consider this

a = [0, 1, 2, 3] #=> [0, 1, 2, 3]
a[0, 10]         #=> [0, 1, 2, 3]
a[1, 10]         #=>    [1, 2, 3]
a[2, 10]         #=>       [2, 3]
a[3, 10]         #=>          [3]
a[4, 10]         #=>           []
a[5, 10]         #=>          nil

So a[4, 10] is the slice between the 3 and the end of the array which is []

Where as a[4] and a[5, 10] are accessing elements that aren't in the array

It may help to think of the slice points as being between the elements, rather than the elements themselves.

[ <0> 0 <1> 1 <2> 2 <3> 3 <4> ]

Where <n> are the points between elements and the start/end of the array. a[4, 10] then becomes a selection of 10 elements, starting from point 4. Whereas a[5, 10] starts from point 5, which is not part of the list.

Answer 2

Look to your friendly Lispy languages for the answer. The philosophy you're looking for began with languages whose specialty was LISt Processing (thus, LISP). For instance, here's one way of creating lists in Haskell:

1:[] => [1] 
1:2:3:[] => [1,2,3] 

This is called cons-ing, for 'constructing' a list. If the idea hasn't clicked yet, consider this: an array is created by adding elements to an empty list, not to 'nil'.

Answer 3

To begin with, this case is a special case in Ruby.

This special case also has an explanation to it:

There is a point of difference when you speak about indexing an array, and slicing it.

Indexing an array means to have an unique Position which helps you access the value at a given Index.

Slicing on the other hand means to "cut" between two points (P.S points here are index)

Consider this:

array = [Ruby, PHP, JS, HTML, CSS]

Indexing in this case will be:

array = [Ruby, PHP, JS, HTML, CSS]
Index =   0.    1.  2.  3.    4. 

Slicing in the same case will be:

array = [Ruby, PHP, JS, HTML, CSS]
Slice = 0.   1.   2.  3.    4.   5.

Hence:

array[5,n] #[] i.e. you get an empty array.
array[6,n] #nil i.e. NIL

Reference