[读书日志]从零开始学习Chisel 第十一篇：Scala的类型参数化（灵敏硬件开辟 ...

8.Scala的类型参数化

8.1 var类型的字段

对于可重新赋值的字段，可以实验两个基本操纵，获取字段值或设置为一个新值。如果在类中界说了一个var类型的字段，那么编译器会把这个变量限制为private[this]，同时隐式地界说一个名为变量名的getter方法和一个名为变量名_=的setter方法。默认的getter方法返回变量的值，默认的setter方法接收外部传入的参数来直接赋值给变量。

1. scala> import scala.compiletime.uninitialized
3. scala> class A {
4.      | var aInt: Int = uninitialized
5.      | }
6. // defined class A

复制代码

注意，原书中使用下划线赋初值的方式在Scala3中被废除，推荐使用如许的方式赋初值。
外部仍旧可以读取和修改该字段，但编译器自动将其转换为对setter和getter的调用。

1. scala> class A {
2.      | private var a: Int = uninitialized
3.      | def originalValue: Int = a
4.      | def originalValue_=(x:Int) = a = x
5.      | def tenfoldValue: Int = a * 10
6.      | def tenfoldValue_= (x: Int) = a = x / 10
7.      | }
8. // defined class A
10. scala> val a = new A
11. val a: A = A@23a0c7f3
13. scala> a.originalValue = 1
15. scala> a.originalValue
16. val res32: Int = 1
18. scala> a.tenfoldValue
19. val res33: Int = 10
21. scala> a.tenfoldValue = 1000
23. scala> a.tenfoldValue
24. val res34: Int = 1000
26. scala> a.originalValue
27. val res35: Int = 100

复制代码

在Scala3中不推荐使用private[this]，只必要使用private即可。我们可以自界说这两个方法来操纵
在这个例子中我们重写了这个变量的方法，这两组方法都会修改这个变量的值。
8.2 类型构造器

1. scala> abstract class A[T] {
2.      | val a: T
3.      | }
4. // defined class A

复制代码

这个例子中A被称为类型构造器，它接收一个类型参数来构造一个类型，也可以说A是一个泛型的类。

1. scala> def doesCompile(x: A[AnyRef]) = {}
2. def doesCompile(x: A[AnyRef]): Unit

复制代码

泛型的类和特质必要在方括号中加上类型参数，如果某个成员方法的参数也是泛型的，那么方法名后面也必须加上方括号和类型参数，字段则不必要。
8.3 型变注解

像A[T]如许的类型构造器，它们的类型参数可以是协变的，逆变的或者不变的。这被称为类型参数的型变。A[+T]表现类A在类型参数T上是协变的，A[-T]表现逆变，如果没有就是不变的，+和-被称为型变注解。

如果类型Sub是类型Super的子类，那么协变表现Tmep[Sub]也是Temp[Super]的子类型，逆变表现Temp[Sub]是Temp[Super]的超类，不变则表现这两个是两种没有任何关系的不同类型。
8.4 查抄型变注解

标志了型变注解的类型参数不能随便使用，类型系统设计要满足里氏更换原则，即在任何必要类型为T的对象的地方，都能用T的子类的对象更换。
假设类型T是类型S的超类，如果类型参数是协变的，导致A[T]也是A[S]的超类，那么val a : A[T]= new A[S]就合法。此时，如果类A内部的某个方法funcA的入参的类型也是这个协变类型参数，那么方法调用a.funcA(b:T)就会出错，由于a现实指向的是一个子类对象，子类对象的方法funcA接收的入参的类型是S，而子类S不能指向超类T，以是传入的b不能被接收。但是a的类型是A[T]又隐式地告诉使用者，可以传入类型是T的参数，这就产生了矛盾。相反，funca的返回类型是协变类型参数就没有题目，由于子类对象的funcA的返回值的类型虽然是S，但是能被T类型的变量接收，即val c : T = a.funcA()合法。a的类型A[T]隐式地告诉使用者应该用T类型的变量接收返回值，虽然现实返回的值是S类型，但是子类型多态答应如许做。

   要包管不出错，生产者产生的值的类型应该是子类，消费者接收的值的类型应该是超类（接收者本来只希望使用超类的成员，但是现实给出的子类统统都具备，接收者也不会去使用多出来的成员，以是子类型多态才精确）。
  基于此，方法的入参的类型应该是逆变类型参数，逆变使得val a : A[S]= newA[T]合法，也就是现实引用的对象的方法想要一个T类型的参数，但传入了子类型S的值，符合里氏更换原则。同理，方法的返回类型应该是协变的。
既然类型参数的使用有限制，那么就应该有一条规则来判断该使用什么类型参数。 Scala 的编译器把类或特质中任何出现类型参数的地方都当作一个"点"，点有协变点、逆变点和不变点之分，以声明类型参数的类和特质作为顶层开始，渐渐往内层深入，对这些点进行归类。
在顶层的点都是协变点，例如，顶层的方法的返回类型就在协变点。默认情况下，在更深一层的嵌套的点与在包含嵌套的外一层的点被归为一类。
该规则有一些例外：
①方法的值参数所在的点会根据方法外的点进行一次翻转，也就是把协变点翻转成逆变点、逆变点翻转成协变点、不变点仍旧保持不变；
②方法的类型参数（即方法名后面的方括号）也会根据方法外的点进行一次翻转；
③如果类型也是一个类型构造器，比如以C[T]为类型，那么，当 t 有"-“注解时就根据外层进行翻转，有”+"注解时就保持与外层一致，否则就变成不变点。
协变点只能用"+“注解类型参数，逆变点只能用”-"注解类型参数。没有型变注解的类型参数可以用在任何点，也是唯一能用在不变点的类型参数。以是对于类型Q[+U,-T,V]而言，U处在协变点，T处在逆变点，而V处在不变点。以如下例子为例进行解释：

