blocks|key|1309076|text|Manifests是一种在运行时获取类型信息的方法，就好像Scala具有具体化的类型一样。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1309077|entityMap|0|LINK|mutability|MUTABLE|url|http://scala-blogs.org/2008/10/manifests-reified-types.html^0|0|9|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="http://scala-blogs.org/2008/10/manifests-reified-types.html" rel="nofollow noreferrer">Manifests</a> which are a sort of way at getting the type information at runtime, as if Scala had reified types.

blocks|key|1309136|text|也许不是太隐蔽，但我认为这是有用的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1309137|@scala.reflect.BeanProperty
var+firstName:String+=+_|code-block|syntax|javascript|1309138|这将自动为匹配bean约定的字段生成getter和setter。|1309139|在developerworks上有更多描述|offset|length|1309140|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ibm.com/developerworks/java/library/j-scala03268.html^0|0|0|0|1|E|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

Maybe not too hidden, but I think this is useful:

<pre><code>@scala.reflect.BeanProperty
var firstName:String = _
</code></pre>

This will automatically generate a getter and setter for the field that matches bean convention.

Further description at <a href="http://www.ibm.com/developerworks/java/library/j-scala03268.html" rel="nofollow noreferrer">developerworks</a>

blocks|key|1524263|text|您可以指定一个按名称调用的参数(编辑:这与懒惰参数不同！)添加到函数中，直到函数使用它才会进行计算(EDIT:实际上，每次使用它时都会重新计算它)。详情请参阅this+faq|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1524264|class+Bar(i:Int)+{
++++println("constructing+bar+"+%2B+i)
++++override+def+toString():String+=+{
++++++++"bar+with+value:+"+%2B+i
++++}
}

//+NOTE+the+=>+in+the+method+declaration.++It+indicates+a+lazy+paramter
def+foo(x:+=>+Bar)+=+{
++++println("foo+called")
++++println("bar:+"+%2B+x)
}


foo(new+Bar(22))

/*
prints+the+following:
foo+called
constructing+bar+22
bar+with+value:+22
*/|code-block|syntax|javascript|1524265|entityMap|0|LINK|mutability|MUTABLE|url|http://scala.sygneca.com/faqs/language#what-s-the-difference-between-a-lazy-argument-a-no-arg-function-argument-and-a-lazy-value^0|27|8|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

You can designate a call-by-name parameter (EDITED: this is different then a lazy parameter!) to a function and it will not be evaluated until used by the function (EDIT: in fact, it will be reevaluated every time it is used). See <a href="http://scala.sygneca.com/faqs/language#what-s-the-difference-between-a-lazy-argument-a-no-arg-function-argument-and-a-lazy-value" rel="noreferrer">this faq</a> for details

<pre><code>class Bar(i:Int) {
 println("constructing bar " + i)
 override def toString():String = {
 "bar with value: " + i
 }
}

// NOTE the =&gt; in the method declaration. It indicates a lazy paramter
def foo(x: =&gt; Bar) = {
 println("foo called")
 println("bar: " + x)
}


foo(new Bar(22))

/*
prints the following:
foo called
constructing bar 22
bar with value: 22
*/
</code></pre>

blocks|key|1309257|text|您可以定义自己的控制结构。它实际上只是一些函数和对象以及一些语法糖，但它们看起来和行为都像真正的东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1309258|例如，以下代码定义dont+{...}+unless+(cond)和dont+{...}+until+(cond)|offset|length|style|CODE|1309259|def+dont(code:+=>+Unit)+=+new+DontCommand(code)

class+DontCommand(code:+=>+Unit)+{
++def+unless(condition:+=>+Boolean)+=
++++if+(condition)+code

++def+until(condition:+=>+Boolean)+=+{
++++while+(!condition)+{}
++++code
++}
}|code-block|syntax|javascript|1309260|现在，您可以执行以下操作：|1309261|/*+This+will+only+get+executed+if+the+condition+is+true+*/
dont+{
++println("Yep,+2+really+is+greater+than+1.")
}+unless+(2+>+1)+

/*+Just+a+helper+function+*/
var+number+=+0;
def+nextNumber()+=+{
++number+%2B=+1
++println(number)
++number
}

/*+This+will+not+be+printed+until+the+condition+is+met.+*/
dont+{
++println("Done+counting+to+5!")
}+until+(nextNumber()+==+5)+|1309262|entityMap^0|0|9|O|Y|N|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]|$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

You can define your own control structures. It's really just functions and objects and some syntactic sugar, but they look and behave like the real thing.

