code review 11884043: spec: clarify index and selector expressions

spec: clarify index and selector expressions

1) Explain a[i] and a[i:j] where a is of type *A as
   shortcut for (*a)[i] and (*a)[i:j], respectively.

2) Together with 1), because len() of nil slices is
   well defined, there's no need to special case nil
   operands anymore.

3) The result of indexing or slicing a constant string
   is always a non-constant byte or string value.

4) The result of slicing an untyped string is a value
   of type string.

5) If the operand of a valid slice a[i:j] is nil (i, j
   must be 0 for it to be valid - this already follows
   from the in-range rules), the result is a nil slice.

Fixes issue 4913.
Fixes issue 5951.

[gri, 2013-07-26 00:03:08]

Hello rsc@golang.org, r@golang.org, iant@golang.org, ken@golang.org (cc:
golang-dev@googlegroups.com),

I'd like you to review this change to
https://code.google.com/p/go

[gri, 2013-07-30 15:59:45]

friendly ping

(this is not change but a more complete documentation of the status quo)


On Thu, Jul 25, 2013 at 5:03 PM, <gri@golang.org> wrote:

> Reviewers: rsc, r, iant, ken2,
>
> Message:
> Hello rsc@golang.org, r@golang.org, iant@golang.org, ken@golang.org (cc:
> golang-dev@googlegroups.com),
>
> I'd like you to review this change to
> https://code.google.com/p/go
>
>
> Description:
> spec: clarify index and selector expressions
>
> 1) Explain a[i] and a[i:j] where a is of type *A as
>    shortcut for (*a)[i] and (*a)[i:j], respectively.
>
> 2) Together with 1), because len() of nil slices is
>    well defined, there's no need to special case nil
>    operands anymore.
>
> 3) The result of indexing or slicing a constant string
>    is always a non-constant byte or string value.
>
> 4) The result of slicing an untyped string is a value
>    of type string.
>
> 5) If the operand of a valid slice a[i:j] is nil (i, j
>    must be 0 for it to be valid - this already follows
>    from the in-range rules), the result is a nil slice.
>
> Fixes issue 4913.
> Fixes issue 5951.
>
> Please review this at
https://codereview.appspot.**com/11884043/<https://codereview.appspot.com/118...
>
> Affected files:
>   M doc/go_spec.html
>
>
> Index: doc/go_spec.html
> ==============================**==============================**=======
> --- a/doc/go_spec.html
> +++ b/doc/go_spec.html
> @@ -1,6 +1,6 @@
>  <!--{
>         "Title": "The Go Programming Language Specification",
> -       "Subtitle": "Version of July 25, 2013",
> +       "Subtitle": "Version of July 26, 2013",
>         "Path": "/ref/spec"
>  }-->
>
> @@ -2519,10 +2519,9 @@
>  </pre>
>
>  <p>
> -denotes the element of the array, slice, string or map <code>a</code>
> indexed by <code>x</code>.
> -The value <code>x</code> is called the
> -<i>index</i> or <i>map key</i>, respectively. The following
> -rules apply:
> +denotes the element of the array, pointer to array, slice, string or map
> <code>a</code> indexed by <code>x</code>.
> +The value <code>x</code> is called the <i>index</i> or <i>map key</i>,
> respectively.
> +The following rules apply:
>  </p>
>
>  <p>
> @@ -2537,44 +2536,48 @@
>  </ul>
>
>  <p>
> -For <code>a</code> of type <code>A</code> or <code>*A</code>
> -where <code>A</code> is an <a href="#Array_types">array type</a>:
> +For <code>a</code> of <a href="#Array_types">array type</a>
> <code>A</code>:
>  </p>
>  <ul>
>         <li>a <a href="#Constants">constant</a> index must be in range</li>
> -       <li>if <code>a</code> is <code>nil</code> or if <code>x</code> is
> out of range at run time,
> +       <li>if <code>x</code> is out of range at run time,
>             a <a href="#Run_time_panics">run-**time panic</a> occurs</li>
>         <li><code>a[x]</code> is the array element at index <code>x</code>
> and the type of
>             <code>a[x]</code> is the element type of <code>A</code></li>
>  </ul>
>
>  <p>
> -For <code>a</code> of type <code>S</code> where <code>S</code> is a <a
> href="#Slice_types">slice type</a>:
> +For <code>a</code> of <a href="#Pointer_types">pointer<**/a> to array
> type:
>  </p>
>  <ul>
> -       <li>if the slice is <code>nil</code> or if <code>x</code> is out
> of range at run time,
> +       <li><code>a[x]</code> is a shortcut for <code>(*a)[x]</code></li>
> +</ul>
> +
> +<p>
> +For <code>a</code> of <a href="#Slice_types">slice type</a>
> <code>S</code>:
> +</p>
> +<ul>
> +       <li>if <code>x</code> is out of range at run time,
>             a <a href="#Run_time_panics">run-**time panic</a> occurs</li>
>         <li><code>a[x]</code> is the slice element at index <code>x</code>
> and the type of
>             <code>a[x]</code> is the element type of <code>S</code></li>
>  </ul>
>
>  <p>
> -For <code>a</code> of type <code>T</code>
> -where <code>T</code> is a <a href="#String_types">string type</a>:
> +For <code>a</code> of <a href="#String_types">string type</a>:
>  </p>
>  <ul>
>         <li>a <a href="#Constants">constant</a> index must be in range
>             if the string <code>a</code> is also constant</li>
>         <li>if <code>x</code> is out of range at run time,
>             a <a href="#Run_time_panics">run-**time panic</a> occurs</li>
> -       <li><code>a[x]</code> is the byte at index <code>x</code> and the
> type of
> +       <li><code>a[x]</code> is the non-constant byte value at index
> <code>x</code> and the type of
>             <code>a[x]</code> is <code>byte</code></li>
>         <li><code>a[x]</code> may not be assigned to</li>
>  </ul>
>
>  <p>
> -For <code>a</code> of type <code>M</code>
> -where <code>M</code> is a <a href="#Map_types">map type</a>:
> +For <code>a</code> of <a href="#Map_types">map type</a> <code>M</code>:
>  </p>
>  <ul>
>         <li><code>x</code>'s type must be
> @@ -2628,9 +2631,9 @@
>  </pre>
>
>  <p>
> -constructs a substring or slice. The indices <code>low</code> and
> -<code>high</code> select which elements appear in the result. The result
> has
> -indices starting at 0 and length equal to
> +constructs a substring or slice. The <i>indices</i> <code>low</code> and
> +<code>high</code> select which elements of operand <code>a</code> appear
> +in the result. The result has indices starting at 0 and length equal to
>  <code>high</code>&nbsp;-&nbsp;**<code>low</code>.
>  After slicing the array <code>a</code>
>  </p>
> @@ -2663,24 +2666,34 @@
>  </pre>
>
>  <p>
> +If <code>a</code> is a pointer to an array, <code>a[low : high]</code> is
> a shortcut for
> +<code>(*a)[low : high]</code>.
> +</p>
> +
> +<p>
>  For arrays or strings, the indices <code>low</code> and <code>high</code>
> are
>  <i>in range</i> if <code>0</code> &lt;= <code>low</code> &lt;=
> <code>high</code> &lt;= <code>len(a)</code>,
>  otherwise they are <i>out of range</i>.
>  For slices, the upper index bound is the slice capacity
> <code>cap(a)</code> rather than the length.
>  A <a href="#Constants">constant</a> index must be non-negative and
> representable by a value of type
>  <code>int</code>.
> -If both indices
> -are constant, they must satisfy <code>low &lt;= high</code>. If
> <code>a</code> is <code>nil</code>
> -or if the indices are out of range at run time, a <a
> href="#Run_time_panics">run-**time panic</a> occurs.
> -</p>
> -
> -<p>
> -If the sliced operand is a string or slice, the result of the slice
> operation
> -is a string or slice of the same type.
> +If both indices are constant, they must satisfy <code>low &lt;=
> high</code>.
> +If the indices are out of range at run time, a <a
> href="#Run_time_panics">run-**time panic</a> occurs.
> +</p>
> +
> +<p>
> +Except for <a href="#Constants">untyped strings</a>, if the sliced
> operand is a string or slice,
> +the result of the slice operation is a non-constant string or slice of
> the same type.
> +For untyped string operands the result is a non-constant value of type
> <code>string</code>.
>  If the sliced operand is an array, it must be <a
> href="#Address_operators">**addressable</a>
>  and the result of the slice operation is a slice with the same element
> type as the array.
>  </p>
>
> +<!-- TODO: should this be an implementation restriction? -->
> +<p>
> +If the sliced operand of a valid slice expression is a <code>nil</code>
> slice, the result
> +is a <code>nil</code> slice.
> +<p>
>
>  <h3 id="Type_assertions">Type assertions</h3>
>
>
>
>

