public struct TrailingArray<Header: TrailingElements>: ~Copyable
    where Header: ~Copyable
{
    /// Allocate an intrusive managed buffer with the given header and calling
    /// the initializer to fill in the trailing elements.
    public init<E>(
        header: consuming Header,
        initializingTrailingElementsWith initializer: (inout OutputSpan<Element>) throws(E) -> Void
    ) throws(E)

    /// Allocate an intrusive managed buffer with the given header and
    /// initializing each trailing element with the given `element`.
    public init(header: consuming Header, repeating element: Element)

    /// Take ownership over a pointer to memory containing the header followed
    /// by the trailing elements.
    ///
    /// Once this managed buffer instance is no longer used, this memory will
    /// be freed.
    public init(consuming pointer: UnsafeMutablePointer<Header>)

    /// Return the pointer to the underlying memory, including ownership over
    /// that memory. The underlying storage will not be freed by this buffer;
    /// it is the responsibility of the caller.
    public consuming func takePointer() -> UnsafeMutablePointer<Header>

    /// Access the header portion of the buffer.
    public var header: Header { get set }

    /// The number of trailing elements in the value.
    public var count: Int { get }

    /// Starting index for accessing the trailing elements. Always 0
    public var startIndex: Int { get }

    /// Ending index for accessing the trailing elements. Always `count`.
    public var endIndex: Int { get }

    /// Indices covering all of the trailing elements. Always `0..<count`.
    public var indices: Range<Int> { get }

    /// Access the trailing element at the given index.
    public subscript(index: Int) -> Element { get set }

    /// Accesses the trailing elements following the header.
    public var elements: Span<Element> { get }

    /// Accesses the trailing elements following the header, allowing mutation
    /// of those elements.
    public var mutableElements: MutableSpan<Element> { mutating get }

    /// Create a temporary intrusive managed buffer for the given header, whose
    /// trailing elements are initialized to copies of `element`. That instance
    /// is provided to the given `body` to operate on for the duration of the
    /// call. The temporary is allocated on the stack, unless it is very
    /// large according to `withUnsafeTemporaryAllocation`.
    public static func withTemporaryValue<R: ~Copyable, E>(
        header: consuming Header,
        repeating element: Element,
        body: (inout IntrusiveManagedBuffer<Header>) throws(E) -> R
    ) throws(E) -> R

    /// Create a temporary intrusive managed buffer for the given header, whose
    /// trailing elements are initialized with the given `initializer` function.
    /// That instance is provided to the given `body` to operate on for the
    /// duration of the call. The temporary is allocated on the stack, unless
    /// it is very large according to `withUnsafeTemporaryAllocation`.
    public static func withTemporaryValue<R: ~Copyable, E>(
        header: consuming Header,
        initializingTrailingElementsWith initializer: (inout OutputSpan<Element>) throws(E) -> Void,
        body: (inout IntrusiveManagedBuffer<Header>) throws(E) -> R
    ) throws(E) -> R
}