public protocol Error : Sendable { }

/// 聲明一個Int解析的Error
enum IntParsingError: Error {
  /// 超過長度
  case overflow
  /// 無法解析的字符
  case invalidInput(String)
  /// 其他錯誤類型
  case other
}

extension Int {
  init(validating input: String) throws {
      for item in input {
          guard let _ = item.toInt() else {
              throw IntParsingError.invalidInput(String(item))
          }
      }
      if let int = input.toInt() {
          self = int
      } else {
          throw IntParsingError.other
      }
  }
}
extension Character {
  func toInt() -> Int? {
      let str = String(self)
      if let int = Int(str) {
          return int
      }
      return nil
  }
}
extension String {
  public func toInt() -> Int? {
      if let num = NumberFormatter().number(from: self) {
          return num.intValue
      } else {
          return nil
      }
  }
}

let money: String = "100塊錢"
let a = try? Int(validating: money)

do {
  let price = try Int(validating: money)
  print(price)
} catch IntParsingError.invalidInput(let invalid) {
  print("Invalid character: '(invalid)'")
} catch IntParsingError.overflow {
  print("Overflow error")
} catch {
  print("Other error")
}

struct ParseError: Error {
  enum errorKind {
      case pathError
      case InvalidFormat
      case other
  }
  let file: String
  let method: String
  let line: Int
  let type: errorKind
}
func parse(_ source: String) throws -> Int {
  throw ParseError.init(
      file: "Users/Mccc/Log/Vip.swift",
      method: "LogMethod",
      line: 12,
      type: .InvalidFormat)
}

do {
  let info = try parse("123")
  print(info)
} catch let e as ParseError {
  print("Parsing error: (e.type) [(e.file) : (e.method) : (e.line)]")
} catch {
  print("Other error: (error)")
}

@frozen public struct Array<Element> {
  @inlinable public func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
}

enum NegativeError: Error {
  /// 負(fù)數(shù)
  case negative
}
let nums = [1, 2, 3, 4, -5]
do {
  let strNums = try nums.map { (num) throws -> String in
      if num >= 0 {
          return String(num)
      } else {
          throw NegativeError.negative
      }
  }
  print(strNums) // Will no print
} catch let err {
  print(err)
}

func methodThrows(num: Int) throws {
  if num < 0 {
      print("Throwing!")
      throw error
  }
  print("Executed!")
}
func methodRethrows(num: Int, f: (Int) throws -> ()) rethrows {
  try f(num)
}
do {
  try methodRethrows(num: 1, f: methodThrows)
} catch _ {
}

fatalError("something wrong")

struct Car { }

extension Car {
  enum TroubleError: Error {
      /// 癱瘓：車輛無法行駛
      case paralysis
      /// 油量不足
      case lackOilWarning
      /// 超員：減員之后可以繼續(xù)行駛。
      case overcrowding(Int)
  }
}

public protocol LocalizedError : Error {
  /// 提供描述錯誤的本地化消息
  var errorDescription: String? { get }
  /// 發(fā)生錯誤的原因
  var failureReason: String? { get }
  /// 如何恢復(fù)的提示
  var recoverySuggestion: String? { get }
  /// 其他幫助文本
  var helpAnchor: String? { get }
}

extension Car.TroubleError: LocalizedError {
  /// 提供描述錯誤的本地化消息
  var errorDescription: String? {
      switch self {
      case .paralysis:
          return NSLocalizedString("汽車已經(jīng)癱瘓，無法行駛", comment: "呼叫拖車維修")
      case .lackOilWarning:
          return NSLocalizedString("油量不足", comment: "清前往加油")
      case .overcrowding(let count):
          return NSLocalizedString("乘客超載，超載人數(shù)：(count)", comment: "超員部分乘客下車")
      }
  }
  /// 發(fā)生錯誤的原因
  var failureReason: String? {
      switch self {
      case .paralysis:
          return "汽車已經(jīng)癱瘓，無法行駛"
      case .lackOilWarning:
          return "油量不足"
      case .overcrowding(let count):
          return "乘客超載，超載人數(shù)：(count)"
      }
  }
  /// 如何恢復(fù)的提示
  var recoverySuggestion: String? {
      switch self {
      case .paralysis:
          return "尋找緊急修車方法"
      case .lackOilWarning:
          return "去加油站加油"
      case .overcrowding(let count):
          return "把超載的人數(shù)(count)人趕下車"
      }
  }
  /// 其他幫助文本
  var helpAnchor: String? {
      switch self {
      case .paralysis:
          return "緊急修車電話：0632-2347232"
      case .lackOilWarning:
          return "地圖搜索加油站"
      case .overcrowding(_):
          return "禁止超載"
      }
  }
}

