 /// Append the elements of rhs to lhs
 public func += <
   T, C: CollectionType where C._Element == T
-> (
-  inout lhs: _ContiguousArrayBuffer<T>, rhs: C
-) {
+> (inout lhs: _ContiguousArrayBuffer<T>, rhs: C) {
   let oldCount = lhs.count
   let newCount = oldCount + numericCast(count(rhs))
 

    /// Note that this is better than folding hasStorage in to
    /// the return from this function, as this implementation generates
    /// no shortcircuiting blocks.
    _precondition(_base.hasStorage, "Cannot index empty buffer")
    return (index >= 0) & (index < _base.value.count)
  }

  /// How many elements the buffer can store without reallocation
  public var capacity: Int {
    return _base.hasStorage ? _base.value.capacity : 0
  }

  /// Copy the given subRange of this buffer into uninitialized memory

  override var staticElementType: Any.Type {
    return T.self
  }

  internal // private
  typealias Manager = ManagedBufferPointer<_ArrayBody, T>

  internal // private
  var __manager : Manager {
    return Manager(unsafeBufferObject: self)
  }
}

public struct _ContiguousArrayBuffer<T> : _ArrayBufferType {
