Scala 2.8和Scala 2.7之间最大的区别是什么？_Scala

Scala 2.8和Scala 2.7之间最大的区别是什么？

scala

Scala 2.8和Scala 2.7之间最大的区别是什么？,scala,Scala,我已经用Scala 2.7.5编写了一个相当大的程序，现在我期待着2.8版。但我很好奇Scala进化过程中的这一重大飞跃将如何影响我这两个版本的Scala之间最大的区别是什么？也许最重要的是：我需要重写什么吗我想重写任何东西只是为了利用一些很酷的新功能吗 Scala 2.8的总体新特性是什么您可以在这里找到a（2009年4月），最近完成（2009年6月）命名参数和默认参数嵌套注释包对象 @专门的改进的集合（此处可能需要一些重写） REPL将完成命令（更多）新控件抽象（继续或

我已经用Scala 2.7.5编写了一个相当大的程序，现在我期待着2.8版。但我很好奇Scala进化过程中的这一重大飞跃将如何影响我

这两个版本的Scala之间最大的区别是什么？也许最重要的是：

我需要重写什么吗
我想重写任何东西只是为了利用一些很酷的新功能吗
Scala 2.8的总体新特性是什么

您可以在这里找到a（2009年4月），最近完成（2009年6月）

命名参数和默认参数
嵌套注释
包对象
@专门的
改进的集合（此处可能需要一些重写）
REPL将完成命令（更多）
新控件抽象（继续或中断）
增强功能（Swing包装、性能等）

“重写代码”不是一项义务（除了使用一些改进的集合），但是一些特性，如（：控件状态的抽象表示，或“剩余计算”或“剩余要执行的代码”）可以给您一些新的想法。一个很好的介绍是，作者是（他在这篇文章中也发表了很多）

注意：似乎与一些2.8夜间构建（与之相比）

VonC的答案很难改进，所以我甚至不会尝试。我将介绍一些他没有提到的其他东西

首先，一些不推荐的东西会被淘汰。如果您的代码中有弃用警告，那么它很可能不再编译

接下来，Scala的库正在扩展。大多数情况下，常见的小模式包括将异常捕获到

或选项中，或将AnyRef转换为null
映射到None
的选项。这些东西通常不会被注意到，但我已经厌倦了在博客上发布一些东西，后来有人告诉我它已经在Scala 2.8上了。嗯，事实上，我并没有厌倦它，相反，我很高兴地习惯了。我这里不是说这些藏品，它们正在进行重大修订
现在，如果人们把图书馆改进的实际例子作为答案贴出来，那就太好了。我很乐意投票支持所有这些答案
REPL不仅仅是命令完成。它得到了很多东西，包括检查对象的AST的能力，或者在REPL中插入断点的能力
此外，Scala的编译器正在进行修改，以便能够为IDE提供快速的部分编译，这意味着我们可以期望它们对Scala更加“了解”——通过查询Scala编译器本身的代码
一个大的变化可能会在许多人没有注意到的情况下通过，尽管它会减少图书馆作者和用户的问题。现在，如果您编写以下内容：
package com.mystuff.java.wrappers

import java.net._

您正在导入的不是Java的net
库，而是com.mystuff.Java
的net
库，因为com
、com.mystuff
、com.mystuff.Java
和com.mystuff.Java.wrappers
都在范围内，而Java
可以在com.mystuff
中找到。在Scala 2.8中，只有包装器
具有作用域。由于有时您希望其他部分在范围内，因此现在允许使用另一种包
语法：
package com.mystuff.factories
package ligthbulbs

这相当于：
package com.mystuff.factories {
  package lightbulbs {
    ...
  }
}

而且恰巧工厂
和灯泡
都进入了范围
我需要重写什么吗
需要成为
def usesVarArgs(obs: AnyRef*) {
    takesArray(obs.toArray)
}

我不得不访问IRC频道，但后来意识到我应该从这里开始。
这是Eric Willigers的清单，他从2.2开始使用Scala。对于最近的用户来说，有些东西似乎过时了
*从外部软件包显式导入*
假设我们有
改变
到
或
*从外部软件包导入时使用完全限定的软件包名称*
假设我们有
改变
到
*在容器方法调用中显式指定类型参数时，添加新的类型参数*
改变
到
改变
到
*使用排序而不是转换为已排序创建已排序地图*
*导入替换scala.collection.jcl*的隐式转换
*不可变映射。更新变为。更新*
***从新弃用的列表方法迁移--

*元素
*删除
*排序
*List.plant（someList）
*List.fromString（someList，sep）
*List.make

***使用列表方法
*diff
*迭代器
*filterNot
*sortWith
*someList.flatten
*someList.split（sep）
*列表。填写

*使用scala.tools.nsc.Settings时的类路径*

settings.classpath.value=System.getProperty（“java.class.path”）
*避免错误：\必须遵循方法；不能跟在（Any）=>Boolean*
替换
与
或
>
>
>
*从不推荐的枚举方法迁移迭代器映射*
使用枚举方法values.iterator
values.map

*从不推荐的迭代器迁移。从值（a、b、c、d）
*
使用迭代器（a，b，c，d）

*避免弃用类型集合
*
改用Iterable

*更改初始化顺序*
def usesVarArgs(obs: AnyRef*) {
    takesArray(obs.toArray)
}

package a
class B

package a.c
class D extends B

package a.c
import a.B
class D extends B

package a
package c
class D extends B

package a.b
object O { val x = 1 }

package a.b.c
import b.O.x

package a.b.c
import a.b.O.x

list.map[Int](f)

list.map[Int, List[Int]](f)

map.transform[Value](g)

map.transform[Value, Map[Key, Value]](g)

 [scalac]  found   : (String) => Ordered[String]
 [scalac]  required: Ordering[String]
 [scalac]         TreeMap[String, Any](map.toList: _*)(stringToCaseInsensitiveOrdered _)

list.filter(that.f _)

list.filter(that f _)

list.filter(that.f(_))

trait T {
  val v
  val w = v + v
}

class C extends T {
  val v = "v"
}

class C extends {
  val v = "v"
} with T

s/^(package com.example.project.*)\.(\w+)/$1\npackage $2/g

scala> def listToArray[T](ls: List[T]): Array[T] = ls.toArray
<console>:5: error: could not find implicit value for evidence parameter of type         scala.reflect.ClassManifest[T]
       def listToArray[T](ls: List[T]): Array[T] = ls.toArray                                              ^

scala> def listToArray[T: Manifest](ls: List[T]): Array[T] = ls.toArray
listToArray: [T](ls: List[T])(implicit evidence$1: Manifest[T])Array[T]

scala> def listToArray[T](ls: List[T])(implicit m: Manifest[T]): Array[T] = ls.toArray          
listToArray: [T](ls: List[T])(implicit m: Manifest[T])Array[T]

scala> collection.Map(1 -> 2): Map[Int, Int]
<console>:6: error: type mismatch;
 found   : scala.collection.Map[Int,Int]
 required: Map[Int,Int]
       collection.Map(1 -> 2): Map[Int, Int]
             ^

 object Predef {
     type Map[A, B] = collection.immutable.Map[A, B]
     val Map = collection.immutable.Map
 }

  scala> case class Foo(a: Int, b: String)
  defined class Foo

  scala> Foo(1, "a").copy(b = "b")
  res1: Foo = Foo(1,b)