For example, the following code defines <code>dont {...} unless (cond)</code> and <code>dont {...} until (cond)</code>:

<pre><code>def dont(code: =&gt; Unit) = new DontCommand(code)

class DontCommand(code: =&gt; Unit) {
 def unless(condition: =&gt; Boolean) =
 if (condition) code

 def until(condition: =&gt; Boolean) = {
 while (!condition) {}
 code
 }
}
</code></pre>

Now you can do the following:

<pre><code>/* This will only get executed if the condition is true */
dont {
 println("Yep, 2 really is greater than 1.")
} unless (2 &gt; 1) 

/* Just a helper function */
var number = 0;
def nextNumber() = {
 number += 1
 println(number)
 number
}

/* This will not be printed until the condition is met. */
dont {
 println("Done counting to 5!")
} until (nextNumber() == 5) 
</code></pre>

blocks|key|1309292|text|Scala+2.8引入了默认和命名参数，这使得Scala向case类添加新的"copy“方法成为可能。如果您这样定义：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1309293|case+class+Foo(a:+Int,+b:+Int,+c:+Int,+...+z:Int)|code-block|syntax|javascript|1309294|如果您想创建一个新的Foo，它类似于现有的Foo，只是具有不同的"n“值，那么您只需说：|1309295|foo.copy(n+=+3)|1309296|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|$]]

Scala 2.8 introduced default and named arguments, which made possible the addition of a new "copy" method that Scala adds to case classes. If you define this:

<pre><code>case class Foo(a: Int, b: Int, c: Int, ... z:Int)
</code></pre>

and you want to create a new Foo that's like an existing Foo, only with a different "n" value, then you can just say:

<pre><code>foo.copy(n = 3)
</code></pre>

blocks|key|1309367|text|好吧，我还得再加一个。Scala中的每个Regex对象都有一个提取器(参见上面oxbox_lakes的答案)，可以让您访问匹配组。所以你可以这样做：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1309368|//+Regex+to+split+a+date+in+the+format+Y/M/D.
val+regex+=+"(\\d%2B)/(\\d%2B)/(\\d%2B)".r
val+regex(year,+month,+day)+=+"2010/1/13"|code-block|syntax|javascript|1309369|如果你不习惯使用模式匹配和提取器，第二行看起来很混乱。无论何时定义val或var，关键字后面的不只是一个标识符，而是一个模式。这就是为什么它是有效的：|1309370|val+(a,+b,+c)+=+(1,+3.14159,+"Hello,+world")|1309371|右边的表达式创建了一个可以匹配模式(a,+b,+c)的Tuple3[Int,+Double,+String]。|1309372|大多数情况下，您的模式使用的提取器是单例对象的成员。例如，如果您编写了如下模式|1309373|Some(value)|1309374|然后，您隐式地调用了提取器Some.unapply。|1309375|但是您也可以在模式中使用类实例，这就是这里正在发生的事情。val正则表达式是Regex的一个实例，当您在模式中使用它时，您隐式地调用了regex.unapplySeq+(unapply与unapplySeq不在此答案的讨论范围内)，它将匹配组提取到一个Seq[String]中，其元素按顺序分配给变量year、month和day。|1309376|entityMap^0|K|5|0|0|X|3|11|3|0|0|H|9|R|R|0|0|0|D|C|0|12|5|1V|G|2D|7|2L|A|3I|B|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1F|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|1G|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|W|3|X|5|6|7|1K|8|@$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]]|Z|$]]

Okay, I had to add one more. Every <code>Regex</code> object in Scala has an extractor (see answer from oxbox_lakes above) that gives you access to the match groups. So you can do something like:

<pre><code>// Regex to split a date in the format Y/M/D.
val regex = "(\\d+)/(\\d+)/(\\d+)".r
val regex(year, month, day) = "2010/1/13"
</code></pre>

The second line looks confusing if you're not used to using pattern matching and extractors. Whenever you define a <code>val</code> or <code>var</code>, what comes after the keyword is not simply an identifier but rather a pattern. That's why this works:

<pre><code>val (a, b, c) = (1, 3.14159, "Hello, world")
</code></pre>

The right hand expression creates a <code>Tuple3[Int, Double, String]</code> which can match the pattern <code>(a, b, c)</code>.

Most of the time your patterns use extractors that are members of singleton objects. For example, if you write a pattern like

<pre><code>Some(value)
</code></pre>

then you're implicitly calling the extractor <code>Some.unapply</code>.

