不调用约束协议扩展中的函数实现

问题总结

我有一个通用的视图子类TintableView<T>: UIView，该子类实现TintStateComputing具有相同关联类型的协议T。TintStateComputing的约束扩展实现未调用；而是调用其不受限制的扩展实现。

该TintStateComputing协议具有一个功能computeTintState() -> T，它听起来像什么：检查本地状态属性，并返回的相应实例T。

我想写func computeTintState() -> Ton的扩展实现TintStateComputing，受的类型限制T。例如，使用一个ControlState枚举：

extension TintStateComputing where T == ControlState {
    func computeTintState() -> T {
        return self.isEnabled ? .enabled : T.default
    }
}

但是，为了完成协议的一致性，我认为我需要考虑的其他值T。因此，我还对进行了无限制的扩展TintStateComputing。总是调用此不受约束的扩展实现，而不是受约束的实现。

extension TintStateComputing {
    func computeTintState() -> T {
        return _tintState ?? T.default
    }
}

游乐场试验台

import UIKit

// MARK: - Types

public enum ControlState: Int {
    case normal, enabled, highlighted, selected, disabled
}

public protocol Defaultable {
    static var `default`: Self { get }
}

extension ControlState: Defaultable {
    public static let `default`: ControlState = .normal
}

// MARK: - TintStateComputing declaration

public protocol TintStateComputing {
    associatedtype TintState: Hashable & Defaultable
    func computeTintState() -> TintState
    var _tintState: TintState? { get }
    var isEnabled: Bool { get }
}

// MARK: - TintableView declaration

class TintableView<T: Hashable & Defaultable>: UIView, TintStateComputing {
    // `typealias TintState = T` is implictly supplied by compiler
    var _tintState: T?
    var isEnabled: Bool = true { didSet { _tintState = nil }}

    var tintState: T  {
        get {
            guard _tintState == nil else {
                return _tintState!
            }
            return computeTintState()
        }
        set {
            _tintState = newValue
        }
    }
}

// MARK: - Unconstrained TintStateComputing extension

extension TintStateComputing {
    func computeTintState() -> TintState {
        return _tintState ?? TintState.default
    }
}

// MARK: - Constrained TintStateComputing extension

extension TintStateComputing where TintState == ControlState {
    func computeTintState() -> TintState {
        return self.isEnabled ? .enabled : TintState.default
    }
}

// MARK: - Test Case

let a = TintableView<ControlState>()
a.isEnabled = true
print("Computed tint state: \(a.tintState);  should be .enabled") // .normal
print("finished")

解决方法

我今天早上意识到，由于（至少到目前为止）我真正想完成的工作是处理isEnabled: Bool视图上的标志，因此我可以遵循与Defaultable定义默认“启用”情况相同的模式。

public protocol Enableable {
    static var defaultEnabled: Self { get }
}

extension ControlState: Defaultable, Enableable {
    public static let `default`: ControlState = .normal
    public static let defaultEnabled: ControlState = .enabled
}

到那时，我真的可以消除该TintStateComputing协议了，并更新视图的tintState: T实现以直接考虑该标志。

var tintState: T  {
    get {
        guard _tintState == nil else { return _tintState! }
        return self.isEnabled ? T.defaultEnabled : T.default
    }
    set {
        _tintState = newValue
    }
}

它不像将实现放在受约束的扩展中那样笼统，但是现在可以使用。我认为，如果将来有带有多维着色状态类型的子类（例如，“启用” +“范围内”），我将可以通过进行寻址override。

struct CalendarState: Equatable, Hashable, Defaultable, Enableable  {
    let x: Int

    static let `default`: CalendarState = CalendarState(x: 0)
    static let defaultEnabled: CalendarState = CalendarState(x: 1)
}

class ControlTintableView: TintableView<ControlState> {}
class CalendarView: TintableView<CalendarState> {}

let a = ControlTintableView()
a.isEnabled = true
print("ControlTintableView computed tint state: \(a.tintState);  should be: .enabled") // .enabled

let b = CalendarView()
b.isEnabled = true
print("CalendarView computed tint state: \(b.tintState);  should be: CalendarState(x: 1)") // CalendarState(x: 1)