我写了一个简单的fetch客户端来处理请求。代码如下：
申请

public protocol RequestParameter: Encodable {
  var queryItems: [URLQueryItem] { get }
}

public extension RequestParameter {
  var queryItems: [URLQueryItem] {
    var this = [URLQueryItem]()
    let mirror = Mirror(reflecting: self)
    for child in mirror.children {
      guard let label = child.label, let value = child.value as? CustomStringConvertible else {
        continue
      }
      this.append(.init(name: label, value: value.description))
    }
    return this
  }
}

extension Dictionary: RequestParameter where Key == String, Value: CustomStringConvertible & Encodable {
  public var queryItems: [URLQueryItem] {
    var this = [URLQueryItem]()
    for (key, value) in self {
      this.append(.init(name: key, value: value.description))
    }
    return this
  }
}

public protocol Request<Parameter, Response> {
  associatedtype Parameter: RequestParameter
  associatedtype Response: Decodable

  var method: HTTPMethod { get }
  var path: String { get }
  var parameter: Parameter? { get }
  var headers: HTTPHeaders? { get }
}

public extension Request {
  func build(_ urlString: String, encoder: JSONEncoder? = nil) -> URLRequest {
    var components = URLComponents(string: urlString)
    components?.path = path

    if method == .get {
      components?.queryItems = parameter?.queryItems
    }

    guard let url = components?.url else {
      fatalError("url can't be nil")
    }

    var urlRequest = URLRequest(url: url)
    urlRequest.httpMethod = method.rawValue

    if let headers {
      urlRequest.headers = headers
    }

    if method == .post, let parameter, let encoder {
      do {
        urlRequest.httpBody = try encoder.encode(parameter)
      } catch {
        fatalError("`parameter cannot be encoded`")
      }
    }

    return urlRequest
  }
}

客户端

public protocol Client {
  func send<RequestType: Request>(_ request: RequestType, encoder: JSONEncoder?, decoder: JSONDecoder) async throws -> RequestType.Response

  var urlString: String { get }

  static var shared: Self { get }
}

public extension Client {
  func send<RequestType: Request>(_ request: RequestType, encoder: JSONEncoder? = nil, decoder: JSONDecoder = .init()) async throws -> RequestType.Response {
    let (data, urlResponse) = try await URLSession.shared.data(for: request.build(urlString, encoder: encoder))
    guard let httpResponse = urlResponse as? HTTPURLResponse else {
      throw #InvalidResponse
    }
    guard 200 ... 299 ~= httpResponse.statusCode else {
      throw #NetworkFailure(httpResponse.statusCode)
    }
    return try decoder.decode(RequestType.Response.self, from: data)
  }
}

因此，一个简单而有效的网络请求代码看起来像这样：

struct FooRequest: Request {
  typealias Parameter = FooParameter
  typealias Response = Foo

  var method: HTTPMethod = .get
  var path: String = ""
  var parameter: FooParameter? = FooParameter()
  var headers: HTTPHeaders? = nil
}
struct FooParameter: RequestParameter {}
struct Foo: Decodable {}
struct FooClient: Client {
  var urlString: String = "fooURLString.com"

  static var shared: FooClient = Self()
}

let result = try await FooClient.shared.send(FooRequest())

但是有时候一个简单的GET请求可能不需要参数。为了避免重复代码var parameter: FooParameter? = nil或var parameter: BarParameter? = nil，我添加了一个NeverParameter类型：

public struct NeverParameter: RequestParameter {
  private init() {}
}

public extension Request where Parameter == NeverParameter {
  var parameter: Parameter? { nil }
}

这个时候，问题来了。我认为使用NeverParameter，请求应该是这样的：

struct FooRequest: Request {
  typealias Parameter = NeverParameter
  typealias Response = Foo

  var method: HTTPMethod = .get
  var path: String = ""
  var headers: HTTPHeaders? = nil
}

但实际上，注解掉typealias Parameter = NeverParameter仍然可以编译：

struct FooRequest: Request {
  // typealias Parameter = NeverParameter
  typealias Response = Foo

  var method: HTTPMethod = .get
  var path: String = ""
  var headers: HTTPHeaders? = nil
}

（lldb）po类型（的：参数）
Swift.Optional<Request.NeverParameter>
为什么编译器可以推断出参数的类型是NeverParameter？即使默认值nil只添加在NeverParameter的where子句下？再添加一个具有相同实现的NeverParameter1，Xcode最终抛出了一个错误。

public struct NeverParameter: RequestParameter {
  private init() {}
}

public extension Request where Parameter == NeverParameter {
  var parameter: Parameter? { nil }
}

public struct NeverParameter1: RequestParameter {
  private init() {}
}

public extension Request where Parameter == NeverParameter1 {
  var parameter: Parameter? { nil }
}

错误：
类型“FooRequest”不符合协议“Request”