// 初始化一個NSError
let errorOC = NSError.init(domain: "intsig.qxb", code: 1000, userInfo: nil)
// 轉(zhuǎn)換為Error
let swiftError = errorOC as Error
print(swiftError)
print(swiftError.localizedDescription)
// 轉(zhuǎn)換為NSError
let error = swiftError as NSError

0 libswiftCore.dylib __swift_stdlib_bridgeErrorToNSError + 40
1 projectName loadDataDidFailed (文件名.swift:69)
...
...

public protocol CustomNSError : Error {
  /// The domain of the error.
  static var errorDomain: String { get }
  /// The error code within the given domain.
  var errorCode: Int { get }
  /// The user-info dictionary.
  var errorUserInfo: [String : Any] { get }
}

extension Car.TroubleError: CustomNSError {
  static var errorDomain: String {
      return "Domain"
  }
  var errorCode: Int {
      switch self {
      case .paralysis:
          return 1000
      case .lackOilWarning:
          return 1001
      case .overcrowding(_):
          return 1002
      }
  }
  var errorUserInfo: [String : Any] {
      return [:]
  }
}

extension Car.TroubleError {
  func toNSError() -> NSError {
      NSError.init(domain: Car.TroubleError.errorDomain, code: errorCode, userInfo: errorUserInfo)
  }
}

extension Car.TroubleError: RecoverableError {
  /// 在用戶請求時執(zhí)行恢復(fù)來恢復(fù)的錯誤。這主要在使用 AppKit 的 macOS應(yīng)用 中使用.
  func attemptRecovery(optionIndex recoveryOptionIndex: Int) -> Bool {
      if recoveryOptionIndex == 0 { // 呼叫緊急車輛救援
          return false
      } else if recoveryOptionIndex == 1 { // 前往加油站加油
          return true
      } else if recoveryOptionIndex == 2 { // 處理超載情況
          return true
      }
      fatalError("something wrong")
  }
  /// 提供提供給用戶的一組可能的恢復(fù)選項
  var recoveryOptions: [String] {
      return ["呼叫緊急車輛救援", "前往加油站加油", "處理超載情況"]
  }
}

public enum KingfisherError: Error {
  // 表示網(wǎng)絡(luò)請求階段的錯誤原因
  case requestError(reason: RequestErrorReason)
  // 表示網(wǎng)絡(luò)響應(yīng)階段的錯誤原因
  case responseError(reason: ResponseErrorReason)
  // 表示 Kingfisher 緩存系統(tǒng)中的錯誤
  case cacheError(reason: CacheErrorReason)
  // 表示圖像處理階段的錯誤原因
  case processorError(reason: ProcessorErrorReason)
  // 表示在視圖相關(guān)類中設(shè)置圖像時出現(xiàn)錯誤的原因
  case imageSettingError(reason: ImageSettingErrorReason)
}

public enum KingfisherError: Error {
  public enum RequestErrorReason {
      case emptyRequest
      case invalidURL(request: URLRequest)
      case taskCancelled(task: SessionDataTask, token: SessionDataTask.CancelToken)
  }
}

let reason = KingfisherError.RequestErrorReason.emptyRequest

public enum KingfisherError: Error {
  public enum ResponseErrorReason {
      case invalidURLResponse(response: URLResponse)
      case invalidHTTPStatusCode(response: HTTPURLResponse)
      case URLSessionError(error: Error)
      case dataModifyingFailed(task: SessionDataTask)
      case noURLResponse(task: SessionDataTask)
  }
}