[r, 2013-07-31 03:41:37]

https://codereview.appspot.com/11884043/diff/15001/doc/go_spec.html
File doc/go_spec.html (right):

https://codereview.appspot.com/11884043/diff/15001/doc/go_spec.html#newcode2553
doc/go_spec.html:2553: <li><code>a[x]</code> is a shortcut for
<code>(*a)[x]</code></li>
"shortcut" is a bit odd. i think "shorthand" is the right term, or you could say

<li><code>a[x]</code> is equivalent to <code>(*a)[x]</code></li>

https://codereview.appspot.com/11884043/diff/15001/doc/go_spec.html#newcode2670
doc/go_spec.html:2670: <code>(*a)[low : high]</code>.
ditto.

https://codereview.appspot.com/11884043/diff/15001/doc/go_spec.html#newcode2676
doc/go_spec.html:2676: otherwise they are <i>out of range</i>.
you use this terminology before you define it.

[gri, 2013-07-31 20:30:58]

PTAL

https://codereview.appspot.com/11884043/diff/15001/doc/go_spec.html
File doc/go_spec.html (right):

https://codereview.appspot.com/11884043/diff/15001/doc/go_spec.html#newcode2553
doc/go_spec.html:2553: <li><code>a[x]</code> is a shortcut for
<code>(*a)[x]</code></li>
On 2013/07/31 03:41:38, r wrote:
> "shortcut" is a bit odd. i think "shorthand" is the right term, or you could
say
> 
> <li><code>a[x]</code> is equivalent to <code>(*a)[x]</code></li>
> 

