Data+Hex.swift

extension Data {
  init?(hexString: String) {
    let count = hexString.count / 2
    var data = Data(capacity: count)
    var i = hexString.startIndex
    for _ in 0 ..< count {
      let j = hexString.index(after: i)
      if var byte = UInt8(hexString[i ... j], radix: 16) {
        data.append(&byte, count: 1)
      } else {
        return nil
      }
      i = hexString.index(after: j)
    }
    self = data
  }
}

embrace your inner Substring

import Foundation

extension Data {
    init?<Hex: StringProtocol>(hexString: Hex) {
        var hex = hexString[...]

        self.init(capacity: hex.count / 2)
        while !hex.isEmpty {
            guard
                let hi = hex.popFirst()?.hexDigitValue,
                let lo = hex.popFirst()?.hexDigitValue
            else { return nil }
            append(UInt8(hi << 4 | lo))
        }
    }
}

That works and shows me hexDigitValue which I should have used in the iterator approach. Is there any advantage to the Substring over the iterator? I imagine it just has an additional end index though I haven’t checked.

Also if we use iterator it can be made generic over collections of Characters so it should work on Strings, Substrings and arrays of characters. It could work on Sequences if we didn’t need the count upfront.

extension Data {
    init?<S>(hexString: S) where S : Collection, S.Element == Character {
        let count = hexString.count / 2
        var data = Data(capacity: count)
        var itr = hexString.makeIterator()
        for _ in 0 ..< count {
            guard let hi = itr.next()?.hexDigitValue,
                  let lo = itr.next()?.hexDigitValue else { return nil }
            data.append(UInt8(hi << 4 | lo))
        }
        self = data
    }
}

From my own timings, popping a substring is slower than using index.after(). Not sure how it compares to iterator: https://twitter.com/nicklockwood/status/1382142248247308292

Try using hexString.utf8.withContiguousStorageIfAvailable. You'll have to write your own hexDigitValue though.