But you can also use class instances in patterns, and that is what's happening here. The val regex is an instance of <code>Regex</code>, and when you use it in a pattern, you're implicitly calling <code>regex.unapplySeq</code> (<code>unapply</code> versus <code>unapplySeq</code> is beyond the scope of this answer), which extracts the match groups into a <code>Seq[String]</code>, the elements of which are assigned in order to the variables year, month, and day.

blocks|key|1309424|text|在Scala2.8中，你可以通过使用scala.util.control.TailCalls包来实现尾递归方法(实际上它就是一种弹跳)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1309425|举个例子：|1309426|def+u(n:Int):TailRec[Int]+=+{
++if+(n==0)+done(1)
++else+tailcall(v(n/2))
}
def+v(n:Int):TailRec[Int]+=+{
++if+(n==0)+done(5)
++else+tailcall(u(n-1))
}
val+l=for(n<-0+to+5)+yield+(n,u(n).result,v(n).result)
println(l)|code-block|syntax|javascript|1309427|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

In scala 2.8 you can have tail-recursive methods by using the package scala.util.control.TailCalls (in fact it's trampolining).

An example:

<pre><code>def u(n:Int):TailRec[Int] = {
 if (n==0) done(1)
 else tailcall(v(n/2))
}
def v(n:Int):TailRec[Int] = {
 if (n==0) done(5)
 else tailcall(u(n-1))
}
val l=for(n&lt;-0 to 5) yield (n,u(n).result,v(n).result)
println(l)
</code></pre>

blocks|key|1309470|text|在Scala2.8中，您可以将@specialized添加到泛型类/方法中。这将为原语类型(扩展AnyVal)创建类的特殊版本，并节省不必要的装箱/拆箱成本：class+Foo[@specialized+T]...|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1309471|您可以选择AnyVals的一个子集：class+Foo[@specialized(Int,Boolean)+T]...|1309472|entityMap^0|27|S|0|I|15|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

in scala 2.8 you can add @specialized to your generic classes/methods. This will create special versions of the class for primitive types (extending AnyVal) and save the cost of un-necessary boxing/unboxing :
<code>class Foo[@specialized T]...</code>

You can select a subset of AnyVals :
<code>class Foo[@specialized(Int,Boolean) T]...</code>

blocks|key|1524574|text|使用Scala的Streams：http://www.codecommit.com/blog/scala/infinite-lists-for-the-finitely-patient构建无限数据结构|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1524575|entityMap|0|LINK|mutability|MUTABLE|url|http://www.codecommit.com/blog/scala/infinite-lists-for-the-finitely-patient^0|8|6|G|24|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Build infinite data structures with Scala's <code>Stream</code>s :
<a href="http://www.codecommit.com/blog/scala/infinite-lists-for-the-finitely-patient" rel="nofollow noreferrer">http://www.codecommit.com/blog/scala/infinite-lists-for-the-finitely-patient</a>

blocks|key|1309863|text|结果类型取决于隐式解析。这可以为您提供一种多分派的形式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1309864|scala>+trait+PerformFunc[A,B]+{+def+perform(a+:+A)+:+B+}
defined+trait+PerformFunc

scala>+implicit+val+stringToInt+=+new+PerformFunc[String,Int]+{
++def+perform(a+:+String)++=+5
}
stringToInt:+java.lang.Object+with+PerformFunc[String,Int]+=+$anon$1@13ccf137

scala>+implicit+val+intToDouble+=+new+PerformFunc[Int,Double]+{
++def+perform(a+:+Int)+=+1.0
}
intToDouble:+java.lang.Object+with+PerformFunc[Int,Double]+=+$anon$1@74e551a4

scala>+def+foo[A,+B](x+:+A)(implicit+z+:+PerformFunc[A,B])+:+B+=+z.perform(x)
foo:+[A,B](x:+A)(implicit+z:+PerformFunc[A,B])B

scala>+foo("HAI")
res16:+Int+=+5

scala>+foo(1)
res17:+Double+=+1.0|code-block|syntax|javascript|1309865|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Result types are dependent on implicit resolution. This can give you a form of multiple dispatch:

<pre><code>scala&gt; trait PerformFunc[A,B] { def perform(a : A) : B }
defined trait PerformFunc

scala&gt; implicit val stringToInt = new PerformFunc[String,Int] {
 def perform(a : String) = 5
}
stringToInt: java.lang.Object with PerformFunc[String,Int] = $anon$1@13ccf137

scala&gt; implicit val intToDouble = new PerformFunc[Int,Double] {
 def perform(a : Int) = 1.0
}
intToDouble: java.lang.Object with PerformFunc[Int,Double] = $anon$1@74e551a4

scala&gt; def foo[A, B](x : A)(implicit z : PerformFunc[A,B]) : B = z.perform(x)
foo: [A,B](x: A)(implicit z: PerformFunc[A,B])B

scala&gt; foo("HAI")
res16: Int = 5

scala&gt; foo(1)
res17: Double = 1.0
</code></pre>

blocks|key|1309916|text|扩展语言。我一直想用Java做这样的事情(不能)。但在Scala中，我可以拥有：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1309917|++def+timed[T](thunk:+=>+T)+=+{
++++val+t1+=+System.nanoTime
++++val+ret+=+thunk
++++val+time+=+System.nanoTime+-+t1
++++println("Executed+in:+"+%2B+time/1000000.0+%2B+"+millisec")
++++ret
++}|code-block|syntax|javascript|1309918|然后写下：|1309919|val+numbers+=+List(12,+42,+3,+11,+6,+3,+77,+44)
val+sorted+=+timed+{+++//+"timed"+is+a+new+"keyword"!
++numbers.sortWith(_<_)
}
println(sorted)|1309920|并获取|1309921|Executed+in:+6.410311+millisec
List(3,+3,+6,+11,+12,+42,+44,+77)|1309922|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Extending the language. I always wanted to do something like this in Java (couldn't). But in Scala I can have:

<pre><code> def timed[T](thunk: =&gt; T) = {
 val t1 = System.nanoTime
 val ret = thunk
 val time = System.nanoTime - t1
 println("Executed in: " + time/1000000.0 + " millisec")
 ret
 }
</code></pre>

and then write:

<pre><code>val numbers = List(12, 42, 3, 11, 6, 3, 77, 44)
val sorted = timed { // "timed" is a new "keyword"!
 numbers.sortWith(_&lt;_)
}
println(sorted)
</code></pre>

and get

<pre><code>Executed in: 6.410311 millisec
List(3, 3, 6, 11, 12, 42, 44, 77)
</code></pre>

blocks|key|1309991|text|Case类自动混合Product特征，提供对字段的无类型、索引访问，而不需要任何反射：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1309992|case+class+Person(name:+String,+age:+Int)

val+p+=+Person("Aaron",+28)
val+name+=+p.productElement(0)+//+name+=+"Aaron":+Any
val+age+=+p.productElement(1)+//+age+=+28:+Any
val+fields+=+p.productIterator.toList+//+fields+=+List[Any]("Aaron",+28)|code-block|syntax|javascript|1309993|此功能还提供了一种更改toString方法输出的简化方法：|offset|length|style|CODE|1309994|case+class+Person(name:+String,+age:+Int)+{
+++override+def+productPrefix+=+"person:+"
}

//+prints+"person:+(Aaron,28)"+instead+of+"Person(Aaron,+28)"
println(Person("Aaron",+28))+|1309995|entityMap^0|0|0|B|8|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Case classes automatically mixin the Product trait, providing untyped, indexed access to the fields without any reflection:

<pre><code>case class Person(name: String, age: Int)

val p = Person("Aaron", 28)
val name = p.productElement(0) // name = "Aaron": Any
val age = p.productElement(1) // age = 28: Any
val fields = p.productIterator.toList // fields = List[Any]("Aaron", 28)
</code></pre>

This feature also provides a simplified way to alter the output of the <code>toString</code> method:

<pre><code>case class Person(name: String, age: Int) {
 override def productPrefix = "person: "
}

// prints "person: (Aaron,28)" instead of "Person(Aaron, 28)"
println(Person("Aaron", 28)) 
</code></pre>

blocks|key|1310044|text|可以使用'+with‘关键字组成结构类型|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1310045|object+Main+{
++type+A+=+{def+foo:+Unit}
++type+B+=+{def+bar:+Unit}

++type+C+=+A+with+B

++class+myA+{
++++def+foo:+Unit+=+println("myA.foo")
++}


++class+myB+{
++++def+bar:+Unit+=+println("myB.bar")
++}
++class+myC+extends+myB+{
++++def+foo:+Unit+=+println("myC.foo")
++}

++def+main(args:+Array[String]):+Unit+=+{+
++++val+a:+A+=+new+myA+
++++a.foo
++++val+b:+C+=+new+myC+
++++b.bar
++++b.foo
++}
}|code-block|syntax|javascript|1310046|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can compose structural types with the 'with' keyword