1. scala> abstract class Cat[-T, +U] {
2.      |   def meow[W-](volume: T-, listener: Cat[U+, T-]-): Cat[Cat[U+, T-]-, U+]+
3.      | }
4. // defined class Cat

复制代码

这个例子中的正号表现协变点，负号表现逆变点。首先，Cat类声明白类型参数，以是它是顶层。方法meow的返回值属于顶层的点，以是返回类型的最右边是正号，表现协变点。由于方法的返回类型也是类型构造器Cat，而且第一个类型参数是逆变的，以是这里相对协变翻转成了逆变，而第二个类型参数是协变的，以是保持协变属性不变。继承往里归类，返回类型嵌套的 Cat 处在逆变点，以是第一个类型参数的位置相对逆变翻转成协变，第二个类型参数的位置保持逆变属性不变。两个值参数volume和listener都相对协变翻转成了逆变，并转成了逆变。且listener的类型是Cat，以是和返回类型嵌套的Cat一样。方法的类型参数W也相对协变翻虽然型变注解的查抄很复杂，但这些工作都被编译器自动完成了。编译器的查抄方法也很直接，就是检察顶层声明的类型参数是否出如今精确的位置。比如，上例中，T都出如今逆变点，U都出如今协变点，W是什么并不关心。
8.5 类型构造器的继承关系

由于类型构造器必要根据类型参数来确定终极的类型，以是在判断多个类型构造器之间的继承关系时，必须依赖类型参数。对于只含单个类型参数的类型构造器而言，继承关系很好判断，只必要看型变注解是协变、逆变还是不变。当类型参数不止一个时，该怎样判断呢？尤其是当函数的参数是一个函数时，更必要确定一个函数的子类型是什么样的函数。以常用的单参数函数为例，其特质Function1的部门界说如下：

1. scala> trait Function1[-S, +T] {
2.      | def apply(x: S): T
3.      | }
4. // defined trait Function1

复制代码

类型参数 S 代表函数的入参的类型，应该是逆变的。类型参数 T 代表函数返回值的类型，以是是协变的。

假设类A是类a的超类，类B是类b的超类，而且界说了一个函数的类型为Function1[a,B]，那么，这个函数的子类型应该是Function1[A,b]。解释如下：假设在必要类型为Function1[a,B]的函数的地方，现实用类型为Functionl[A,b]的函数代替了。那么，本来会给函数传入a类型的参数，但现实函数必要A类型的参数，由于类A是类a的超类，这符合里氏更换原则；本来会用类型为B的变量接收函数的返回值，但现实函数返回了b类型的值，由于类B是类b的超类，这也符合里氏更换原则。综上所述，用Function1[A,b]代替Function1[a,B]符合里氏更换原则，以是Function1[A,b]是Function1[a,B]的子类型。
因此，对于含有多个类型参数的类型构造器，要构造子类型，就是把逆变类型参数由子类更换成超类、把协变类型参数由超类更换成子类。
8.6 上界和下界

对于类型构造器A[+T]，倘若没有别的本领，很显然它的方法的参数不能泛化，由于协变的类型参数不能用作函数的入参类型。如果要泛化参数，必须借助额外的类型参数，那么这个类型参数该怎么界说呢？由于可能存在val x : A[超类]= new A[子类]如许的界说，导致方法的入参类型会是T的超类，以是，额外的类型参数必须是T的超类。Scala 提供了一个语法——下界，其形式为U >: T，表现U必须是T的超类，或者是T自己（一个类型既是它自身的超类，又是它自身的子类）。 通过使用下界标定一个新的类型参数，就可以在A[+T]如许的类型构造器中泛化方法的返回入参类型。例如：

1. scala> abstract class A[+T] {
2.      | def funcA[U >: T](x: U): U
3.      | }
4. // defined class A

复制代码

如今，编译器不会报错，下界的存在导致编译器预期参数x的类型是T的超类。现实运行时，会根据传入的现实入参确定U是什么。返回类型界说成了U，固然也可以是T，但是动态地根据U来调整类型显得更自然。
与下界对应的是上界，形式为U <: T，表现U必须是T的子类或自己。通过上界，可以在A[-T]如许的类型构造器中泛化方法的返回类型：

1. scala> abstract class A[-T] {
2.      | def funcA[U <: T](x: U): U
3.      | }
4. // defined class A

复制代码

8.7 方法的类型参数

除了类和特质可以声明类型参数，方法也可以带有类型参数。如果方法仅仅使用了包含它的类或特质已声明的类型参数，那就不消自己写出类型参数。如果出现了未声明的类型参数，则必须写在方法的类型参数中。方法的类型参数不能有型变注解。

1. scala> abstract class A[-T] {
2.      | def funcA(x: T): Unit
3.      | }
4. // defined class A
6. scala> abstract class A[-T] {
7.      | def funcA[U](x: T, y: U): Unit
8.      | }
9. // defined class A

复制代码

方法的类型参数不能与包含它的类和特质已声明的类型参数一致，否则会将它们覆盖。
8.8 对象私有数据

var类型的字段，其类型参数不能是协变的或逆变的。
如果var字段是对象私有的，即用private修饰，那么它只能在界说该类或特质时被访问。由于外部无法访问，因此可以忽略对型变注解的查抄。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。