blocks|key|1994805|text|case+class+Scheduled(time+:+Int,+callback+:++=>+Unit)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1994806|case修饰符对构造函数的每个参数进行隐式val。因此(正如有人指出的那样)，如果您删除了case，则可以使用call-by-name参数。编译器可能无论如何都会允许它，但如果它创建了val+callback而不是变形为lazy+val+callback，可能会让人们感到惊讶。|unstyled|offset|length|style|CODE|1994807|当您现在更改为callback:+()+=>+Unit时，您的用例只接受一个函数，而不是一个按名称调用的参数。显然，函数可以存储在val+callback中，所以没有问题。|1994808|获得所需内容(Scheduled(40,+println("x")+)，其中按名称调用参数用于传递lambda)的最简单方法可能是跳过case，显式地创建最初无法获得的apply：|1994809|class+Scheduled(val+time:+Int,+val+callback:+()+=>+Unit)+{
++++def+doit+=+callback()
}

object+Scheduled+{
++++def+apply(time:+Int,+callback:+=>+Unit)+=
++++++++new+Scheduled(time,+{+()+=>+callback+})
}|1994810|使用中：|1994811|scala>+Scheduled(1234,+println("x"))
res0:+Scheduled+=+Scheduled@5eb10190

scala>+Scheduled(1234,+println("x")).doit
x|1994812|entityMap^0|0|0|4|L|3|19|4|2K|C|32|H|0|7|K|1T|C|0|7|S|1V|4|2C|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|X|8|@$G|Y|H|Z|I|J]|$G|10|H|11|I|J]|$G|12|H|13|I|J]|$G|14|H|15|I|J]|$G|16|H|17|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|18|8|@$G|19|H|1A|I|J]|$G|1B|H|1C|I|J]]|9|@]|A|$]]|$1|M|3|N|5|F|7|1D|8|@$G|1E|H|1F|I|J]|$G|1G|H|1H|I|J]|$G|1I|H|1J|I|J]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1K|8|@]|9|@]|A|$B|C]]|$1|Q|3|R|5|F|7|1L|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1M|8|@]|9|@]|A|$B|C]]|$1|U|3|-4|5|F|7|1N|8|@]|9|@]|A|$]]]|V|$]]

<pre><code>case class Scheduled(time : Int, callback : =&gt; Unit)
</code></pre>

The <code>case</code> modifier makes implicit <code>val</code> out of each argument to the constructor. Hence (as someone noted) if you remove <code>case</code> you can use a call-by-name parameter. The compiler could probably allow it anyway, but it might surprise people if it created <code>val callback</code> instead of morphing into <code>lazy val callback</code>.

When you change to <code>callback: () =&gt; Unit</code> now your case just takes a function rather than a call-by-name parameter. Obviously the function can be stored in <code>val callback</code> so there's no problem.

The easiest way to get what you want (<code>Scheduled(40, println("x") )</code> where a call-by-name parameter is used to pass a lambda) is probably to skip the <code>case</code> and explicitly create the <code>apply</code> that you couldn't get in the first place:

<pre><code>class Scheduled(val time: Int, val callback: () =&gt; Unit) {
 def doit = callback()
}

object Scheduled {
 def apply(time: Int, callback: =&gt; Unit) =
 new Scheduled(time, { () =&gt; callback })
}
</code></pre>

In use:

<pre><code>scala&gt; Scheduled(1234, println("x"))
res0: Scheduled = Scheduled@5eb10190

scala&gt; Scheduled(1234, println("x")).doit
x
</code></pre>

