Swift中如何确保返回的Result表达式类型与预期类型一致？

问题描述 #

我正在Swift中试验Result<Int, Error>这类结果类型，想要对玩家的Int类型资金执行数值加法操作并进行验证（例如：Add 1 coin to balance，同时返回验证错误）。使用Result类型根据验证情况返回成功或失败结果，但Swift编译器提示无法将返回表达式类型转换为预期类型。

编译器错误出现在return Transaction.make(.credit(balance: balance, withAmount: amount))行，提示：

Cannot convert return expression of type '(Transaction) -> Result<Int, FundingError>' to return type 'Result<Int, FundingError>'

相关测试代码：

public enum FundingError: Error {
    case notEnough(funds: Int)
    case mustBePositive
}

public struct Funds {
    static func credit(balance: Int, with amount: Int) -> Result<Int, FundingError> {
        return Transaction.make(.credit(balance: balance, withAmount: amount))
    }
    // debit is omitted for now
}

private enum Transaction {
    case credit(balance: Int, withAmount: Int)
    case debit(balance: Int, byAmount: Int)
    
    func make(t: Transaction) -> Result<Int, FundingError> {
        do {
            let _ = try Transaction.validate(t)
                        
            switch self {
            case .credit(let balance, let amount):
                var balance = balance
                balance += amount
                return .success(balance)
                            
            case .debit(let balance, let amount):
                  // debit code removed for now
                return .success(balance)
            }
        }
        catch let err {
            return .failure(err as! FundingError)
        }
    }
}

// 验证器代码
extension Transaction {
    static func validate(_ transaction: Transaction) throws {
        switch (transaction) {
        case .credit(_, let amount):
            guard amount > 0 else {
                throw FundingError.mustBePositive
            }
        // debit case would go here
        }      
    }
}

错误原因 #

• 核心问题：实例方法被当作静态方法调用
  Transaction的make是实例方法（用func定义，无static修饰），但你在Funds.credit里直接通过Transaction.make(...)调用，这相当于获取了该实例方法的函数引用（Swift中实例方法可被视为接收实例为第一个参数的函数），因此返回类型是(Transaction) -> Result<Int, FundingError>，而非预期的Result<Int, FundingError>，直接导致类型不匹配。
• 额外逻辑问题：make方法接收了t参数，但内部处理的是self（当前Transaction实例），而非传入的t，会导致验证和操作的对象不一致。

解决方法 #

将make改为静态方法，并修正内部逻辑使用传入的Transaction实例，同时优化错误处理逻辑：

修正后的代码：

public enum FundingError: Error {
    case notEnough(funds: Int)
    case mustBePositive
}

public struct Funds {
    static func credit(balance: Int, with amount: Int) -> Result<Int, FundingError> {
        return Transaction.make(.credit(balance: balance, withAmount: amount))
    }
    // debit is omitted for now
}

private enum Transaction {
    case credit(balance: Int, withAmount: Int)
    case debit(balance: Int, byAmount: Int)
    
    // 改为静态方法，接收Transaction实例作为参数
    static func make(_ transaction: Transaction) -> Result<Int, FundingError> {
        do {
            try Transaction.validate(transaction)
            
            switch transaction {
            case .credit(let balance, let amount):
                return .success(balance + amount) // 简化余额计算逻辑
                            
            case .debit(let balance, let amount):
                  // debit code removed for now
                return .success(balance - amount) // 后续完善debit逻辑
            }
        } catch let err as FundingError {
            return .failure(err) // 避免强制转换，直接捕获对应错误类型
        } catch {
            // 处理其他意外错误（可选）
            return .failure(.mustBePositive) // 或自定义默认错误
        }
    }
}

extension Transaction {
    static func validate(_ transaction: Transaction) throws {
        switch transaction {
        case .credit(_, let amount):
            guard amount > 0 else {
                throw FundingError.mustBePositive
            }
        case .debit(let balance, let amount):
            guard amount > 0 else {
                throw FundingError.mustBePositive
            }
            guard balance >= amount else {
                throw FundingError.notEnough(funds: balance)
            }
        }      
    }
}

关键修改点 #

1. 给make方法添加static修饰，使其成为静态方法，确保Transaction.make(...)直接返回Result类型。
2. 在make方法内部，使用传入的transaction参数进行switch判断，而非self，保证验证和操作的是同一个交易实例。
3. 优化错误捕获：直接捕获FundingError类型，避免强制转换as!带来的崩溃风险。
4. 简化余额计算逻辑，无需额外创建变量。

内容的提问来源于stack exchange，提问作者zardon