Swift大型结构体Equatable一致性：==运算符类型检查耗时优化

针对SwiftUI大型结构体Equatable实现中类型检查耗时过长的问题，可以通过以下几种方式优化：

1. 拆分表达式并分步判断 #

将长链式的&&判断拆分为多个逻辑分组，用变量保存每组的判断结果，并通过guard提前返回，减少编译器一次性处理的表达式复杂度：

public static func == (lhs: ScrollableGraphicForecastView, rhs: ScrollableGraphicForecastView) -> Bool {
    // 基础标识与配置属性
    let baseMatch = lhs.viewId == rhs.viewId
        && lhs.nowHash == rhs.nowHash
        && lhs.canScrollAndFitAll == rhs.canScrollAndFitAll
        && lhs.colorScheme == rhs.colorScheme
        && lhs.fineHorizontalSizeClass == rhs.fineHorizontalSizeClass
        && lhs.aspectRatio == rhs.aspectRatio
    
    guard baseMatch else { return false }
    
    // 渲染相关属性
    let renderMatch = lhs.forecast == rhs.forecast
        && lhs.renderContent == rhs.renderContent
        && lhs.renderContext == rhs.renderContext
        && lhs.renderOptions == rhs.renderOptions
        && lhs.renderData == rhs.renderData
        && lhs.daysOutlookSource == rhs.daysOutlookSource
        && lhs.dataSettable == rhs.dataSettable
    
    guard renderMatch else { return false }
    
    // 滚动相关属性
    let scrollMatch = lhs.scrollStep == rhs.scrollStep
        && lhs.scrollStepCount == rhs.scrollStepCount
        && lhs.absoluteScrollOffset == rhs.absoluteScrollOffset
        && lhs.containerSize == rhs.containerSize
        && lhs.chartSize == rhs.chartSize
        && lhs.midScreenAbsoluteScrollOffset == rhs.midScreenAbsoluteScrollOffset
    
    guard scrollMatch else { return false }
    
    // 缩放状态属性
    let scaleMatch = lhs.scaleInProgress == rhs.scaleInProgress
        && lhs.scaleAnchor == rhs.scaleAnchor
        && lhs.scale == rhs.scale
        && lhs.scaleCoefficient == rhs.scaleCoefficient
        && lhs.lastScaleValue == rhs.lastScaleValue
        && lhs.visibleChartStartRelative == rhs.visibleChartStartRelative
        && lhs.stagger == rhs.stagger
    
    return scaleMatch
}

2. 显式标注复杂判断的结果类型 #

对于涉及泛型或自定义复杂类型的属性判断，显式标注结果为Bool，减少编译器的类型推导工作量：

let forecastMatch: Bool = lhs.forecast == rhs.forecast
let renderContextMatch: Bool = lhs.renderContext == rhs.renderContext

3. 拆分大型结构体为子结构体 #

将大型结构体按职责拆分为多个小型子结构体，各自实现Equatable。主结构体的相等判断仅需调用子结构体的==运算符，大幅降低编译器的类型检查压力：

// 拆分渲染配置为子结构体
struct RenderConfiguration: Equatable {
    var forecast: ForecastType
    var renderContent: ContentType
    var renderContext: ContextType
    var renderOptions: OptionsType
    var renderData: DataType
    var daysOutlookSource: SourceType
    var dataSettable: SettableType
}

// 拆分滚动状态为子结构体
struct ScrollState: Equatable {
    var scrollStep: CGFloat
    var scrollStepCount: Int
    var absoluteScrollOffset: CGFloat
    var containerSize: CGSize
    var chartSize: CGSize
    var midScreenAbsoluteScrollOffset: CGFloat
}

// 拆分缩放状态为子结构体
struct ScaleState: Equatable {
    var scaleInProgress: Bool
    var scaleAnchor: UnitPoint
    var scale: CGFloat
    var scaleCoefficient: CGFloat
    var lastScaleValue: CGFloat
    var visibleChartStartRelative: CGFloat
    var stagger: Bool
}

// 主结构体
struct ScrollableGraphicForecastView: Equatable {
    var viewId: String
    var nowHash: String
    var canScrollAndFitAll: Bool
    var colorScheme: ColorScheme
    var fineHorizontalSizeClass: UserInterfaceSizeClass?
    var aspectRatio: CGFloat
    var renderConfig: RenderConfiguration
    var scrollState: ScrollState
    var scaleState: ScaleState
    
    public static func == (lhs: Self, rhs: Self) -> Bool {
        return lhs.viewId == rhs.viewId
            && lhs.nowHash == rhs.nowHash
            && lhs.canScrollAndFitAll == rhs.canScrollAndFitAll
            && lhs.colorScheme == rhs.colorScheme
            && lhs.fineHorizontalSizeClass == rhs.fineHorizontalSizeClass
            && lhs.aspectRatio == rhs.aspectRatio
            && lhs.renderConfig == rhs.renderConfig
            && lhs.scrollState == rhs.scrollState
            && lhs.scaleState == rhs.scaleState
    }
}

这种拆分不仅优化了编译速度，同时提升了代码的可维护性和可读性。

内容的提问来源于stack exchange，提问作者Tomáš Kafka