Merge branch 'master' into scala-jdk-OSS-support-policy

Author: SethTisue

_ja/overviews/collections/arrays.md

@@ -28,7 +28,7 @@ Scala 2.8 の設計はより単純なものだ。ほぼ全てのコンパイラ
 
     scala> val seq: Seq[Int] = a1
     seq: Seq[Int] = WrappedArray(1, 2, 3)
-    scala> val a4: Array[Int] = s.toArray
+    scala> val a4: Array[Int] = seq.toArray
     a4: Array[Int] = Array(1, 2, 3)
     scala> a1 eq a4
     res1: Boolean = true
@@ -50,7 +50,7 @@ Scala 2.8 の設計はより単純なものだ。ほぼ全てのコンパイラ
 
 実際には `WrappedArray` である `seq` に対して `reverse` を呼ぶと再び `WrappedArray` が返っているのが分かる。`WrappedArray` は `Seq` であり、`Seq` に対して `reverse` を呼ぶと再び `Seq` が返るため、この結果は論理的だ。一方、`ArrayOps` クラスの値 `ops` に対して `reverse` を呼ぶと、`Seq` ではなく、`Array` が返る。
 
-上記の `ArrayOps` の例は。`WrappedArray` との違いを示すためだけのかなり恣意的な物で、通常は `ArrayOps` クラスの値を定義することはありえない。単に配列に対して `Seq` メソッドを呼び出すだけでいい:
+上記の `ArrayOps` の例は `WrappedArray` との違いを示すためだけのかなり恣意的な物で、通常は `ArrayOps` クラスの値を定義することはありえない。単に配列に対して `Seq` メソッドを呼び出すだけでいい:
 
     scala> a1.reverse
     res4: Array[Int] = Array(3, 2, 1)

_ja/overviews/collections/conversions-between-java-and-scala-collections.md

@@ -15,8 +15,7 @@ language: ja
 Scala と同様に、Java
 にも豊富なコレクションライブラリがある。両者には多くの共通点がある。例えば、両方のライブラリともイテレータ、`Iterable`、集合、マップ、そして列を提供する。しかし、両者には重要な違いもある。特に、Scala では不変コレクションに要点を置き、コレクションを別のものに変換する演算も多く提供している。
 
