Scala 2.8과 Scala 2.7의 가장 큰 차이점은 무엇입니까?

Scala 2.8과 Scala 2.7의 가장 큰 차이점은 무엇입니까?

---

저는 Scala 2.7.5에서 다소 큰 프로그램을 작성했으며 이제 버전 2.8을 기대하고 있습니다. 하지만 스칼라 진화의이 큰 도약이 저에게 어떤 영향을 미칠지 궁금합니다.

이 두 버전의 Scala 간의 가장 큰 차이점은 무엇입니까? 그리고 아마도 가장 중요한 것은 :

• 나는 윌 필요 아무것도 재 작성?
• 나는 마십시오 원하는 단지 멋진 새로운 기능을 활용하는 것도 재 작성?
• 일반적으로 Scala 2.8의 새로운 기능은 정확히 무엇입니까?

---

여기 에서 Scala2.8 (2009 년 4 월) 의 새로운 기능에 대한 미리보기를 찾을 수 있으며 , 최근 이 기사 (2009 년 6 월)로 완성되었습니다.

• 명명 된 인수와 기본 인수
• 중첩 된 주석
• 패키지 개체
• @ 전문
• 향상된 컬렉션 (여기에서 일부 재 작성이 필요할 수 있음)
• REPL은 명령 완성 기능을 갖습니다 ( 이 기사의 기타 트릭에 대한 자세한 내용 ).
• 새로운 컨트롤 추상화 (연속 또는 중단)
• 개선 사항 (스윙 래퍼, 퍼포먼스 등)

"코드 재 작성"은 의무가 아니지만 (일부 개선 된 컬렉션을 사용하는 경우 제외) 연속 과 같은 일부 기능 ( Wikipedia : 제어 상태의 추상적 인 표현 또는 "나머지 계산"또는 "실행할 코드의 나머지") ")는 새로운 아이디어를 제공 할 수 있습니다. Daniel ( 이 스레드에 훨씬 더 상세하고 구체적인 답변 을 게시 한 사람)이 작성한 좋은 소개가 여기에 있습니다 .

참고 : Netbeans의 Scala 는 일부 2.8 nightly-build에서 작동하는 것 같습니다 (vs. 2.7.x 의 공식 페이지 ).

---

도약하기

마이그레이션 할 때 컴파일러는 몇 가지 안전망을 제공 할 수 있습니다.

1. 를 사용하여 2.7.7에 대해 이전 코드를 컴파일 -deprecation하고 모든 지원 중단 경고의 권장 사항을 따릅니다.

2. 제거되지 않은 패키지를 사용하도록 코드를 업데이트하십시오. 이 정규식 검색 바꾸기를 반복적으로 실행하여 기계적으로 수행 할 수 있습니다.

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

3. 편집증 명령 줄 옵션을 사용하여 2.8.0 컴파일러로 컴파일 -deprecation -Xmigration -Xcheckinit -Xstrict-warnings -Xwarninit

4. error 오류를 수신 could not find implicit value for evidence parameter of type scala.reflect.ClassManifest[T]하는 경우 유형 매개 변수에 암시 적 매개 변수 (또는 이에 상응하는 컨텍스트 바인딩)를 추가해야합니다.

   전에:

   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]
   

   를 호출 listToArray하고 자체가 T유형 매개 변수로 취하는 모든 메소드 는 Manifest도 암시 적 매개 변수로 허용해야합니다. 자세한 내용은 어레이 SID 를 참조하십시오.

5. 머지 않아 다음과 같은 오류가 발생합니다.

   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]
                ^
   

   유형 Map이 .NET 용 Predef의 별칭임을 이해해야합니다 collection.immutable.Map.

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

   Map읽기 전용 인터페이스 : collection.Map, 변경 불가능한 구현 : collection.immutable.Map및 변경 가능한 구현 : 이라는 세 가지 유형이 있습니다 collection.mutable.Map. 또한 라이브러리는 병렬 특성 집합에서 동작을 정의 MapLike하지만 실제로 구현 세부 사항입니다.

이익 거두기

1. 일부 메서드 오버로딩을 명명 된 기본 매개 변수로 바꿉니다.

2. copy케이스 클래스 의 생성 된 메소드를 사용하십시오 .

     scala> case class Foo(a: Int, b: String)
     defined class Foo
   
     scala> Foo(1, "a").copy(b = "b")
     res1: Foo = Foo(1,b)
   

3. 에서 메소드 서명을 일반화 List하는 Seq또는 Iterable나 Traversable. 컬렉션 클래스는 깨끗한 계층 구조에 있으므로보다 일반적인 유형을 허용 할 수 있습니다.
4. 주석을 사용하여 Java 라이브러리와 통합합니다. 이제 중첩 된 어노테이션을 지정하고 어노테이션이 필드 또는 메소드를 대상으로하는지 여부를 세밀하게 제어 할 수 있습니다. 이것은 Scala 코드와 함께 Spring 또는 JPA를 사용하는 데 도움이됩니다.

마이그레이션을 시작할 때 무시해도되는 다른 많은 새 기능 (예 : @specialized및 계속)이 있습니다.

---

