struct MyCollection: Collection {
    let storage: [UInt8]
    typealias Element = UInt8
    typealias Index = Array<UInt8>.Index
    typealias SubSequence = Array<UInt8>.SubSequence
    typealias Indices = Array<UInt8>.Indices

    init(underlying: [UInt8]) {
        self.storage = underlying
    }

    public var indices: Indices {
        return self.storage.indices
    }
    public subscript(bounds: Range<Index>) -> SubSequence {
        return self.storage[bounds]
    }

    public subscript(position: Index) -> Element {
        return self.storage[position]
    }

    public var startIndex: Index {
        return self.storage.startIndex
    }

    public var endIndex: Index {
        return self.storage.endIndex
    }

    func index(after i: Index) -> Index {
        return self.storage.index(after: i)
    }

    func withContiguousStorageIfAvailable<R>(_ body: (UnsafeBufferPointer<UInt8>) throws -> R) rethrows -> R? {
        return try self.storage.withUnsafeBufferPointer(body)
    }
}

func makeString<Bytes: Collection>(_ bytes: Bytes) -> String where Bytes.Element == UInt8 {
    return String(decoding: bytes, as: Unicode.UTF8.self)
}

func testMyCollectionUnsafe(_ array: MyCollection) -> String {
    return array.withContiguousStorageIfAvailable {
        return makeString($0)
    }!
}

func testMyCollection(_ array: MyCollection) -> String {
    return makeString(array)
}

@inline(never)
func doMyCollectionUnsafe() {
    let array: [UInt8] = Array(repeating: UInt8(ascii: "X"), count: 15)
    let myCollection = MyCollection(underlying: array)

    for _ in 0..<10000 {
        precondition(testMyCollectionUnsafe(myCollection) == "XXXXXXXXXXXXXXX")
    }
}

@inline(never)
func doMyCollection() {
    let array: [UInt8] = Array(repeating: UInt8(ascii: "X"), count: 15)
    let myCollection = MyCollection(underlying: array)

    for _ in 0..<10000 {
        precondition(testMyCollection(myCollection) == "XXXXXXXXXXXXXXX")
    }
}

doMyCollection()
doMyCollectionUnsafe()