'withUnsafeBytes' is deprecated

[dan.hardkorr (Dan)]

Hey there,

I've been kicking my head with this one. Just hoping for some help:

func hexString(data: Data) -> String {
            return data.withUnsafeBytes { (bytes: UnsafePointer<UInt8>) -> String in
                let buffer = UnsafeBufferPointer(start: bytes, count: data.count)
                return buffer.map{String(format: "%02hhx", $0)}.reduce("", {$0 + $1})
            }
    }

the code above throws the following warning:

'withUnsafeBytes' is deprecated: use withUnsafeBytes<R>(_: (UnsafeRawBufferPointer) throws -> R) rethrows -> R instead

[David_Smith]

Change bytes: UnsafePointer<UInt8> to bytes: UnsafeRawBufferPointer, and then adjust the body of the closure accordingly. It should end up being less code in the end I think.

[Martin (Martin R)]

As @David_Smith said, the withUnsafeBytes() method passing a typed pointer to the closure has been deprecated in favor of a method which passes a raw pointer to the closure, see also

How to use Data.withUnsafeBytes in a well-defined manner?

Data has a method withUnsafeBytes(_:) which allows you to access its contents through a typed UnsafePointer<T>, where the type T is satisfied by the caller (there's also withUnsafeMutableBytes(_:) that gives you mutable access to the underlying data). However it's not documented exactly what we're allowed to substitute for the type T. Is the following fairly innocuous looking example well-defined? import Foundation let data = Data([0xFF]) let i = data.withUnsafeBytes { (ptr: UnsafePointer<Int…

You can also let the compiler infer the closure parameters automatically (and omit the return keyword for single-expression closures/functions):

func hexString(data: Data) -> String {
    data.withUnsafeBytes {
        $0.map{String(format: "%02hhx", $0)}.reduce("", { $0 + $1 })
    }
}

[dan.hardkorr (Dan)]

Thanks, martin, that worked like a charm!