Как Swift ReferenceWritableKeyPath работает с необязательным свойством?

Вы (Мэтт), вероятно, уже знаете хотя бы часть этого, но вот некоторые факты для других читателей:

• Swift определяет типы для одного целого оператора за раз, но не для нескольких операторов.

• Swift позволяет при выводе типа автоматически преобразовывать объект типа T в тип Optional<T>, если это необходимо для проверки типа оператора.

• Swift также позволяет вывод типа автоматически продвигать замыкание типа (A) -> B на тип (A) -> B?. Другими словами, это компилирует:

  let a: (Data) -> UIImage? = { UIImage(data: $0) }
  let b: (Data) -> UIImage?? = a
  

  Для меня это стало неожиданностью. Я обнаружил это, исследуя вашу проблему.

Теперь давайте рассмотрим использование assign:

let p0 = Just(Data())
    .compactMap { UIImage(data: $0) }
    .receive(on: DispatchQueue.main)
    .assign(to: \.image, on: self.iv)

Swift проверяет тип этого оператора одновременно. Поскольку тип \UIImageView.image Value - UIImage?, а тип self.iv - UIImageView!, Swift должен сделать две «автоматические» вещи, чтобы выполнить проверку типа этого оператора:

• Он должен продвигать закрытие { UIImage(data: $0) } от типа (Data) -> UIImage? к типу (Data) -> UIImage??, чтобы compactMap мог отделить один уровень Optional и сделать тип Output UIImage?.

• Он должен неявно разворачивать iv, потому что Optional<UIImage> не имеет свойства с именем image, но UIImage имеет.

Эти два действия позволяют Swift успешно проверять тип оператора.

Теперь предположим, что мы разбили его на три утверждения:

let p1 = Just(Data())
    .compactMap { UIImage(data: $0) }
    .receive(on: DispatchQueue.main)
let a1 = Subscribers.Assign(object: self.iv, keyPath: \.image)
p1.subscribe(a1)

Swift сначала проверяет тип оператора let p1. Ему не нужно продвигать тип закрытия, поэтому он может вывести Output тип UIImage.

Затем Swift проверяет тип оператора let a1. Он должен неявно разворачиваться iv, но Optional продвижение не требуется. Он выводит тип Input как UIImage?, потому что это тип Value ключевого пути.

Наконец, Swift пытается проверить тип оператора subscribe. Тип Output для p1 - UIImage, а тип Input для a1 - UIImage?. Они разные, поэтому Swift не может успешно проверить тип оператора. Swift не поддерживает Optional продвижение параметров универсального типа, таких как Input и Output. Так что это не компилируется.

Мы можем выполнить эту проверку типа, установив Output тип p1 равным UIImage?:

let p1: AnyPublisher<UIImage?, Never> = Just(Data())
    .compactMap { UIImage(data: $0) }
    .receive(on: DispatchQueue.main)
    .eraseToAnyPublisher()
let a1 = Subscribers.Assign(object: self.iv, keyPath: \.image)
p1.subscribe(a1)

Здесь мы заставляем Swift продвигать тип закрытия. Я использовал eraseToAnyPublisher, потому что в противном случае тип p1 слишком уродлив, чтобы описывать его по буквам.

Поскольку Subscribers.Assign.init является общедоступным, мы также можем использовать его напрямую, чтобы Swift определял все типы:

let p2 = Just(Data())
    .compactMap { UIImage(data: $0) }
    .receive(on: DispatchQueue.main)
    .subscribe(Subscribers.Assign(object: self.iv, keyPath: \.image))

Swift успешно проверяет это. По сути, это то же самое, что использовалось ранее .assign. Обратите внимание, что он подразумевает тип () для p2, потому что это то, что здесь возвращает .subscribe.

Теперь вернемся к назначению на основе пути:

class Thing {
    var iv: UIImageView! = UIImageView()

    func test() {
        let im = UIImage()
        let kp = \UIImageView.image
        self.iv[keyPath: kp] = im
    }
}

Это не компилируется с ошибкой value of optional type 'UIImage?' must be unwrapped to a value of type 'UIImage'. Я не знаю, почему Swift не может это скомпилировать. Он компилируется, если мы явно конвертируем im в UIImage?:

class Thing {
    var iv: UIImageView! = UIImageView()

    func test() {
        let im = UIImage()
        let kp = \UIImageView.image
        self.iv[keyPath: kp] = .some(im)
    }
}

Он также компилируется, если мы изменим тип iv на UIImageView? и опционально сделаем присвоение:

class Thing {
    var iv: UIImageView? = UIImageView()

    func test() {
        let im = UIImage()
        let kp = \UIImageView.image
        self.iv?[keyPath: kp] = im
    }
}

Но он не компилируется, если мы просто принудительно развернем неявно развернутый необязательный параметр:

class Thing {
    var iv: UIImageView! = UIImageView()

    func test() {
        let im = UIImage()
        let kp = \UIImageView.image
        self.iv![keyPath: kp] = im
    }
}

И он не компилируется, если мы просто опционально определили назначение:

class Thing {
    var iv: UIImageView! = UIImageView()

    func test() {
        let im = UIImage()
        let kp = \UIImageView.image
        self.iv?[keyPath: kp] = im
    }
}

Думаю, это может быть ошибка компилятора.