scala - def 关键字与火箭( => )表示法会改变 scala 中的函数行为吗？

Question

我正在学习 Scala，我正在尝试了解定义函数的第一种方法引发错误的原因，即找不到“+”、“v1”和“v2”，而第二种方法下面列出的作品。

方法一: - 使用 Lambda 表达式表示法:

val addVectLambda = (v1:Vect3,v2:Vect3):Vect3 => (v1._1 + v2._1, v1._2 + v2._2, v1._3 + v2._3)

方法二:——使用def关键字:

def addVect (v1:Vect3, v2:Vect3):Vect3 = (v1._1 + v2._1, v1._2 + v2._2, v1._3 + v2._3)

如果这个问题已经被问过，我深表歉意 - 我尝试搜索但找不到答案。非常感谢任何帮助/指导。

谢谢

编辑:产生错误信息的完整代码:

type Vect3 = (Double, Double, Double)
val addVectLambda = (v1:Vect3,v2:Vect3):Vect3 => (v1._1 + v2._1, v1._2 + v2._2, v1._3 + v2._3)

错误信息:

error: not found: type +
val addVectLambda = (v1:Vect3,v2:Vect3):Vect3 => (v1._1 + v2._1, v1._2 + v2._2, v1._3 + v2._3)
                                                        ^
error: not found: type +
val addVectLambda = (v1:Vect3,v2:Vect3):Vect3 => (v1._1 + v2._1, v1._2 + v2._2, v1._3 + v2._3)
                                                                       ^
error: not found: type +
val addVectLambda = (v1:Vect3,v2:Vect3):Vect3 => (v1._1 + v2._1, v1._2 + v2._2, v1._3 + v2._3)
                                                                                      ^
error: not found: value v1
val addVectLambda = (v1:Vect3,v2:Vect3):Vect3 => (v1._1 + v2._1, v1._2 + v2._2, v1._3 + v2._3)
                     ^
error: not found: value v2
val addVectLambda = (v1:Vect3,v2:Vect3):Vect3 => (v1._1 + v2._1, v1._2 + v2._2, v1._3 + v2._3)
                              ^

Answer 1

这是您收到的一个奇怪的错误消息，但这几乎不是您的错...我将首先简单解释您的第一个代码片段有什么问题，然后我将讨论它的奇怪错误消息产生。

---

如果你想写下一个 lambda，你必须这样做:

type V3 = (Double, Double, Double)
val add = (a: V3, b: V3) => (a._1 + b._1, a._2 + b._2, a._3 + b._3)

如果您想显式地归属返回类型，则必须在右侧添加类型归属:

val add2 = (a: V3, b: V3) => ((a._1 + b._1, a._2 + b._2, a._3 + b._3) : V3)

另一种选择是赋予 add3 的类型。明确:

val add3: (V3, V3) => V3 = 
  (a: V3, b: V3) => (a._1 + b._1, a._2 + b._2, a._3 + b._3)

这些都是你的选择。只要坚持 lambdas 的有效语法，就可以了。

---

接下来是解释为什么奇怪的错误消息是有意义的。但是，要理解解释，至少应该了解类型构造函数、类型成员、中缀表示法规则和隐式转换。

---

如果你错误地尝试在 lambda 的参数之后附加返回类型:

val broken = (a: V3, b: V3): V3 => (a._1 + b._1, a._2 + b._2, a._3 + b._3)

你得到一堆错误

error: not found: type +

乍一看，整个表达式似乎完全无效。不清楚为什么这个表达式应该在编译的解析阶段幸存下来。但是，这不是编译器错误。我们确实可以发明一组(相当人为的)定义，以使上述表达式变得有效。这是一种可能性:

import scala.language.implicitConversions
trait +[A, B]
class R
class V3 {
  type _1 = R
  type _2 = R
  type _3 = R
}
val a = new V3
val b = new V3

implicit def conversion(i: (V3, V3)): (V3 => (R + R, R + R, R + R)) = { 
  v: V3 =>
  (new +[R, R]{}, new +[R, R]{}, new +[R, R]{})
}

val notBroken = (a: V3, b: V3): V3 => (a._1 + b._1, a._2 + b._2, a._3 + b._3)

println(notBroken)

这里是 notBroken 的右侧看起来与您问题中的不可编译(非)-lambda 基本相同。但是，这是完全有效的 Scala代码，它甚至运行。

这里发生了什么:

• +是用中缀表示法编写的二进制类型构造函数
• _1 ... _3是类 V3 的类型成员, 设置为 R
• a和 b是 V3 的实例
• 有一个来自 (V3, V3) 的完全疯狂的隐式转换到真正丑陋的函数类型V3 => (R + R, R + R, R + R)
• V3 => (a._1 + b._1, ... , ...)冒号右边的部分不是 lambda，而是类型归属
• 类型归属强制隐式转换

所以，它是有效的，但诚然，在不太人为的用例中不是很有帮助。