Merge branch 'travissarles-master' of github.com:scala/scala.github.com into travissarles-master

heathermiller · heathermiller · commit 04a52b7d4683 · 2017-07-24T17:38:20.000+02:00
diff --git a/conduct.html b/conduct.html
@@ -6,6 +6,6 @@
 <body>
   <h2>Redirecting you to the Scala Code of Conduct...</h2>
   <script type="text/javascript">
-    window.location.replace('http://scala-lang.org/conduct.html');
+    window.location.replace('http://scala-lang.org/conduct/');
   </script>
 </body>
diff --git a/overviews/collections/arrays.md b/overviews/collections/arrays.md
@@ -76,23 +76,24 @@ The `evenElems` method returns a new array that consist of all elements of the a
       val arr = new Array[T]((arr.length + 1) / 2)
                 ^
 
-What's required here is that you help the compiler out by providing some runtime hint what the actual type parameter of `evenElems` is. This runtime hint takes the form of a class manifest of type `scala.reflect.ClassManifest`. A class manifest is a type descriptor object which describes what the top-level class of a type is. Alternatively to class manifests there are also full manifests of type `scala.reflect.Manifest`, which describe all aspects of a type. But for array creation, only class manifests are needed.
+What's required here is that you help the compiler out by providing some runtime hint what the actual type parameter of `evenElems` is. This runtime hint takes the form of a class manifest of type `scala.reflect.ClassTag`. A class manifest is a type descriptor object which describes what the top-level class of a type is. Alternatively to class manifests there are also full manifests of type `scala.reflect.Manifest`, which describe all aspects of a type. But for array creation, only class manifests are needed.
 
 The Scala compiler will construct class manifests automatically if you instruct it to do so. "Instructing" means that you demand a class manifest as an implicit parameter, like this:
+    
+    def evenElems[T](xs: Vector[T])(implicit m: ClassTag[T]): Array[T] = ...
 
-    def evenElems[T](xs: Vector[T])(implicit m: ClassManifest[T]): Array[T] = ...
-
-Using an alternative and shorter syntax, you can also demand that the type comes with a class manifest by using a context bound. This means following the type with a colon and the class name `ClassManifest`, like this:
+Using an alternative and shorter syntax, you can also demand that the type comes with a class manifest by using a context bound. This means following the type with a colon and the class name `ClassTag`, like this:
 
+    import scala.reflect.ClassTag
     // this works
