swift的泛型协议为什么不用<T>语法

swift中的协议(protocol)采用的是“Associated Types”的方式来实现泛型功能的，通过associatedtype关键字来声明一个类型的占位符作为协议定义的一部分。swift的协议不支持下面的定义方式：

protocol GeneratorType {
    public mutating func next() -> Element?
}

而是应该使用这样的定义方式：

protocol GeneratorType {
    associatedtype Element
    public mutating func next() -> Self.Element?
}

在swift中，class、struct、enums都可以是用参数化类型来表达泛型的，只有在协议中需要使用associatedtype关键字来表达参数化类型。为什么协议不采用这样的语法形式呢？我查看了很多讨论，原因大概总结为一下两点：

采用语法的参数化方式的泛型其实定义了整个类型的家族，在概念上这对于一个可以具体实现的类型(class、struct、enums)是有意义的，比方说Array,Array。但对于协议来说，协议表达的含义是single的。你只会实现一次GeneratorType，而不会实现一个GeneratorType协议，接着又实现另外一个GeneratorType协议。
协议在swift中有两个目的，第一个目的是用来实现多继承(swift语言被设计为单继承的），第二个目的是强制实现者必须准守自己所指定的泛型约束。关键字associatedtype是用来实现第二个目的的。在GeneratorType中由associatedtype指定的Element，是用来控制next()方法的返回类型的。而不是用来指定GeneratorType的类型的。

我们可以用一个例子进一步解释一下第二个观点

public protocol Automobile {
  associatedtype FuelType
  associatedtype ExhaustType
  func drive(fuel: FuelType) -> ExhaustType
}
public protocol Fuel {
  associatedtype ExhaustType
  func consume() -> ExhaustType
}
public protocol Exhaust {
  init()
  func emit()
}

我们定义了三个协议，机动车(Automobile)、燃料(Fuel)、尾气(Exhaust),因为Automobile涉及到燃料和尾气所以它内定义了两个关联类型FuelType和ExhaustType，
Fuel燃烧后会排放Exhaust，所以在Fuel内定义了关联类型ExhaustType。而Exhaust不需要关联类型。

接下来我们做三个具体的实现：

public struct UnleadedGasoline: Fuel {
  public func consume() -> E {
    print("...consuming unleaded gas...")
    return E()
  }
}
public struct CleanExhaust: Exhaust {
  public init() {}
  public func emit() {
  print("...this is some clean exhaust...")
  }
}
public class Car: Automobile {
  public func drive(fuel: F) -> E {
      return fuel.consume()
  }
}

我们重点关注Car的定义，我们之所以在Car的定义中同时使用了两种占位符F和E，就是为了给这两个占位符所代表的类型增加约束，因为我们使用一种燃料，必然要排放这种燃料所对应的尾气。于是我们这样使用Car

var car = Car, CleanExhaust>()
car.drive(UnleadedGasoline()).emit()

Car, CleanExhaust>在这里成为了一种具体的类型，从Car的意义上来看，燃料成为Car类型的一部分是无可厚非的，因为汽车本身就是可以用燃料进行类型区分的吗。

但尾气成为Car类型的一部分真的有意义吗？从现实生活当中看，这是没有意义，因为尾气一定尊属与某种燃料类型，用燃料做为类型的一部分已经足够了。尾气成为类型的一部分问题出在了，我们需要在技术上进行泛型约束。

我们现在来调整一下Car的实现部分。

public class Car: Automobile {
  public func drive(fuel: F) -> F.ExhaustType {
      return fuel.consume()
  }
}

在新的定义中，我们把E从参数中去掉，而是换作为drive方法的返回值。这样的效果是非常明显的，因为E的存在就是为了泛型约束，让其作为返回值是完全可以实现这种约束。而且有没有使其成为类型一部分的副作用。我们现在就可以这样获得一个Car的实例了。

var fusion = Car>()

swift的协议使用associatedtype来解决类型约束问题，如果大家还有更好的理由，欢迎大家补充。

本文内容参考很多，列几个主要的：

https://schani.wordpress.com/2014/06/11/associated-types-considered-weird/

https://groups.google.com/forum/#!topic/swift-language/3PtydRXR0ao

https://dzone.com/articles/swift-generic-protocols-what-are-they-good-for

swift的泛型协议为什么不用语法

你可能感兴趣的:(swift的泛型协议为什么不用语法)