[读书日记]从零开始学习Chisel 第十三篇：Scala的隐式参数与隐式转换（敏捷 ...

10. 隐式转换与隐式参数

假设编写了一个向量类MyVector，而且包含一些向量的根本操作。因为向量可以与标量做数乘运算，以是必要一个计算数乘的方法“*”，它应该吸取一个类型为根本值类的参数，在向量对象myVec调用该方法时，可以写成myVec * 2的情势。在数学中，反过来写2 * myVec也是可行的，但在程序中不行。操作符左边是调用对象，反过来写就表示Int对象2是方法的调用者，但是Int类中并没有这种方法。
为相识决上述题目，所有oop语言都会有相应的措施，C++采用友元，Scala接纳名为隐式转换的策略，把原来的Int类对象2转换类型，酿成MyVector类的对象，这样它就能使用数乘方法。隐式转换属于隐式定义的一种，它将程序员事先写好的定义，答应编译器隐式地插入这些定义来解决类型错误。
10.1 隐式定义的规则

隐式定义有如下约束规则：

• 标志规则：只有用关键字implicit标志的定义才能被编译器隐式使用，任何函数，变量或单例对象都可以被标志。此中，标志为隐式的变量和单例对象常用作隐式参数。隐式的函数常用于隐式转换。好比x + y由于x类型错误不能通过编译，编译器会将代码改成convert(x) + y，此中convert是某种可用的隐式转换。假如convert能把x改成某种支持+方法的对象，那么这段代码就可以通过类型查抄；
  
• 作用域规则：Scala编译器只会考虑当前作用域内的隐式定义，隐式定义在当前作用域必须是单个标志符，编译器不会展开成A.convert(x) + y的情势，有一个例外是编译器会在与隐式转换相干的源类型和目标类型的伴生对象中查找隐式定义，因此常在伴生对象中定义隐式转换，而不必要显式导入；
  
• 每次一个规则：编译器只会插入一个隐式定义，不会出现convert1(convert2(x)) + y这种嵌套的情势；
  
• 显式优先规则：假如显式定义能通过类型查抄，就不必进行隐式转换。
  

Scala只会在三个地方使用隐式定义：转换到一个预期的类型，转换某个选择吸取端，隐式参数。
10.2 隐式地转换到盼望类型

Scala编译器对于类型查抄比较严格，好比一个浮点数赋值给整数变量，人们大概渴望通过截断小数部门完成赋值，但是Scala默认情况下不答应这种丢失精度的转换。可以定义一个隐式转换来完成：

1. scala> import scala.language.implicitConversions
3. scala> implicit def doubleToInt(x: Double) : Int = x.toInt
4. def doubleToInt(x: Double): Int
6. scala> val i: Int = 1.5
7. val i: Int = 1
9. scala> val i: Int = doubleToInt(2.33)
10. val i: Int = 2

复制代码

10.3 隐式地转换吸取端

吸取端就是指调用方法或字段的对象，调用对象在非法的情况下，被隐式转换成了正当的对象，这是隐式转换最常用的地方。

1. scala> class MyInt(val i: Int)
2. // defined class MyInt
4. scala> 1.i
5. -- [E008] Not Found Error: ---------------------------------------------------------------------------------------------
6. 1 |1.i
7.   |^^^
8.   |value i is not a member of Int
9. 1 error found
11. scala> implicit def intToMy(x: Int): MyInt = new MyInt(x)
12. def intToMy(x: Int): MyInt
14. scala> 1.i
15. val res0: Int = 1

复制代码

在定义隐式转换前，Int类没有i字段，以是调用会报错，定义隐式转换后，用一个Int对象构造了一个新的MyInt对象，而MyInt对象就有字段i。1.i被编译器隐式展开成intToMy(1).i。
隐式转换因此经常用于模拟新的语法，好比Chisel中大量使用了隐式定义。
映射的键-值对语法键->值其实是一个对偶(键，值)，也是隐式转换起作用。
10.4 隐式类

隐式类是一个以关键字implicit开头的类，用于简化富包装类的编写。它不能是样例类，而且主构造方法有且仅有一个参数。此外，隐式类只能位于某个单例对象、类或特质中，不能单独出如今顶层。隐式类的特点是让编译器在相同层次下主动天生一个与类名相同的隐式转换，该转换担当一个与隐式类的主构造方法相同的参数，并用这个参数构造一个隐式类的实例对象来返回。
10.5 隐式参数