blocks|key|1994830|text|Call-by-Name：=>类型|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1994831|=>+Type表示call-by-name，这是可以传递的many+ways参数之一。如果您不熟悉它们，我建议您花一些时间阅读wikipedia文章，尽管现在它主要是按值调用和按引用调用。|offset|length|style|CODE|1994832|它的意思是传递的内容将替换函数中的值名。例如，以此函数为例：|1994833|def+f(x:+=>+Int)+=+x+*+x|code-block|syntax|javascript|1994834|如果我这样称呼它|1994835|var+y+=+0
f+{+y+%2B=+1;+y+}|1994836|然后，代码将像这样执行|1994837|{+y+%2B=+1;+y+}+*+{+y+%2B=+1;+y+}|1994838|不过，这提出了如果存在标识符名称冲突时会发生什么的问题。在传统的按名称调用中，会发生一种称为捕获避免替换的机制，以避免名称冲突。然而，在Scala中，这是以另一种方式实现的，具有相同的结果--参数中的标识符名称不能引用或隐藏被调用函数中的标识符。|1994839|还有一些与call-by-name相关的其他要点，我将在解释完其他两个之后再谈到。|1994840|0参数函数：()+=>类型|1994841|语法()+=>+Type代表Function0的类型。也就是说，一个不带参数并返回一些东西的函数。比方说，这相当于调用方法size()+--它不接受任何参数并返回一个数字。|1994842|然而，有趣的是，这种语法与匿名函数文本的语法非常相似，这是造成一些混淆的原因。例如,|1994843|()+=>+println("I'm+an+anonymous+function")|1994844|是一个参数为0的匿名函数文本，其类型为|1994845|()+=>+Unit|1994846|所以我们可以这样写：|1994847|val+f:+()+=>+Unit+=+()+=>+println("I'm+an+anonymous+function")|1994848|但是，重要的是不要混淆类型和值。|1994849|单位=>类型|1994850|这实际上只是一个Function1，它的第一个参数的类型是Unit。其他的编写方式可以是(Unit)+=>+Type或Function1[Unit,+Type]。问题是..。这不太可能是人们想要的。Unit类型的主要用途是指示一个不感兴趣的值，因此接收该值没有任何意义。|1994851|例如，考虑以下内容：|1994852|def+f(x:+Unit)+=+...|1994853|可以用x做什么呢？它只能有一个值，所以不需要接收它。一种可能的用途是链接返回Unit的函数|1994854|val+f+=+(x:+Unit)+=>+println("I'm+f")
val+g+=+(x:+Unit)+=>+println("I'm+g")
val+h+=+f+andThen+g|1994855|因为andThen只在Function1上定义，而我们链接的函数返回Unit，所以我们必须将它们定义为Function1[Unit,+Unit]类型才能链接它们。|1994856|混乱的来源|1994857|混淆的第一个来源是，认为类型和文字之间的相似性对于0度函数来说也存在，对于按名称调用也存在。换句话说，认为，因为|1994858|()+=>+{+println("Hi!")+}|1994859|是()+=>+Unit的文字，则|1994860|{+println("Hi!")+}|1994861|将是=>+Unit的文字。事实并非如此。这是一段代码，而不是文字。|1994862|另一个造成混淆的原因是Unit类型的值被写成()，这看起来像一个0参数列表(但它不是)。|1994863|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Evaluation_strategy^0|0|0|7|T|9|0|0|0|0|0|0|0|0|0|0|0|2|A|E|9|1P|6|0|0|0|0|0|0|0|0|0|8|9|T|4|18|E|1N|L|2R|4|0|0|0|3|1|12|4|0|0|2|7|B|9|Y|4|1F|L|0|0|0|0|1|A|0|0|2|7|0|B|4|M|2|0^^$0|@$1|2|3|4|5|6|7|2I|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|2J|8|@$D|2K|E|2L|F|G]]|9|@$D|2M|E|2N|1|2O]]|A|$]]|$1|H|3|I|5|6|7|2P|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|2Q|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|2R|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|2S|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|2T|8|@]|9|@]|A|$]]|$1|U|3|V|5|L|7|2U|8|@]|9|@]|A|$M|N]]|$1|W|3|X|5|6|7|2V|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|2W|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|2X|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|2Y|8|@$D|2Z|E|30|F|G]|$D|31|E|32|F|G]|$D|33|E|34|F|G]]|9|@]|A|$]]|$1|14|3|15|5|6|7|35|8|@]|9|@]|A|$]]|$1|16|3|17|5|L|7|36|8|@]|9|@]|A|$M|N]]|$1|18|3|19|5|6|7|37|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|L|7|38|8|@]|9|@]|A|$M|N]]|$1|1C|3|1D|5|6|7|39|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|L|7|3A|8|@]|9|@]|A|$M|N]]|$1|1G|3|1H|5|6|7|3B|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|3C|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|6|7|3D|8|@$D|3E|E|3F|F|G]|$D|3G|E|3H|F|G]|$D|3I|E|3J|F|G]|$D|3K|E|3L|F|G]|$D|3M|E|3N|F|G]]|9|@]|A|$]]|$1|1M|3|1N|5|6|7|3O|8|@]|9|@]|A|$]]|$1|1O|3|1P|5|L|7|3P|8|@]|9|@]|A|$M|N]]|$1|1Q|3|1R|5|6|7|3Q|8|@$D|3R|E|3S|F|G]|$D|3T|E|3U|F|G]]|9|@]|A|$]]|$1|1S|3|1T|5|L|7|3V|8|@]|9|@]|A|$M|N]]|$1|1U|3|1V|5|6|7|3W|8|@$D|3X|E|3Y|F|G]|$D|3Z|E|40|F|G]|$D|41|E|42|F|G]|$D|43|E|44|F|G]]|9|@]|A|$]]|$1|1W|3|1X|5|6|7|45|8|@]|9|@]|A|$]]|$1|1Y|3|1Z|5|6|7|46|8|@]|9|@]|A|$]]|$1|20|3|21|5|L|7|47|8|@]|9|@]|A|$M|N]]|$1|22|3|23|5|6|7|48|8|@$D|49|E|4A|F|G]]|9|@]|A|$]]|$1|24|3|25|5|L|7|4B|8|@]|9|@]|A|$M|N]]|$1|26|3|27|5|6|7|4C|8|@$D|4D|E|4E|F|G]]|9|@]|A|$]]|$1|28|3|29|5|6|7|4F|8|@$D|4G|E|4H|F|G]|$D|4I|E|4J|F|G]]|9|@]|A|$]]|$1|2A|3|-4|5|6|7|4K|8|@]|9|@]|A|$]]]|2B|$2C|$5|2D|2E|2F|A|$2G|2H]]]]

