code: func (d *Decoder) decodeArray(v reflect.Value, ignoreOpaque bool) (err error) {
  	dataLen, err := d.DecodeUint()
  	if err != nil {
  		return
  	}
  	if uint(dataLen) > uint(maxInt) {
  		err = unmarshalError("decodeArray", ErrOverflow, errMaxSlice, dataLen)
  		return
  	}
  
  	// Allocate storage for the slice elements (the underlying array) if
  	// existing slice does not enough capacity.
  	sliceLen := int(dataLen)
  	if v.Cap() < sliceLen {
  		v.Set(reflect.MakeSlice(v.Type(), sliceLen, sliceLen))
  	}
  	if v.Len() < sliceLen {
  		v.SetLen(sliceLen)
  	}
  
  	// Treat []byte (byte is alias for uint8) as opaque data unless ignored.
  	if !ignoreOpaque && v.Type().Elem().Kind() == reflect.Uint8 {
  		data, err := d.DecodeFixedOpaque(int32(sliceLen))
  		if err != nil {
  			return err
  		}
  		v.SetBytes(data)
  		return nil
  	}
  
  	// Decode each slice element.
  	for i := 0; i < sliceLen; i++ {
  		err = d.decode(v.Index(i))
  		if err != nil {
  			return err
  		}
  	}
  	return
  }
docs: // decodeArray treats the next bytes as a variable length series of XDR encoded
  // elements of the same type as the array represented by the reflection value.
  // The number of elements is obtained by first decoding the unsigned integer
  // element count.  Then each element is decoded into the passed array. The
  // ignoreOpaque flag controls whether or not uint8 (byte) elements should be
  // decoded individually or as a variable sequence of opaque data.
  //
  // An UnmarshalError is returned if any issues are encountered while decoding
  // the array elements.
  //
  // Reference:
  // 	RFC Section 4.13 - Variable-Length Array
  // 	Unsigned integer length followed by individually XDR encoded array elements