函数的末了一个参数列表可以用关键字implicit声明为隐式的，这样整个参数列表的参数都是隐式参数。留意，是整个参数列表，纵然括号中有多个参数，也只必要在开头写一个implicit，每个参数都是隐式的，不存在部门隐式部门显式。
当调用函数时，若缺省了隐式参数列表，则编译器实验插入相应的隐式定义。也可以显式给出参数，但是必须全部缺省大概全部写出，不能只写出一部门。
要让编译器隐式插入参数，就必须实现定义好符合预期类型的隐式变量，隐式单例对象和隐式函数，这些隐式定义也必须用implicit修饰。隐式变量，单例对象，函数在当前作用域的引用必须满足单标识符原则，即不同层次之间必要用import解决。
隐式参数的类型应该是稀有或特定的，类型名称最好能表明该参数的作用，而不是使用Int，String等已经约定好的名称。

1. class PreferredPrompt(val preference: String)
2. class PreferredDrink(val preference: String)
4. object Greeter {
5.   def greet(name: String)(implicit prompt: PreferredPrompt, drink: PreferredDrink) = {
6.     println("Welcome, " + name + ". The system is ready.")
7.     print("But while you work, ")
8.     println("why not enjoy a cup of " + drink.preference + "?")
9.     println(prompt.preference)
10.   }
11. }
13. object JoesPrefs {
14.   implicit val prompt: PreferredPrompt = new PreferredPrompt("Yes, master> ")
15.   implicit val drink: PreferredDrink = new PreferredDrink("tea")
16. }

复制代码

保存后执行编译指令，并进入解释器，执行下令：

1. jia@J-MateBookEGo:~/scala_test$ scalac test.scala
2. jia@J-MateBookEGo:~/scala_test$ scala
3. Jan 13, 2025 1:09:02 PM org.jline.utils.Log logr
4. Welcome to Scala 3.6.2 (21.0.5, Java OpenJDK 64-Bit Server VM).
5. Type in expressions for evaluation. Or try :help.
7. scala> :load test.scala
8. // defined class PreferredPrompt
9. // defined class PreferredDrink
10. // defined object Greeter
11. // defined object JoesPrefs
13. scala> Greeter.greet("Joe")
14. -- [E172] Type Error: --------------------------------------------------------------------------------------------------
15. 1 |Greeter.greet("Joe")
16.   |                    ^
17.   |        No given instance of type PreferredPrompt was found for parameter prompt of method greet in object Greeter
18.   |
19.   |        The following import might fix the problem:
20.   |
21.   |          import JoesPrefs.prompt
22.   |
23. 1 error found
25. scala> import JoesPrefs._
27. scala> Greeter.greet("Joe")
28. Welcome, Joe. The system is ready.
29. But while you work, why not enjoy a cup of tea?
30. Yes, master>
32. scala> Greeter.greet("Joe")(prompt, drink)
33. Welcome, Joe. The system is ready.
34. But while you work, why not enjoy a cup of tea?
35. Yes, master>

复制代码

10.6 含有隐式参数的主构造方法

平凡的函数可以含有隐式参数，类的主构造方法也可以包含隐式参数，辅助构造方法不答应出现隐式参数。假设类A仅有一个参数列表，而且该列表是隐式的，那么A的实际定义情势是A()(implicit 参数)，也就是比字面上的代码多了一对空括号，无论用new实例化类A，照旧被其他类继续，若调用主构造方法时显式地给出隐式参数，就必须写出这对空括号，若隐式参数是编译器主动插入，则空括号可有可无。

1. scala> class A(implicit val x: Int)
2. // defined class A
4. scala> val a = new A(1)
5. -- Error: --------------------------------------------------------------------------------------------------------------
6. 1 |val a = new A(1)
7.   |              ^
8.   |              too many arguments for constructor A in class A: ()(implicit x: Int): A
9. 1 error found
11. scala> val a = new A()(1)
12. val a: A = A@6caeba36
14. scala> implicit val ORZ = 233
15. -- Error: --------------------------------------------------------------------------------------------------------------
16. 1 |implicit val ORZ = 233
17.   |             ^
18.   |             type of implicit definition needs to be given explicitly
19. 1 error found
21. scala> implicit val ORZ: Int = 233
22. val ORZ: Int = 233
24. scala> val b = new A
25. val b: A = A@6a7aa675
27. scala> b.x
28. val res0: Int = 233
30. scala> val c = new A()
31. val c: A = A@1534bdc6
33. scala> c.x
34. val res1: Int = 233

复制代码

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