<h2>Call-by-Name: => Type</h2>

The <code>=&gt; Type</code> notation stands for call-by-name, which is one of the <a href="http://en.wikipedia.org/wiki/Evaluation_strategy" rel="noreferrer">many ways</a> parameters can be passed. If you aren't familiar with them, I recommend taking some time to read that wikipedia article, even though nowadays it is mostly call-by-value and call-by-reference.

What it means is that what is passed is substituted for the value name inside the function. For example, take this function:

<pre><code>def f(x: =&gt; Int) = x * x
</code></pre>

If I call it like this

<pre><code>var y = 0
f { y += 1; y }
</code></pre>

Then the code will execute like this

<pre><code>{ y += 1; y } * { y += 1; y }
</code></pre>

Though that raises the point of what happens if there's a identifier name clash. In traditional call-by-name, a mechanism called capture-avoiding substitution takes place to avoid name clashes. In Scala, however, this is implemented in another way with the same result -- identifier names inside the parameter can't refer to or shadow identifiers in the called function.

There are some other points related to call-by-name that I'll speak of after explaining the other two.

<h2>0-arity Functions: () => Type</h2>

The syntax <code>() =&gt; Type</code> stands for the type of a <code>Function0</code>. That is, a function which takes no parameters and returns something. This is equivalent to, say, calling the method <code>size()</code> -- it takes no parameters and returns a number.

It is interesting, however, that this syntax is very similar to the syntax for a anonymous function literal, which is the cause for some confusion. For example,

<pre><code>() =&gt; println("I'm an anonymous function")
</code></pre>

is an anonymous function literal of arity 0, whose type is

<pre><code>() =&gt; Unit
</code></pre>

So we could write:

<pre><code>val f: () =&gt; Unit = () =&gt; println("I'm an anonymous function")
</code></pre>

It is important not to confuse the type with the value, however.

<h2>Unit => Type</h2>

This is actually just a <code>Function1</code>, whose first parameter is of type <code>Unit</code>. Other ways to write it would be <code>(Unit) =&gt; Type</code> or <code>Function1[Unit, Type]</code>. The thing is... this is unlikely to ever be what one wants. The <code>Unit</code> type's main purpose is indicating a value one is not interested in, so doesn't make sense to receive that value.

Consider, for instance,

<pre><code>def f(x: Unit) = ...
</code></pre>

What could one possibly do with <code>x</code>? It can only have a single value, so one need not receive it. One possible use would be chaining functions returning <code>Unit</code>:

<pre><code>val f = (x: Unit) =&gt; println("I'm f")
val g = (x: Unit) =&gt; println("I'm g")
val h = f andThen g
</code></pre>

