   : ManagedProtoBuffer<Header, Element> {
 
   /// Create a new instance of the most-derived class, calling
-  /// `initialHeader` on the partially-constructed object to
-  /// generate an initial `Header`.
+  /// `factory` on the partially-constructed object to generate
+  /// an initial `Header`.
   public final class func create(
     minimumCapacity: Int,
-    initialHeader: @noescape (ManagedProtoBuffer<Header, Element>) throws -> Header
+    makingHeaderWith factory: (
+      ManagedProtoBuffer<Header, Element>) throws -> Header
   ) rethrows -> ManagedBuffer<Header, Element> {
 
     let p = try ManagedBufferPointer<Header, Element>(
       bufferClass: self,
       minimumCapacity: minimumCapacity,
-      initialHeader: { buffer, _ in
-        try initialHeader(
+      makingHeaderWith: { buffer, _ in
+        try factory(
           unsafeDowncast(buffer, to: ManagedProtoBuffer<Header, Element>.self))
       })
 


  /// Destroy the stored Header.
  deinit {
    ManagedBufferPointer(self).withUnsafeMutablePointerToHeader { $0.deinitialize() }
  }

  /// The stored `Header` instance.
  public final var header: Header {
    addressWithNativeOwner {
      return (
        ManagedBufferPointer(self).withUnsafeMutablePointerToHeader { UnsafePointer($0) },
        Builtin.castToNativeObject(self))
    }
    mutableAddressWithNativeOwner {

  public init(
    bufferClass: AnyClass,
    minimumCapacity: Int,
    makingHeaderWith factory:
      (buffer: AnyObject, capacity: (AnyObject) -> Int) throws -> Header
  ) rethrows {
    self = ManagedBufferPointer(
      bufferClass: bufferClass, minimumCapacity: minimumCapacity)

    // initialize the header field
    try withUnsafeMutablePointerToHeader {
      $0.initialize(with: 
        try factory(
          buffer: self.buffer,
          capacity: {
            ManagedBufferPointer(unsafeBufferObject: $0).capacity
