What does `:_*` (colon underscore star) do in Scala?

送分小仙女□ 提交于 2019-11-25 22:47:39

问题


I have the following piece of code from this question:

def addChild(n: Node, newChild: Node) = n match {
  case Elem(prefix, label, attribs, scope, child @ _*) => Elem(prefix, label, attribs, scope, child ++ newChild : _*)
  case _ => error(\"Can only add children to elements!\")
}

Everything in it is pretty clear, except this piece: child ++ newChild : _*

What does it do?

I understand there is Seq[Node] concatenated with another Node, and then? What does : _* do?


回答1:


It "splats"1 the sequence.

Look at the constructor signature

new Elem(prefix: String, label: String, attributes: MetaData, scope: NamespaceBinding,
         child: Node*)

which is called as

new Elem(prefix, label, attributes, scope,
         child1, child2, ... childN)

but here there is only a sequence, not child1, child2, etc. so this allows the result sequence to be used as the input to the constructor.

Happy coding.


1 This doesn't have a cutesy-name in the SLS, but here are the details. The important thing to get is that it changes how Scala binds the arguments to the method with repeated parameters (as denoted with Node* above).

The _* type annotation is covered in "4.6.2 Repeated Parameters" of the SLS.

The last value parameter of a parameter section may be suffixed by “*”, e.g. (..., x:T *). The type of such a repeated parameter inside the method is then the sequence type scala.Seq[T]. Methods with repeated parameters T * take a variable number of arguments of type T . That is, if a method m with type (p1 : T1, . . . , pn : Tn,ps : S*)U is applied to arguments (e1, . . . , ek) where k >= n, then m is taken in that application to have type (p1 : T1, . . . , pn : Tn,ps : S, . . . , ps0S)U, with k ¡ n occurrences of type S where any parameter names beyond ps are fresh. The only exception to this rule is if the last argument is marked to be a sequence argument via a _* type annotation. If m above is applied to arguments (e1, . . . , en,e0 : _*), then the type of m in that application is taken to be (p1 : T1, . . . , pn : Tn,ps :scala.Seq[S])




回答2:


  • child ++ newChild - sequence
  • : - type ascription, a hint that helps compiler to understand, what type does that expression have
  • _* - placeholder accepting any value + vararg operator

child ++ newChild : _* expands Seq[Node] to Node* (tells the compiler that we're rather working with a varargs, than a sequence). Particularly useful for the methods that can accept only varargs.




回答3:


All the above answer looks great, but just need a sample to explain this . Here it is :

val x : Seq[Seq[Int]] = Seq(Seq(1),Seq(2))

def f(arg: Seq[Any]*) : Int = {
 arg.length
}
f(x) //1 as x is taken as single arg
f(x:_*)  // 2 as x is "unpacked" as a Seq[Any]*

So now we know what :_* do is to tell compiler : please unpack this argument and bind those elements to the vararg parameter in function call rather than take the x as a single argument .

So in a nutshell, the :_* is to remove ambiguity when pass argument to vararg parameter.




回答4:


For some of the lazy folks like me, it just converts a Seq to varArgs!



来源:https://stackoverflow.com/questions/6051302/what-does-colon-underscore-star-do-in-scala

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!