typo - I meant shorthand

also fixed all other uses of "shortcut"

https://codereview.appspot.com/11884043/diff/15001/doc/go_spec.html#newcode2670
doc/go_spec.html:2670: <code>(*a)[low : high]</code>.
On 2013/07/31 03:41:38, r wrote:
> ditto.

Done.

https://codereview.appspot.com/11884043/diff/15001/doc/go_spec.html#newcode2676
doc/go_spec.html:2676: otherwise they are <i>out of range</i>.
On 2013/07/31 03:41:38, r wrote:
> you use this terminology before you define it.

this _is_ the definition

[gri, 2013-07-31 20:40:05]

*** Submitted as https://code.google.com/p/go/source/detail?r=bfd5ed8236d5 ***

spec: clarify index and selector expressions

1) Explain a[i] and a[i:j] where a is of type *A as
   shortcut for (*a)[i] and (*a)[i:j], respectively.

2) Together with 1), because len() of nil slices is
   well defined, there's no need to special case nil
   operands anymore.

3) The result of indexing or slicing a constant string
   is always a non-constant byte or string value.

4) The result of slicing an untyped string is a value
   of type string.

5) If the operand of a valid slice a[i:j] is nil (i, j
   must be 0 for it to be valid - this already follows
   from the in-range rules), the result is a nil slice.

Fixes issue 4913.
Fixes issue 5951.

R=rsc, r, iant, ken
CC=golang-dev
https://codereview.appspot.com/11884043

[r, 2013-07-31 21:06:40]

I didn't LGTM this.

[gri, 2013-07-31 21:07:35]

oops - my bad. I used the wrong CL #. Will revert.
- gri


On Wed, Jul 31, 2013 at 2:06 PM, Rob Pike <r@golang.org> wrote:

> I didn't LGTM this.
>
>

[r, 2013-07-31 21:09:16]

https://codereview.appspot.com/11884043/diff/23001/doc/go_spec.html
File doc/go_spec.html (right):

https://codereview.appspot.com/11884043/diff/23001/doc/go_spec.html#newcode2676
doc/go_spec.html:2676: otherwise they are <i>out of range</i>.
look at line 2532.

[gri, 2013-07-31 21:23:13]

https://codereview.appspot.com/11884043/diff/23001/doc/go_spec.html
File doc/go_spec.html (right):

https://codereview.appspot.com/11884043/diff/23001/doc/go_spec.html#newcode2676
doc/go_spec.html:2676: otherwise they are <i>out of range</i>.
On 2013/07/31 21:09:16, r wrote:
> look at line 2532.

Line 2532 defines these terms for index expressions, this section defines them
for slice expressions.

But perhaps I am missing something?

Please comment on new CL 12198043.