public enum KingfisherError: Error {
  public enum CacheErrorReason {
      case fileEnumeratorCreationFailed(url: URL)
      case invalidFileEnumeratorContent(url: URL)
      case invalidURLResource(error: Error, key: String, url: URL)
      case cannotLoadDataFromDisk(url: URL, error: Error)
      case cannotCreateDirectory(path: String, error: Error)
      case imageNotExisting(key: String)
      case cannotConvertToData(object: Any, error: Error)
      case cannotSerializeImage(image: KFCrossPlatformImage?, original: Data?, serializer: CacheSerializer)
      case cannotCreateCacheFile(fileURL: URL, key: String, data: Data, error: Error)
      case cannotSetCacheFileAttribute(filePath: String, attributes: [FileAttributeKey : Any], error: Error)
  }
}

public enum KingfisherError: Error {
  public enum ProcessorErrorReason {
      case processingFailed(processor: ImageProcessor, item: ImageProcessItem)
  }
}

public enum KingfisherError: Error {
  public enum ImageSettingErrorReason {
      case emptySource
      case notCurrentSourceTask(result: RetrieveImageResult?, error: Error?, source: Source)
      case dataProviderError(provider: ImageDataProvider, error: Error)
      case alternativeSourcesExhausted([PropagationError])
  }
}

public var isTaskCancelled: Bool {
  if case .requestError(reason: .taskCancelled) = self {
      return true
  }
  return false
}

public func isInvalidResponseStatusCode(_ code: Int) -> Bool {
  if case .responseError(reason: .invalidHTTPStatusCode(let response)) = self {
      return response.statusCode == code
  }
  return false
}

public var isInvalidResponseStatusCode: Bool {
  if case .responseError(reason: .invalidHTTPStatusCode) = self {
      return true
  }
  return false
}

public var isNotCurrentTask: Bool {
  if case .imageSettingError(reason: .notCurrentSourceTask(_, _, _)) = self {
      return true
  }
  return false
}

extension KingfisherError: LocalizedError {    
  public var errorDescription: String? {
      switch self {
      case .requestError(let reason): return reason.errorDescription
      case .responseError(let reason): return reason.errorDescription
      case .cacheError(let reason): return reason.errorDescription
      case .processorError(let reason): return reason.errorDescription
      case .imageSettingError(let reason): return reason.errorDescription
      }
  }
}
extension KingfisherError: CustomNSError {
  public var errorCode: Int {
      switch self {
      case .requestError(let reason): return reason.errorCode
      case .responseError(let reason): return reason.errorCode
      case .cacheError(let reason): return reason.errorCode
      case .processorError(let reason): return reason.errorCode
      case .imageSettingError(let reason): return reason.errorCode
      }
  }
}

