code review 156115: gofmt -r 'α[β:len(α)] -> α[β:]' -w src/cmd src/pkg

src/pkg/encoding/binary/binary.go

 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // This package implements translation between
 // unsigned integer values and byte sequences.
 package binary
 
 import (
         "math";
@@ skipping 192 matching lines @@
         buf     []byte;
 }
 
 type encoder struct {
         order   ByteOrder;
         buf     []byte;
 }
 
 func (d *decoder) uint8() uint8 {
         x := d.buf[0];
-        d.buf = d.buf[1:len(d.buf)];
+        d.buf = d.buf[1:];
         return x;
 }
 
 func (e *encoder) uint8(x uint8) {
         e.buf[0] = x;
-        e.buf = e.buf[1:len(e.buf)];
+        e.buf = e.buf[1:];
 }
 
 func (d *decoder) uint16() uint16 {
         x := d.order.Uint16(d.buf[0:2]);
-        d.buf = d.buf[2:len(d.buf)];
+        d.buf = d.buf[2:];
         return x;
 }
 
 func (e *encoder) uint16(x uint16) {
         e.order.PutUint16(e.buf[0:2], x);
-        e.buf = e.buf[2:len(e.buf)];
+        e.buf = e.buf[2:];
 }
 
 func (d *decoder) uint32() uint32 {
         x := d.order.Uint32(d.buf[0:4]);
-        d.buf = d.buf[4:len(d.buf)];
+        d.buf = d.buf[4:];
         return x;
 }
 
 func (e *encoder) uint32(x uint32) {
         e.order.PutUint32(e.buf[0:4], x);
-        e.buf = e.buf[4:len(e.buf)];
+        e.buf = e.buf[4:];
 }
 
 func (d *decoder) uint64() uint64 {
         x := d.order.Uint64(d.buf[0:8]);
-        d.buf = d.buf[8:len(d.buf)];
+        d.buf = d.buf[8:];
         return x;
 }
 
 func (e *encoder) uint64(x uint64) {
         e.order.PutUint64(e.buf[0:8], x);
-        e.buf = e.buf[8:len(e.buf)];
+        e.buf = e.buf[8:];
 }
 
 func (d *decoder) int8() int8   { return int8(d.uint8()) }
 
 func (e *encoder) int8(x int8)  { e.uint8(uint8(x)) }
 
 func (d *decoder) int16() int16 { return int16(d.uint16()) }
 
 func (e *encoder) int16(x int16)        { e.uint16(uint16(x)) }
 
@@ skipping 69 matching lines @@
         case *reflect.Int32Value:
                 e.int32(v.Get())
         case *reflect.Int64Value:
                 e.int64(v.Get())
         case *reflect.Float32Value:
                 e.uint32(math.Float32bits(v.Get()))
         case *reflect.Float64Value:
                 e.uint64(math.Float64bits(v.Get()))
         }
 }