UIContentSizeCategory不符合Comparable吗？

Question

It says in the type signature in UIKit that UIContentSizeCategory conforms to the Comparable protocol.

The type signature is:

public struct UIContentSizeCategory : RawRepresentable, Equatable, Hashable, Comparable {

    public init(rawValue: String)
}

So how come I get this nasty stack trace when I try to compare them?

po UIContentSizeCategory.small < UIContentSizeCategory.medium
error: warning: <EXPR>:12:9: warning: initialization of variable '$__lldb_error_result' was never used; consider replacing with assignment to '_' or removing it
    var $__lldb_error_result = __lldb_tmp_error
    ~~~~^~~~~~~~~~~~~~~~~~~~
    _

error: type 'UIContentSizeCategory' does not conform to protocol 'Comparable'
Swift.Comparable:144:24: note: multiple matching functions named '<=' with type '(UIContentSizeCategory, UIContentSizeCategory) -> Bool'
    public static func <=(lhs: Self, rhs: Self) -> Bool
                       ^

Swift.<=:10:13: note: candidate exactly matches
public func <=<T>(lhs: T, rhs: T) -> Bool where T : Comparable
            ^

Swift.<=:1:13: note: candidate exactly matches
public func <=<T>(lhs: T, rhs: T) -> Bool where T : _SwiftNewtypeWrapper, T.RawValue : Comparable
            ^

Swift.Comparable:151:24: note: multiple matching functions named '>=' with type '(UIContentSizeCategory, UIContentSizeCategory) -> Bool'
    public static func >=(lhs: Self, rhs: Self) -> Bool
                       ^

Swift.>=:12:13: note: candidate exactly matches
public func >=<T>(lhs: T, rhs: T) -> Bool where T : Comparable
            ^

Swift.>=:1:13: note: candidate exactly matches
public func >=<T>(lhs: T, rhs: T) -> Bool where T : _SwiftNewtypeWrapper, T.RawValue : Comparable
            ^

Swift.Comparable:158:24: note: multiple matching functions named '>' with type '(UIContentSizeCategory, UIContentSizeCategory) -> Bool'
    public static func >(lhs: Self, rhs: Self) -> Bool
                       ^

Swift.>:10:13: note: candidate exactly matches
public func ><T>(lhs: T, rhs: T) -> Bool where T : Comparable
            ^

Swift.>:1:13: note: candidate exactly matches
public func ><T>(lhs: T, rhs: T) -> Bool where T : _SwiftNewtypeWrapper, T.RawValue : Comparable
            ^

When I try to write my own extension to make UIContentSizeCategory conform to Comparable I get an error that it already conforms.

The goal here is to be able to check if a size is below a certain threshold and clip some text if it is. How do I fix this?

Answer 1

So, although the docs and signature claim conformance, it does not conform.

First time around I tried this:

extension UIContentSizeCategory: Comparable {
    static func <(lhs: UIContentSizeCategory, rhs: UIContentSizeCategory) -> Bool {
        return true
    }

    static func >(lhs: UIContentSizeCategory, rhs: UIContentSizeCategory) -> Bool {
        return true
    }
}

it threw an error because of the redundant conformance to Comparable

When I tried it without:

extension UIContentSizeCategory {
    static func <(lhs: UIContentSizeCategory, rhs: UIContentSizeCategory) -> Bool {
        return true
    }

    static func >(lhs: UIContentSizeCategory, rhs: UIContentSizeCategory) -> Bool {
        return true
    }
}

Magic! Works!

Full code (just in case you were wondering):

extension UIContentSizeCategory {
    static var orderedSizes: [UIContentSizeCategory] {
        return [.extraSmall,
                    .small,
                    .accessibilityMedium,
                    .medium,
                    .accessibilityLarge,
                    .large,
                    .accessibilityExtraLarge,
                    .extraLarge,
                    .accessibilityExtraExtraLarge,
                    .extraExtraLarge,
                    .extraExtraExtraLarge,
                    .accessibilityExtraExtraExtraLarge
            ]
    }

    static func < (lhs: UIContentSizeCategory, rhs: UIContentSizeCategory) -> Bool {
        var sizes = orderedSizes
        while sizes.contains(lhs) {
            sizes.removeFirst()
        }
        return sizes.contains(rhs)
    }

    static func > (lhs: UIContentSizeCategory, rhs: UIContentSizeCategory) -> Bool {
        var sizes = orderedSizes
        while sizes.contains(lhs) {
            sizes.removeLast()
        }
        return sizes.contains(rhs)
    }

    static func <= (lhs: UIContentSizeCategory, rhs: UIContentSizeCategory) -> Bool {
        guard lhs != rhs else { return true }

        return lhs < rhs
    }

    static func >= (lhs: UIContentSizeCategory, rhs: UIContentSizeCategory) -> Bool {
        guard lhs != rhs else { return true }

        return lhs > rhs
    }
}