<pre><code>object Main {
 type A = {def foo: Unit}
 type B = {def bar: Unit}

 type C = A with B

 class myA {
 def foo: Unit = println("myA.foo")
 }


 class myB {
 def bar: Unit = println("myB.bar")
 }
 class myC extends myB {
 def foo: Unit = println("myC.foo")
 }

 def main(args: Array[String]): Unit = { 
 val a: A = new myA 
 a.foo
 val b: C = new myC 
 b.bar
 b.foo
 }
}
</code></pre>

blocks|key|1525086|text|不知道这是不是真的隐藏了，但我觉得它很好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1525087|接受2个类型参数的类型构造函数可以用中缀表示法编写|1525088|object+Main+{+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++class+FooBar[A,+B]

++def+main(args:+Array[String]):+Unit+=+{
++++var+x:+FooBar[Int,+BigInt]+=+null
++++var+y:+Int+FooBar+BigInt+++=+null
++}
}|code-block|syntax|javascript|1525089|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Dunno if this is really hidden, but I find it quite nice.

Typeconstructors that take 2 type parameters can be written in infix notation

<pre><code>object Main { 
 class FooBar[A, B]

 def main(args: Array[String]): Unit = {
 var x: FooBar[Int, BigInt] = null
 var y: Int FooBar BigInt = null
 }
}
</code></pre>

