In a Go slice, why does s[lo:hi] end at element hi-1?

According to the Tour of Go, in a Go slice s, the expression s[lo:hi] evaluates to a slice of the elements from lo through hi-1, inclusive:

package main

import "fmt"

func main() {

    p := []int{0,  // slice position 0 
               10, // slice position 1
               20, // slice position 2
               30, // slice position 3
               40, // slice position 4
               50} // slice position 5

    fmt.Println(p[0:3]) // => [0 10 20]
}    

In my code example above, "p[0:3]" would seem to intuitively "read" as: "the slice from position 0 to position 3", equating to [0, 10, 20, 30]. But of course, it actually equates to [0 10 20].

So my question is: what is the design rationale for the upper value evaluating to hi-1 rather than simply hi? It feels unintuitive, but there must be some reason for it that I'm missing, and I'm curious what that might be.

Thanks in advance.

This is completely a matter of convention, and there are certainly other ways to do it (for example, Matlab uses arrays whose first index is 1). The choice really comes down to what properties you want. As it turns out, using 0-indexed arrays where slicing is inclusive-exclusive (that is, a slice from a to b includes element a and excludes element b) has some really nice properties, and thus it's a very common choice. Here are a few advantages.

Advantages of 0-indexed arrays and inclusive-exclusive slicing

(note that I'm using non-Go terminology, so I'll talk about arrays in the way that C or Java would talk about them. Arrays are what Go calls slices, and slices are sub-arrays (ie, "the slice from index 1 to index 4"))

• Pointer arithmetic works. If you're in a language like C, arrays are really just pointers to the first element in the array. Thus, if you use 0-indexed arrays, then you can say that the element at index i is just the element pointed at by the array pointer plus i. For example, if we have the array [3 2 1] with the address of the array being 10 (and assuming that each value takes up one byte of memory), then the address of the first element is 10 + 0 = 10, the address of the second is 10 + 1 = 11, and so on. In short, it makes the math simple.

• The length of a slice is also the place to slice it. That is, for an array arr, arr[0:len(arr)] is just arr itself. This comes in handy a lot in practice. For example, if I call n, _ := r.Read(arr) (where n is the number of bytes read into arr), then I can just do arr[:n] to get the slice of arr corresponding to the data that was actually written into arr.

• Indices don't overlap. This means that if I have arr[0:i], arr[i:j], arr[j:k], arr[k:len(arr)], these slices fully cover arr itself. You may not often find yourself partitioning an array into sub-slices like this, but it has a number of related advantages. For example, consider the following code to split an array based on non-consecutive integers:

    func consecutiveSlices(ints []int) [][]int {
        ret := make([][]int, 0)
        i, j := 0, 1
        for j < len(ints) {
            if ints[j] != ints[j-1] + 1 {
                ret = append(ret, ints[i:j])
                i = j
            }
        }
        ret = append(ret, ints[i:j])
    }
  

(this code obviously doesn't handle some edge cases well, but you get the idea)

If we were to try to write the equivalent function using inclusive-inclusive slicing, it would be significantly more complicated.

If anyone can think of any more, please feel free to edit this answer and add them.

> The Go Programming Language Specification
>
> Slice types
>
> Slice expressions
>
> For a string, array, pointer to array, or slice a, the primary
> expression
>
> a[low : high]
>
> constructs a substring or slice. The indices low and high select which
> elements of operand a appear in the result. The result has indices
> starting at 0 and length equal to high - low.
>
> For convenience, any of the indices may be omitted. A missing low
> index defaults to zero; a missing high index defaults to the length of
> the sliced operand
>
> For arrays or strings, the indices are in range if 0 <= low <= high <=
> len(a), otherwise they are out of range. For slices, the upper index
> bound is the slice capacity cap(a) rather than the length. A constant
> index must be non-negative and representable by a value of type int;
> for arrays or constant strings, constant indices must also be in
> range. If both indices are constant, they must satisfy low <= high. If
> the indices are out of range at run time, a run-time panic occurs.

For q := p[m:n], q is a slice of p starting at index m for a length of n-m elements.