code: func (b batch) Concat(other batch, size int) (left, right batch, minWait time.Duration) {
  	u := batch(append(b, other...))
  	for _, ot := range u {
  		if time.Now().After(ot.ReadyTime) {
  			// The current time is past the time the object should
  			// be available.
  			left = append(left, ot)
  		} else {
  			// The time hasn't passed for the object.
  			right = append(right, ot)
  			wait := time.Until(ot.ReadyTime)
  			if minWait == 0 {
  				minWait = wait
  			} else if wait < minWait {
  				minWait = wait
  			}
  		}
  	}
  	if len(left) <= size {
  		// If the size of left fits the given size limit, return with no adjustments.
  		return left, right, minWait
  	}
  	// If left is too large, trip left up to size and append the rest to right.
  	right = append(right, left[size:]...)
  	left = left[:size]
  	return left, right, minWait
  }
docs: // Concat concatenates two batches together, returning a single, clamped batch as
  // "left", and the remainder of elements as "right". If the union of the
  // receiver and "other" has cardinality less than "size", "right" will be
  // returned as nil. Any object tuple that is not currently able to be retried
  // (ie Retry-After response), will also go into the right batch. Also, when object(s)
  // are returend that are rate-limited, return the minimum duration required to wait until
  // a object is ready.