blocks|key|1310171|text|闭包中的隐式参数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1310172|函数参数可以标记为隐式，就像方法一样。在函数体的范围内，隐式参数是可见的，并且适合隐式解析：|1310173|trait+Foo+{+def+bar+}

trait+Base+{
++def+callBar(implicit+foo:+Foo)+=+foo.bar
}

object+Test+extends+Base+{
++val+f:+Foo+=>+Unit+=+{+implicit+foo+=>
++++callBar
++}
++def+test+=+f(new+Foo+{
++++def+bar+=+println("Hello")
++})
}|code-block|syntax|javascript|1310174|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Implicit arguments in closures.

A function argument can be marked as implicit just as with methods. Within the scope of the body of the function the implicit parameter is visible and eligible for implicit resolution:

<pre><code>trait Foo { def bar }

trait Base {
 def callBar(implicit foo: Foo) = foo.bar
}

object Test extends Base {
 val f: Foo =&gt; Unit = { implicit foo =&gt;
 callBar
 }
 def test = f(new Foo {
 def bar = println("Hello")
 })
}
</code></pre>

blocks|key|1310213|text|Scala的Java双括号初始化器的等价物。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1310214|Scala允许您使用包含初始化该类实例的语句的类体(构造函数)创建匿名子类。|1310215|此模式在构建基于组件的用户界面(例如Swing、Vaadin)时非常有用，因为它允许创建UI组件并更简洁地声明其属性。|1310216|有关详细信息，请参阅http://spot.colorado.edu/~reids/papers/how-scala-experience-improved-our-java-development-reid-2011.pdf。|offset|length|1310217|下面是一个创建Vaadin按钮的示例：|1310218|val+button+=+new+Button("Click+me"){
+setWidth("20px")
+setDescription("Click+on+this")
+setIcon(new+ThemeResource("icons/ok.png"))
}|code-block|syntax|javascript|1310219|entityMap|0|LINK|mutability|MUTABLE|url|http://spot.colorado.edu/~reids/papers/how-scala-experience-improved-our-java-development-reid-2011.pdf^0|0|0|0|A|2V|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@$H|12|I|13|1|14]]|A|$]]|$1|J|3|K|5|6|7|15|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|16|8|@]|9|@]|A|$O|P]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

<h2>Scala's equivalent of Java double brace initializer.</h2>

Scala allows you to create an anonymous subclass with the body of the class (the constructor) containing statements to initialize the instance of that class. 

This pattern is very useful when building component-based user interfaces (for example Swing , Vaadin) as it allows to create UI components and declare their properties more concisely.

See <a href="http://spot.colorado.edu/~reids/papers/how-scala-experience-improved-our-java-development-reid-2011.pdf" rel="nofollow">http://spot.colorado.edu/~reids/papers/how-scala-experience-improved-our-java-development-reid-2011.pdf</a> for more information.

Here is an example of creating a Vaadin button:

<pre><code>val button = new Button("Click me"){
 setWidth("20px")
 setDescription("Click on this")
 setIcon(new ThemeResource("icons/ok.png"))
}
</code></pre>

What are the hidden features of Scala that every Scala developer should be aware of?

One hidden feature per answer, please.

Hidden features of Scala

数据结构

Java

每个Scala开发人员都应该知道Scala的隐藏特性是什么？请为每个答案提供一个隐藏功能。

问Scala的隐藏功能
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala的隐藏功能EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala的隐藏功能
EN