extension KingfisherError.RequestErrorReason {
  var errorDescription: String? {
      switch self {
      case .emptyRequest:
          return "The request is empty or `nil`."
      case .invalidURL(let request):
          return "The request contains an invalid or empty URL. Request: (request)."
      case .taskCancelled(let task, let token):
          return "The session task was cancelled. Task: (task), cancel token: (token)."
      }
  }
  var errorCode: Int {
      switch self {
      case .emptyRequest: return 1001
      case .invalidURL: return 1002
      case .taskCancelled: return 1003
      }
  }
}
extension KingfisherError.ResponseErrorReason {
  var errorDescription: String? {
      switch self {
      case .invalidURLResponse(let response):
          return "The URL response is invalid: (response)"
      case .invalidHTTPStatusCode(let response):
          return "The HTTP status code in response is invalid. Code: (response.statusCode), response: (response)."
      case .URLSessionError(let error):
          return "A URL session error happened. The underlying error: (error)"
      case .dataModifyingFailed(let task):
          return "The data modifying delegate returned `nil` for the downloaded data. Task: (task)."
      case .noURLResponse(let task):
          return "No URL response received. Task: (task),"
      }
  }
  var errorCode: Int {
      switch self {
      case .invalidURLResponse: return 2001
      case .invalidHTTPStatusCode: return 2002
      case .URLSessionError: return 2003
      case .dataModifyingFailed: return 2004
      case .noURLResponse: return 2005
      }
  }
}
extension KingfisherError.CacheErrorReason {
  var errorDescription: String? {
      switch self {
      case .fileEnumeratorCreationFailed(let url):
          return "Cannot create file enumerator for URL: (url)."
      case .invalidFileEnumeratorContent(let url):
          return "Cannot get contents from the file enumerator at URL: (url)."
      case .invalidURLResource(let error, let key, let url):
          return "Cannot get URL resource values or data for the given URL: (url). " +
                  "Cache key: (key). Underlying error: (error)"
      case .cannotLoadDataFromDisk(let url, let error):
          return "Cannot load data from disk at URL: (url). Underlying error: (error)"
      case .cannotCreateDirectory(let path, let error):
          return "Cannot create directory at given path: Path: (path). Underlying error: (error)"
      case .imageNotExisting(let key):
          return "The image is not in cache, but you requires it should only be " +
                  "from cache by enabling the `.onlyFromCache` option. Key: (key)."
      case .cannotConvertToData(let object, let error):
          return "Cannot convert the input object to a `Data` object when storing it to disk cache. " +
                  "Object: (object). Underlying error: (error)"
      case .cannotSerializeImage(let image, let originalData, let serializer):
          return "Cannot serialize an image due to the cache serializer returning `nil`. " +
                  "Image: (String(describing:image)), original data: (String(describing: originalData)), " +
                  "serializer: (serializer)."
      case .cannotCreateCacheFile(let fileURL, let key, let data, let error):
          return "Cannot create cache file at url: (fileURL), key: (key), data length: (data.count). " +
                  "Underlying foundation error: (error)."
      case .cannotSetCacheFileAttribute(let filePath, let attributes, let error):
          return "Cannot set file attribute for the cache file at path: (filePath), attributes: (attributes)." +
                  "Underlying foundation error: (error)."
      }
  }
  var errorCode: Int {
      switch self {
      case .fileEnumeratorCreationFailed: return 3001
      case .invalidFileEnumeratorContent: return 3002
      case .invalidURLResource: return 3003
      case .cannotLoadDataFromDisk: return 3004
      case .cannotCreateDirectory: return 3005
      case .imageNotExisting: return 3006
      case .cannotConvertToData: return 3007
      case .cannotSerializeImage: return 3008
      case .cannotCreateCacheFile: return 3009
      case .cannotSetCacheFileAttribute: return 3010
      }
  }
}
extension KingfisherError.ProcessorErrorReason {
  var errorDescription: String? {
      switch self {
      case .processingFailed(let processor, let item):
          return "Processing image failed. Processor: (processor). Processing item: (item)."
      }
  }
  var errorCode: Int {
      switch self {
      case .processingFailed: return 4001
      }
  }
}
extension KingfisherError.ImageSettingErrorReason {
  var errorDescription: String? {
      switch self {
      case .emptySource:
          return "The input resource is empty."
      case .notCurrentSourceTask(let result, let error, let resource):
          if let result = result {
              return "Retrieving resource succeeded, but this source is " +
                      "not the one currently expected. Result: (result). Resource: (resource)."
          } else if let error = error {
              return "Retrieving resource failed, and this resource is " +
                      "not the one currently expected. Error: (error). Resource: (resource)."
          } else {
              return nil
          }
      case .dataProviderError(let provider, let error):
          return "Image data provider fails to provide data. Provider: (provider), error: (error)"
      case .alternativeSourcesExhausted(let errors):
          return "Image setting from alternaive sources failed: (errors)"
      }
  }
  var errorCode: Int {
      switch self {
      case .emptySource: return 5001
      case .notCurrentSourceTask: return 5002
      case .dataProviderError: return 5003
      case .alternativeSourcesExhausted: return 5004
      }
  }
}