Because <code>andThen</code> is only defined on <code>Function1</code>, and the functions we are chaining are returning <code>Unit</code>, we had to define them as being of type <code>Function1[Unit, Unit]</code> to be able to chain them.

<h2>Sources of Confusion</h2>

The first source of confusion is thinking the similarity between type and literal that exists for 0-arity functions also exists for call-by-name. In other words, thinking that, because

<pre><code>() =&gt; { println("Hi!") }
</code></pre>

is a literal for <code>() =&gt; Unit</code>, then

<pre><code>{ println("Hi!") }
</code></pre>

would be a literal for <code>=&gt; Unit</code>. It is not. That is a block of code, not a literal. 

Another source of confusion is that <code>Unit</code> type's value is written <code>()</code>, which looks like a 0-arity parameter list (but it is not).

blocks|key|1781186|text|在这个问题中，您想要在JavaScript中模拟SetTimeOut函数。根据前面的答案，我编写了以下代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1781187|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
++}
}|code-block|syntax|javascript|1781188|在REPL中，我们可以得到如下内容：|1781189|scala>+Scheduled(10,+println("a"));+Scheduled(1,+println("b"))
a
b|1781190|我们的模拟与SetTimeOut的行为不完全相同，因为我们的模拟是阻塞函数，而SetTimeOut是非阻塞的。|1781191|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

In the question, you want to simulate SetTimeOut function in JavaScript. Based on previous answers, I write following code:

<pre><code>class Scheduled(time: Int, cb: =&gt; Unit) {
 private def runCb = cb
}

object Scheduled {
 def apply(time: Int, cb: =&gt; Unit) = {
 val instance = new Scheduled(time, cb)
 Thread.sleep(time*1000)
 instance.runCb
 }
}
</code></pre>

In REPL, we can get something like this:

<pre><code>scala&gt; Scheduled(10, println("a")); Scheduled(1, println("b"))
a
b
</code></pre>

Our simulation doesn't behave exactly the same as SetTimeOut, because our simulation is blocking function, but SetTimeOut is non-blocking.

blocks|key|1781242|text|我是这样做的(只是不想破坏apply)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1781243|case+class+Thing[A](...,+lazy:+()+=>+A)+{}
object+Thing+{
++def+of[A](...,+a:+=>+A):+Thing[A]+=+Thing(...,+()+=>+a)
}|code-block|syntax|javascript|1781244|并将其称为|1781245|Thing.of(...,+your_value)|1781246|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I do it this way (just don't want to break apply):

<pre><code>case class Thing[A](..., lazy: () =&gt; A) {}
object Thing {
 def of[A](..., a: =&gt; A): Thing[A] = Thing(..., () =&gt; a)
}
</code></pre>

and call it

<pre><code>Thing.of(..., your_value)
</code></pre>

I'm trying to represent a function that takes no arguments and returns no value (I'm simulating the setTimeout function in JavaScript, if you must know.)

<pre><code>case class Scheduled(time : Int, callback : =&gt; Unit)
</code></pre>

doesn't compile, saying " `val' parameters may not be call-by-name"

<pre><code>case class Scheduled(time : Int, callback : () =&gt; Unit) 
</code></pre>

compiles, but has to be invoked strangely, instead of

<pre><code>Scheduled(40, { println("x") } )
</code></pre>

I have to do this

<pre><code>Scheduled(40, { () =&gt; println("x") } ) 
</code></pre>

What also works is

<pre><code>class Scheduled(time : Int, callback : Unit =&gt; Unit)
</code></pre>

but is invoked in an even-less-sensible way

<pre><code> Scheduled(40, { x : Unit =&gt; println("x") } )
</code></pre>

(What would a variable of type Unit be?) What I want of course is a constructor that can be invoke the way I would invoke it if it were an ordinary function:

<pre><code> Scheduled(40, println("x") )
</code></pre>

Give baby his bottle!

What's the difference between => , ()=>, and Unit=>

编译器

我试图表示一个不带参数、不返回值的函数(如果您一定要知道，我正在用JavaScript模拟setTimeout函数)。case class Scheduled(time : Int, callback :  => Unit)不能编译，因为“` `val‘参数可能不是按名称调用的”case class Scheduled...

问=>、()=>和Unit=>之间的区别是什么
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问=>、()=>和Unit=>之间的区别是什么EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问=>、()=>和Unit=>之间的区别是什么
EN