VonC의 답변은 개선하기 어렵 기 때문에 노력하지도 않을 것입니다. 나는 그가 언급하지 않은 다른 것들을 다룰 것입니다.

첫째, 더 이상 사용되지 않는 항목이 사라집니다. 코드에 지원 중단 경고가있는 경우 더 이상 컴파일되지 않을 가능성이 높습니다.

다음으로 Scala의 라이브러리가 확장되고 있습니다. 대부분 예외를 Either또는 로 포착 Option하거나 AnyRef를에 null매핑 된 Option으로 변환하는 것과 같은 일반적인 작은 패턴 None입니다. 이러한 것들은 대부분 눈에 띄지 않게 지나갈 수 있지만 블로그에 무언가를 게시하고 나중에 누군가가 이미 Scala 2.8에 있다고 말하는 데 지쳐 있습니다. 글쎄, 사실, 나는 그것에 지치지 않고 오히려 행복하게 익숙해졌습니다. 그리고 컬렉션, 여기에 대해 이야기하고 있지 않다 되는 주요 개정을 받고.

이제 사람들이 이러한 라이브러리 개선의 실제 사례를 답변으로 게시하면 좋을 것 입니다. 나는 그러한 모든 답변을 기꺼이 찬성 할 것입니다.

REPL은 단순한 명령 완성이 아닙니다. 객체에 대한 AST를 검사하는 기능이나 REPL에 속하는 코드에 중단 점을 삽입하는 기능을 포함하여 많은 것을 얻고 있습니다.

또한 Scala의 컴파일러는 IDE에 빠른 부분 컴파일을 제공 할 수 있도록 수정되고 있습니다. 즉, 코드에 대해 Scala 컴파일러 자체에 쿼리하여 Scala에 대해 훨씬 더 "알고있을"것으로 기대할 수 있습니다.

하나의 큰 변화는 많은 사람들이 알아 차리지 못하지만 도서관 작성자와 사용자 모두의 문제를 줄여 줄 것입니다. 지금 다음을 작성하면 :

package com.mystuff.java.wrappers

import java.net._

당신은하지 자바의 가져 net라이브러리 만 com.mystuff.java의 net라이브러리로 com, com.mystuff, com.mystuff.java및 com.mystuff.java.wrappers모든 범위 내에서 얻고, java내부를 볼 수 있습니다 com.mystuff. Scala 2.8에서는 wrappers범위 만 지정됩니다. 때로는 나머지 일부가 Scope에 있기를 원하기 때문에 package이제 대체 구문이 허용됩니다.

package com.mystuff.factories
package ligthbulbs

이는 다음과 같습니다.

package com.mystuff.factories {
  package lightbulbs {
    ...
  }
}

그리고 모두 얻을 발생 factories및 lightbulbs범위에있다.

---

나는 윌 필요 아무것도 재 작성?

def takesArray(arr: Array[AnyRef]) {…}

def usesVarArgs(obs: AnyRef*) {
    takesArray(obs)
}

될 필요가

def usesVarArgs(obs: AnyRef*) {
    takesArray(obs.toArray)
}

IRC 채널을 방문해야했지만 여기서 시작해야한다는 것을 깨달았습니다.

---

다음은 2.2부터 Scala를 사용해온 Eric Willigers의 체크리스트입니다. 이 항목 중 일부는 더 최근 사용자에게 날짜가 표시됩니다.

* 외부 패키지에서 명시 적으로 가져 오기 *

우리가 가지고 있다고 가정

package a
class B

변화

package a.c
class D extends B

...에

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

or

package a
package c
class D extends B

* Use fully qualified package name when importing from outer package *

Suppose we have

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

Change

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

to

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

* When explicitly specifying type parameters in container method calls, add new type parameters *

Change

list.map[Int](f)

to

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

Change

map.transform[Value](g)

to

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

* Create sorted map using Ordering instead of conversion to Ordered *

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

* Import the implicit conversions that replace scala.collection.jcl *

* Immutable Map .update becomes .updated *

*** Migrate from newly deprecated List methods --
* elements * remove * sort * List.flatten(someList) * List.fromString(someList, sep) * List.make

*** Use List methods * diff * iterator * filterNot * sortWith * someList.flatten * someList.split(sep) * List.fill

* classpath when using scala.tools.nsc.Settings *

http://thread.gmane.org/gmane.comp.lang.scala/18245/focus=18247 settings.classpath.value = System.getProperty("java.class.path")

* Avoid error: _ must follow method; cannot follow (Any) => Boolean *

Replace

list.filter(that.f _)

with

list.filter(that f _)

or

list.filter(that.f(_))

> > >

* Migrate from deprecated Enumeration methods iterator map * Use Enumeration methods values.iterator values.map

* Migrate from deprecated Iterator.fromValues(a, b, c, d) * Use Iterator(a, b, c, d)

* Avoid deprecated type Collection * Use Iterable instead

* Change initialisation order *

Suppose we have

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

Replace

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

with

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

* Avoid unneeded val in for (val x <- ...) *

* Avoid trailing commas *

참고URL : https://stackoverflow.com/questions/1243794/what-are-the-biggest-differences-between-scala-2-8-and-scala-2-7