-時として、コレクションを一方のフレームワークから他方へと渡す必要がある。例えば、既存の Java のコレクションを Scala のコレクションであるかのようにアクセスしたいこともあるだろう。もしくは、Scala のコレクションを Java のコレクションを期待している Java メソッドに渡したいと思うかもしれない。Scala は [`JavaConversions`](http://www.scala-lang.org/api/{{ site.scala-version }}/scala/collection/JavaConversions$.html) オブジェクトにより主要なコレクション間の暗黙の変換 (implicit conversion)
-を提供するため、簡単に相互運用できる。特に以下の型に関しては、双方向変換を提供する。
+時として、コレクションを一方のフレームワークから他方へと渡す必要がある。例えば、既存の Java のコレクションを Scala のコレクションであるかのようにアクセスしたいこともあるだろう。もしくは、Scala のコレクションを Java のコレクションを期待している Java メソッドに渡したいと思うかもしれない。Scala は [JavaConverters](http://www.scala-lang.org/api/{{ site.scala-version }}/scala/collection/JavaConverters$.html) オブジェクトにより主要なコレクション間の暗黙の変換を提供するため、簡単に相互運用できる。特に以下の型に関しては、双方向変換を提供する。
 
     Iterator               <=>     java.util.Iterator
     Iterator               <=>     java.util.Enumeration
@@ -27,25 +26,25 @@ Scala と同様に、Java
     mutable.Map            <=>     java.util.Map
     mutable.ConcurrentMap  <=>     java.util.concurrent.ConcurrentMap
 
-このような変換を作動させるには、[`JavaConversions`](http://www.scala-lang.org/api/{{ site.scala-version }}/scala/collection/JavaConversions$.html) オブジェクトからインポートするだけでいい:
+このような変換を作動させるには、[JavaConverters](http://www.scala-lang.org/api/{{ site.scala-version }}/scala/collection/JavaConverters$.html) オブジェクトからインポートするだけでいい:
 
-    scala> import collection.JavaConversions._
-    import collection.JavaConversions._
+    scala> import collection.JavaConverters._
+    import collection.JavaConverters._
 
-これで Scala コレクションとそれに対応する Java コレクションの自動変換が行われる。
+これで `asScala` 及び `asJava` 拡張メソッドを呼び出すことで Scala コレクションとそれに対応する Java コレクションの変換が行われる。
 
     scala> import collection.mutable._
     import collection.mutable._
-    scala> val jul: java.util.List[Int] = ArrayBuffer(1, 2, 3)
+    scala> val jul: java.util.List[Int] = ArrayBuffer(1, 2, 3).asJava
     jul: java.util.List[Int] = [1, 2, 3]
-    scala> val buf: Seq[Int] = jul
+    scala> val buf: Seq[Int] = jul.asScala
     buf: scala.collection.mutable.Seq[Int] = ArrayBuffer(1, 2, 3)
-    scala> val m: java.util.Map[String, Int] = HashMap("abc" -> 1, "hello" -> 2)
+    scala> val m: java.util.Map[String, Int] = HashMap("abc" -> 1, "hello" -> 2).asJava
     m: java.util.Map[String,Int] = {hello=2, abc=1}
 
 内部では、このような変換は全ての演算を委譲する「ラッパー」オブジェクトを作ることで実現されている。そのため、Java と Scala の間でコレクションを変換してもコレクションはコピーされることはない。興味深い特性として、例えば Java 型から対応する Scala 型に変換して再び Java 型に逆変換するといった、ラウンドトリップを実行した場合、始めた時と同一のオブジェクトが返ってくるというものがある。
 
-Scala コレクションの中には、Java 型に変換できるが、逆変換はできないというものもある。それらは以下の通り:
+他の Scala コレクションも Java に変換できるが、元の Scala 型には逆変換できない。それらは以下の通り:
 
     Seq           =>    java.util.List
     mutable.Seq   =>    java.utl.List
@@ -54,8 +53,9 @@ Scala コレクションの中には、Java 型に変換できるが、逆変換
 
 Java は可変コレクションと不変コレクションを型で区別しないため、例えば `scala.immutable.List` からの変換は、上書き演算を呼び出すと `UnsupportedOperationException` を発生する `java.util.List` を返す。次に具体例で説明する:
 
-    scala> jul = List(1, 2, 3)
+    scala> val jul = List(1, 2, 3).asJava
     jul: java.util.List[Int] = [1, 2, 3]
+    
     scala> jul.add(7)
     java.lang.UnsupportedOperationException
-            at java.util.AbstractList.add(AbstractList.java:131)
+            at java.util.AbstractList.add(AbstractList.java:148)

_ja/overviews/collections/maps.md

@@ -18,7 +18,7 @@ language: ja
 
 * **検索演算** には `apply`、`get`、`getOrElse`、`contains`、および `isDefinedAt` がある。これらはマップをキーから値への部分関数に変える。マップの最も基本的な検索メソッドは `def get(key): Option[Value]` だ。"`m get key`" という演算はマップが `key` に関連する値があるかを調べる。もしあれば、マップはその関連する値を `Some` に包んで返す。`key` がマップ中に定義されていなければ `get` は `None` を返す。マップはまた、任意のキーに関連する値を `Option` に包まずに直接返す `apply` メソッドも定義する。マップにキーが定義されていない場合は、例外が発生する。
 * **加算と更新演算**である `+`、`++`、`updated` は、マップに新しい対応関係を追加するか、既存の対応関係を更新する。
-<li> <b>減算</b>である <code>-</code>、 <code>--</code> は、対応関係をマップから削除する。</li> <!-- keep this html -->
+* **減算**である `-`、 `--` は、対応関係をマップから削除する。
 * **サブコレクション取得演算**である `keys`、`keySet`、`keysIterator`、`values`、`valuesIterator` は、マップのキーや値を様々な形で別に返す。
 * **変換演算**である `filterKeys` と `mapValues` は、既存のマップの対応関係をフィルターしたり変換することで新たなマップを生成する。
 

_ja/overviews/collections/overview.md

@@ -14,7 +14,7 @@ language: ja
 
 Scala のコレクションは、体系的に可変および不変コレクションを区別している。**可変** (mutable) コレクションは上書きしたり拡張することができる。これは副作用としてコレクションの要素を変更、追加、または削除することができることを意味する。一方、**不変** (immutable) コレクションは変わることが無い。追加、削除、または更新を模倣した演算は提供されるが、全ての場合において演算は新しいコレクションを返し、古いコレクションは変わることがない。
 
-コレクションクラスの全ては `scala.collection` パッケージもしくは `mutable`、`immutable`、`generic` のどれかのサブパッケージに定義されている。クライアントコードに必要なコレクションのクラスのほどんどには可変性に関して異なる特性を持つ 3つの形態が定義されおり、ぞれぞれ　`scala.collection`、`scala.collection.immutable`、か `scala.collection.mutable` のパッケージに存在する。
+コレクションクラスの全ては `scala.collection` パッケージもしくは `mutable`、`immutable`、`generic` のどれかのサブパッケージに定義されている。クライアントコードに必要なコレクションのクラスのほとんどには可変性に関して異なる特性を持つ 3つの形態が定義されており、それぞれ　`scala.collection`、`scala.collection.immutable`、か `scala.collection.mutable` のパッケージに存在する。
 
 `scala.collection.immutable` パッケージのコレクションは、誰にとっても不変であることが保証されている。
 そのようなコレクションは作成後には一切変更されることがない。したがって、異なる時点で何回同じコレクションの値にアクセスしても常に同じ要素を持つコレクションが得られることに依存できる。
@@ -40,7 +40,7 @@ Scala のコレクションは、体系的に可変および不変コレクシ
 このパッケージには、コレクションを実装するための基本的なパーツが含まれている。
 コレクションクラスがいくつかの演算を `generic` 内のクラスに委譲することはよくあるが、 フレームワークのユーザーが `generic` 内のクラスが必要になることは普通はありえない。
 
-利便性と後方互換性のために、いつくかの重要な型は `scala` パッケージ内に別名を定義してあるため、インポート無しで単純な名前でコレクションを使うことができる。[`List`](http://www.scala-lang.org/api/{{ site.scala-version }}/scala/collection/immutable/List.html) 型が良い例で、以下の名前でもアクセスすることができる
+利便性と後方互換性のために、いくつかの重要な型は `scala` パッケージ内に別名を定義してあるため、インポート無しで単純な名前でコレクションを使うことができる。[`List`](http://www.scala-lang.org/api/{{ site.scala-version }}/scala/collection/immutable/List.html) 型が良い例で、以下の名前でもアクセスすることができる
 
     scala.collection.immutable.List   // 定義元
     scala.List                        // scala パッケージのエイリアス経由
@@ -89,7 +89,7 @@ Scala のコレクションは、体系的に可変および不変コレクシ
 
 すべてのコレクションが `Traversable` によって提供される API をサポートするが、理にかなうところでは型を特殊化している。
 たとえば、`Traversable` クラスの `map` メソッドは別の `Traversable` を戻り値として返すが、結果の型はサブクラスでオーバーライドされる。
-たとえば、`List` が `map` を呼び出しても再び `List` が返ってき、`Set` が `map` を呼び出すと `Set` が返ってくる、といういう具合だ。
+たとえば、`List` が `map` を呼び出しても再び `List` が返ってき、`Set` が `map` を呼び出すと `Set` が返ってくる、という具合だ。
 
     scala> List(1, 2, 3) map (_ + 1)
     res0: List[Int] = List(2, 3, 4)
@@ -101,4 +101,4 @@ Scala のコレクションは、体系的に可変および不変コレクシ
 コレクションの階層のクラスのほとんどは基底、不変、可変の3種類とも存在する。
 唯一の例外は、可変コレクションにのみ存在する `Buffer` トレイトだ。
 
-これより、これらのクラスを一つづつ見ていく。
+これより、これらのクラスを一つずつ見ていく。

_ja/overviews/collections/seqs.md

@@ -17,7 +17,7 @@ language: ja
 以下の表にまとめられた列の演算は以下のカテゴリーに分けることができる:
 
 * **添字と長さの演算** `apply`、 `isDefinedAt`、 `length`、 `indices`、および `lengthCompare`。`Seq` では `apply` メソッドは添字の意味で使われるため、`Seq[T]`型の列は `Int` を引数 (添字) としてをとり、`T`型の要素を返す部分関数だ。つまり、`Seq[T]` は `PartialFunction[Int, T]` を継承する。列内の要素はゼロから列の長さ (`length`) − 1 まで添字付けられている。列の `length` メソッドは一般コレクションにおける `size` メソッドの別名だ。`lengthCompare` メソッドは、たとえどちらかの列が無限の長さを持っていても、二つの列の長さを比較することができる。
-* **添字検索演算**である `indexOf`、 `lastIndexOf`、 `indexofSlice`、 `lastIndexOfSlice`、 `indexWhere`、 `lastIndexWhere`、 `segmentLength`、 `prefixLength` は、渡された値もしくは条件関数に合致する要素の添字を返す。
+* **添字検索演算**である `indexOf`、 `lastIndexOf`、 `indexOfSlice`、 `lastIndexOfSlice`、 `indexWhere`、 `lastIndexWhere`、 `segmentLength`、 `prefixLength` は、渡された値もしくは条件関数に合致する要素の添字を返す。
 * **加算**である `+:`、`:+`、`padTo` は、列の先頭か最後に要素を追加した新しい列を返す。
 * **更新演算**である `updated`、`patch` は、元の列に何らかの要素を上書きした列を返す。
 * **並べ替え演算**である `sorted`、`sortWith`、`sortBy` は、列内の要素を何らかの基準に基づいて並べ替える。
@@ -82,7 +82,7 @@ Scala の他の構文の例にならって、`seq(idx) = elem` は `seq.update(i
 よく使われる線形列の例に `scala.collection.immutable.List` と `scala.collection.immutable.Stream` がある。よく使われる添字付き列の例としては `scala.Array` と `scala.collection.mutable.ArrayBuffer` がある。
 `Vector` は添字付き列と線形列の間の興味深い折衷案だ。
 事実上定数時間のオーバーヘッドで添字アクセスと線形アクセスを提供するからだ。
-そのため、ベクトルは添字アクセスと線形アクセスの両方を混合して使用してるアクセスパターンにおける良い基盤となる。
+そのため、ベクトルは添字アクセスと線形アクセスの両方を混合して使用しているアクセスパターンにおける良い基盤となる。
 ベクトルに関しては、また[後ほど詳しくみていく](concrete-immutable-collection-classes.html)。
 
 ### バッファ ###

_ja/overviews/collections/sets.md

@@ -91,7 +91,7 @@ language: ja
     scala> s
     res2: scala.collection.immutable.Set[Int] = Set(1, 3, 4)
 
-ここでは `immutable.Set`型の `var` に対して `+=` と `-=` を使った。`s += 4` のようなステートメントは、`s = s + 4` の略だ。つまり、これは集合 `s` に対して追加メソッドの `+` を呼び出して、結果を変数`s` に代入しなおしてる。次に、可変集合でのやりとりを見てほしい。
+ここでは `immutable.Set`型の `var` に対して `+=` と `-=` を使った。`s += 4` のようなステートメントは、`s = s + 4` の略だ。つまり、これは集合 `s` に対して追加メソッドの `+` を呼び出して、結果を変数`s` に代入しなおしている。次に、可変集合でのやりとりを見てほしい。
 
     scala> val s = collection.mutable.Set(1, 2, 3)
     s: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

_ja/overviews/collections/trait-iterable.md

@@ -12,7 +12,7 @@ num: 4
 language: ja
 ---
 
-反復可能 ([`Iterable`](http://www.scala-lang.org/api/{{ site.scala-version }}/scala/collection/Iterable.html) トレイトはコレクション階層の上から2番目に位置する。このトレイトの全メソッドは、コレクション内の要素を1つづつ返す抽象メソッド `iterator` に基づいている。`Iterable` では、`Traversable` トレイトの `foreach` メソッドも `iterator`に基づいて実装されている。以下が実際の実装だ:
+反復可能 ([`Iterable`](http://www.scala-lang.org/api/{{ site.scala-version }}/scala/collection/Iterable.html) トレイトはコレクション階層の上から2番目に位置する。このトレイトの全メソッドは、コレクション内の要素を1つずつ返す抽象メソッド `iterator` に基づいている。`Iterable` では、`Traversable` トレイトの `foreach` メソッドも `iterator`に基づいて実装されている。以下が実際の実装だ:
 
     def foreach[U](f: Elem => U): Unit = {
       val it = iterator