=> 和有什么区别？ 、()=>、单位=>

Question

我试图表示一个不带参数且不返回任何值的函数（如果您必须知道的话，我正在用 JavaScript 模拟 setTimeout 函数。）

case class Scheduled(time : Int, callback :  => Unit)

无法编译，说“‘val’参数可能不会被调用-name"

case class Scheduled(time : Int, callback :  () => Unit)  

编译，但必须奇怪地调用，而不是

Scheduled(40, { println("x") } )

我必须这样做

Scheduled(40, { () => println("x") } )      

什么也有效，

class Scheduled(time : Int, callback :  Unit => Unit)

但以一种甚至不太明智的方式调用

 Scheduled(40, { x : Unit => println("x") } )

（Unit 类型的变量会是什么？）我 Want 当然是一个构造函数，可以按照我调用它的方式调用它（如果它是一个普通函数）：

 Scheduled(40, println("x") )

给宝宝他的瓶子！

Answer 1

按姓名呼唤： =>输入

=>类型表示法代表按名称调用，这是多种方式之一可以传递参数。如果您不熟悉它们，我建议花一些时间阅读维基百科文章，尽管现在它主要是按值调用和按引用调用。

这意味着传递的内容将替换函数内的值名称。例如，采用这个函数：

def f(x: => Int) = x * x

如果我像这样调用它

var y = 0
f { y += 1; y }

那么代码将像这样执行

{ y += 1; y } * { y += 1; y }

虽然这提出了如果存在标识符名称冲突会发生什么的问题。在传统的按名称调用中，会发生一种称为避免捕获替换的机制来避免名称冲突。然而，在 Scala 中，这是以另一种方式实现的，具有相同的结果——参数内的标识符名称不能引用或隐藏被调用函数中的标识符。

还有一些与直呼姓名相关的要点，我将在解释完其他两点之后再谈。

0 元函数： () =>类型

语法 () =>; Type 代表Function0 的类型。也就是说，一个不带参数并返回某些内容的函数。这相当于调用方法 size() ——它不带参数并返回一个数字。

然而有趣的是，这种语法与匿名函数文字的语法非常相似，这导致了一些混乱。例如，

() => println("I'm an anonymous function")

是一个 arity 0 的匿名函数字面量，其 type 是

() => Unit

所以我们可以这样写：

val f: () => Unit = () => println("I'm an anonymous function")

但是，重要的是不要将类型与值混淆。

单位=>类型

这实际上只是一个Function1，其第一个参数的类型为Unit。其他编写方式为 (Unit) =>类型 或Function1[单位，类型]。问题是……这不太可能是人们想要的。 Unit 类型的主要目的是指示一个人们不感兴趣的值，因此接收该值没有意义。

例如，考虑一下，

def f(x: Unit) = ...

人们可以用 x 做什么？它只能有一个值，因此不需要接收它。一种可能的用途是链接返回 Unit 的函数：

val f = (x: Unit) => println("I'm f")
val g = (x: Unit) => println("I'm g")
val h = f andThen g

因为 andThen 仅在 Function1 上定义，并且我们链接的函数返回 Unit，我们必须将它们定义为 Function1[Unit, Unit] 类型才能链接它们。

混乱的来源

第一个混乱的来源是认为 0 元函数中存在的类型和文字之间的相似性也存在于按名称调用中。换句话说，认为，because

() => { println("Hi!") }

是 () => 的文字。 Unit 则将

{ println("Hi!") }

是 => 的文字单位。它不是。这是一个代码块，而不是文字。

另一个令人困惑的来源是 Unit 类型的 value 被写成 ()，它看起来像一个 0 元参数列表（但事实并非如此） 。

Answer 2

case class Scheduled(time : Int, callback :  => Unit)

case 修饰符使构造函数的每个参数隐含 val 。因此（正如有人指出的）如果您删除 case 您可以使用按名称调用参数。无论如何，编译器可能会允许它，但如果它创建 val 回调 而不是转变为 lazy val 回调，人们可能会感到惊讶。

当您更改为 callback: () =>;现在你的案例只需要一个函数而不是一个按名称调用的参数。显然该函数可以存储在 valcallback 中，所以没有问题。

获得所需内容的最简单方法（Scheduled(40, println("x") )，其中使用按名称调用参数传递 lambda）可能是跳过 case 并显式创建您一开始无法获得的 apply：

class Scheduled(val time: Int, val callback: () => Unit) {
    def doit = callback()
}

object Scheduled {
    def apply(time: Int, callback: => Unit) =
        new Scheduled(time, { () => callback })
}

在使用中：

scala> Scheduled(1234, println("x"))
res0: Scheduled = Scheduled@5eb10190

scala> Scheduled(1234, println("x")).doit
x

Answer 3

在问题中，您想在 JavaScript 中模拟 SetTimeOut 函数。根据之前的答案，我编写了以下代码：

class Scheduled(time: Int, cb: => Unit) {
  private def runCb = cb
}

object Scheduled {
  def apply(time: Int, cb: => Unit) = {
    val instance = new Scheduled(time, cb)
    Thread.sleep(time*1000)
    instance.runCb
  }
}

在REPL中，我们可以得到这样的结果：

scala> Scheduled(10, println("a")); Scheduled(1, println("b"))
a
b

我们的模拟与SetTimeOut的行为并不完全相同，因为我们的模拟是阻塞函数，但SetTimeOut是非阻塞的。

Answer 4

我这样做（只是不想打破应用）：

case class Thing[A](..., lazy: () => A) {}
object Thing {
  def of[A](..., a: => A): Thing[A] = Thing(..., () => a)
}

并调用它

Thing.of(..., your_value)