-    def evenElems[T: ClassManifest](xs: Vector[T]): Array[T] = {
+    def evenElems[T: ClassTag](xs: Vector[T]): Array[T] = {
       val arr = new Array[T]((xs.length + 1) / 2)
       for (i <- 0 until xs.length by 2)
         arr(i / 2) = xs(i)
       arr
     }
 
-The two revised versions of `evenElems` mean exactly the same. What happens in either case is that when the `Array[T]` is constructed, the compiler will look for a class manifest for the type parameter T, that is, it will look for an implicit value of type `ClassManifest[T]`. If such a value is found, the manifest is used to construct the right kind of array. Otherwise, you'll see an error message like the one above.
+The two revised versions of `evenElems` mean exactly the same. What happens in either case is that when the `Array[T]` is constructed, the compiler will look for a class manifest for the type parameter T, that is, it will look for an implicit value of type `ClassTag[T]`. If such a value is found, the manifest is used to construct the right kind of array. Otherwise, you'll see an error message like the one above.
 
 Here is some REPL interaction that uses the `evenElems` method.
 
@@ -104,15 +105,15 @@ Here is some REPL interaction that uses the `evenElems` method.
 In both cases, the Scala compiler automatically constructed a class manifest for the element type (first, `Int`, then `String`) and passed it to the implicit parameter of the `evenElems` method. The compiler can do that for all concrete types, but not if the argument is itself another type parameter without its class manifest. For instance, the following fails:
 
     scala> def wrap[U](xs: Vector[U]) = evenElems(xs)
-    <console>:6: error: No ClassManifest available for U.
+    <console>:6: error: No ClassTag available for U.
          def wrap[U](xs: Vector[U]) = evenElems(xs)
                                                ^
 
 What happened here is that the `evenElems` demands a class manifest for the type parameter `U`, but none was found. The solution in this case is, of course, to demand another implicit class manifest for `U`. So the following works:
 
-    scala> def wrap[U: ClassManifest](xs: Vector[U]) = evenElems(xs)
-    wrap: [U](xs: Vector[U])(implicit evidence$1: ClassManifest[U])Array[U]
+    scala> def wrap[U: ClassTag](xs: Vector[U]) = evenElems(xs)
+    wrap: [U](xs: Vector[U])(implicit evidence$1: scala.reflect.ClassTag[U])Array[U]
 
-This example also shows that the context bound in the definition of `U` is just a shorthand for an implicit parameter named here `evidence$1` of type `ClassManifest[U]`.
+This example also shows that the context bound in the definition of `U` is just a shorthand for an implicit parameter named here `evidence$1` of type `ClassTag[U]`.
 
-In summary, generic array creation demands class manifests. So whenever creating an array of a type parameter `T`, you also need to provide an implicit class manifest for `T`. The easiest way to do this is to declare the type parameter with a `ClassManifest` context bound, as in `[T: ClassManifest]`.
+In summary, generic array creation demands class manifests. So whenever creating an array of a type parameter `T`, you also need to provide an implicit class manifest for `T`. The easiest way to do this is to declare the type parameter with a `ClassTag` context bound, as in `[T: ClassTag]`.
diff --git a/sips/pending/_posts/2017-01-13-binary-compatibility.md b/sips/pending/_posts/2017-01-13-binary-compatibility.md
@@ -1,6 +1,6 @@
 ---
-layout: inner-page-no-masthead
-title: SIP XX - Improving binary compatibility with @stableABI
+layout: sip
+title: SIP-NN - Improving binary compatibility with @stableABI
 discourse: true
 ---
 
diff --git a/sips/sip-submission.md b/sips/sip-submission.md
@@ -76,7 +76,7 @@ a SIP or needs more work.
 After receiving the green light from the Process Lead, you can write up your
 idea and submit it as a SIP.
 
-A SIP is a Markdown document written in conformance with the [process template](https://github.com/scala/slip/blob/master/slip-template.md).
+A SIP is a Markdown document written in conformance with the [process template](https://github.com/scala/scala.github.com/blob/master/sips/sip-template.md).
 It ought to contain a clear specification of the proposed changes. When such
 changes significantly alter the compiler internals, the author is invited to
 provide a proof of concept. Delivering a basic implementation can speed up the
diff --git a/tutorials/tour/_posts/2017-02-13-variances.md b/tutorials/tour/_posts/2017-02-13-variances.md
@@ -135,7 +135,7 @@ Fortunately, the compiler stops us long before we could get this far.
 
 ### Other Examples
 
-Another example that can help one understand variance is `trait Function1[-T, R]` from the Scala standard library. `Function1` represents a function with one argument, where the first type parameter `T` represents the argument type, and the second type parameter `R` represents the return type. A `Function1` is contravariant over its argument type, and covariant over its return type. For this example we'll use the literal notation `A => B` to represent a `Function1[A, B]`.
+Another example that can help one understand variance is `trait Function1[-T, +R]` from the Scala standard library. `Function1` represents a function with one argument, where the first type parameter `T` represents the argument type, and the second type parameter `R` represents the return type. A `Function1` is contravariant over its argument type, and covariant over its return type. For this example we'll use the literal notation `A => B` to represent a `Function1[A, B]`.
 
 Assume the similar `Cat`, `Dog`, `Animal` inheritance tree used earlier, plus the following:
 
diff --git a/zh-cn/overviews/collections/arrays.md b/zh-cn/overviews/collections/arrays.md
@@ -9,7 +9,7 @@ num: 10
 language: zh-cn
 ---
 
-在Scala中，[数组](http://www.scala-lang.org/api/2.10.0/scala/Array.html)是一种特殊的collection。一方面，Scala数组与Java数组是一一对应的。即Scala数组Array[Int]可看作Java的Int[]，Array[Double]可看作Java的double[]，以及Array[String]可看作Java的String[]。但Scala数组比Java数组提供了更多内容。首先，Scala数组是一种泛型。即可以定义一个Array[T]，T可以是一种类型参数或抽象类型。其次，Scala数组与Scala序列是兼容的 - 在需要Seq[T]的地方可由Array[T]代替。最后，Scala数组支持所有的序列操作。这里有个实际的例子：
+在Scala中，[数组](http://www.scala-lang.org/api/{{ site.scala-version }}/scala/Array.html)是一种特殊的collection。一方面，Scala数组与Java数组是一一对应的。即Scala数组Array[Int]可看作Java的Int[]，Array[Double]可看作Java的double[]，以及Array[String]可看作Java的String[]。但Scala数组比Java数组提供了更多内容。首先，Scala数组是一种泛型。即可以定义一个Array[T]，T可以是一种类型参数或抽象类型。其次，Scala数组与Scala序列是兼容的 - 在需要Seq[T]的地方可由Array[T]代替。最后，Scala数组支持所有的序列操作。这里有个实际的例子：
 
     scala> val a1 = Array(1, 2, 3)
     a1: Array[Int] = Array(1, 2, 3)
@@ -76,16 +76,17 @@ evenElems方法返回一个新数组，该数组包含了参数向量xs的所有
       val arr = new Array[T]((arr.length + 1) / 2)
                 ^
 
-这里需要你做的就是通过提供一些运行时的实际元素类型参数的线索来帮助编译器处理。这个运行时的提示采取的形式是一个`scala.reflect.ClassManifest`类型的类声明。一个类声明就是一个类型描述对象，给对象描述了一个类型的顶层类。另外，类声明也有`scala.reflect.Manifest`类型的所有声明，它描述了类型的各个方面。但对于数组创建而言，只需要提供类声明。
+这里需要你做的就是通过提供一些运行时的实际元素类型参数的线索来帮助编译器处理。这个运行时的提示采取的形式是一个`scala.reflect.ClassTag`类型的类声明。一个类声明就是一个类型描述对象，给对象描述了一个类型的顶层类。另外，类声明也有`scala.reflect.Manifest`类型的所有声明，它描述了类型的各个方面。但对于数组创建而言，只需要提供类声明。
 
 如果你指示编译器那么做它就会自动的构建类声明。“指示”意味着你决定一个类声明作为隐式参数，像这样：
 
-    def evenElems[T](xs: Vector[T])(implicit m: ClassManifest[T]): Array[T] = ...
+    def evenElems[T](xs: Vector[T])(implicit m: ClassTag[T]): Array[T] = ...
     
 使用一个替换和较短的语法。通过用一个上下文绑定你也可以要求类型与一个类声明一起。这种方式是跟在一个冒号类型和类名为ClassManifest的后面，想这样：
 
+    import scala.reflect.ClassTag
     // this works
-    def evenElems[T: ClassManifest](xs: Vector[T]): Array[T] = {
+    def evenElems[T: ClassTag](xs: Vector[T]): Array[T] = {
       val arr = new Array[T]((xs.length + 1) / 2)
       for (i <- 0 until xs.length by 2)
         arr(i / 2) = xs(i)
@@ -104,16 +105,16 @@ evenElems方法返回一个新数组，该数组包含了参数向量xs的所有
 在这两种情况下，Scala编译器自动的为元素类型构建一个类声明（首先，Int,然后String）并且通过它传递evenElems 方法的隐式参数。编译器可以对所有的具体类型构造，但如果论点本身是另一个没有类声明的类型参数就不可以。例如，下面的错误：
 
     scala> def wrap[U](xs: Vector[U]) = evenElems(xs)
-    <console>:6: error: No ClassManifest available for U.
+    <console>:6: error: No ClassTag available for U.
          def wrap[U](xs: Vector[U]) = evenElems(xs)
                                                ^
 
 这里所发生的是，evenElems 需要一个类型参数U的类声明，但是没有发现。这种情况下的解决方案是，当然，是为了U的另一个隐式类声明。所以下面起作用了：
 
-    scala> def wrap[U: ClassManifest](xs: Vector[U]) = evenElems(xs)
-    wrap: [U](xs: Vector[U])(implicit evidence$1: ClassManifest[U])Array[U]
+    scala> def wrap[U: ClassTag](xs: Vector[U]) = evenElems(xs)
+    wrap: [U](xs: Vector[U])(implicit evidence$1: scala.reflect.ClassTag[U])Array[U]
 
-这个实例还显示在定义U的上下文绑定里这仅是一个简短的隐式参数命名为`ClassManifest[U]`类型的`evidence$1`。
+这个实例还显示在定义U的上下文绑定里这仅是一个简短的隐式参数命名为`ClassTag[U]`类型的`evidence$1`。
 
-总结，泛型数组创建需要类声明。所以每当创建一个类型参数T的数组，你还需要提供一个T的隐式类声明。最简单的方法是声明类型参数与ClassManifest的上下文绑定，如 `[T: ClassManifest]`。 
+总结，泛型数组创建需要类声明。所以每当创建一个类型参数T的数组，你还需要提供一个T的隐式类声明。最简单的方法是声明类型参数与ClassManifest的上下文绑定，如 `[T: ClassTag]`。 
 
