Translation tour ja

_data/translations.yml

@@ -1,2 +1,2 @@
 tour:
-  languages: [ba, es, ko, pt-br, pl, zh-cn, th, ru]
+  languages: [ba, es, ko, pt-br, pl, zh-cn, th, ru, ja]

_ja/tour/abstract-type-members.md

@@ -0,0 +1,79 @@
+---
+layout: tour
+title: 抽象型メンバー
+language: ja
+
+discourse: true
+
+partof: scala-tour
+num: 23
+next-page: compound-types
+previous-page: inner-classes
+topics: abstract type members
+prerequisite-knowledge: variance, upper-type-bound
+
+redirect_from: "/tutorials/tour/abstract-types.html"
+redirect_from: "/tour/abstract-types.html"
+---
+
+トレイトや抽象クラスのような抽象型は抽象型メンバーを持つことができます。
+これは具体的な実装で実際の型を定義するという意味です。
+こちらが例です。
+
+```tut
+trait Buffer {
+  type T
+  val element: T
+}
+```
+こちらでは、抽象型`type T`を定義しています。それは`element`の型を記述するために使われます。このトレイトを抽象クラスで継承し、より具体的にするために上限型境界を`T`に追加することができます。
+
+```tut
+abstract class SeqBuffer extends Buffer {
+  type U
+  type T <: Seq[U]
+  def length = element.length
+}
+```
+`T`の上限型境界の定義に出てきた、更に別の抽象型`U`の使い方に気をつけてください。この`class SeqBuffer`はこのバッファーの中にシーケンスのみを保持することができます。それは型`T`は新しい抽象型`U`を使った`Seq[U]`のサブタイプであると記述しているからです。
+
+抽象型メンバーを持つトレイトと[クラス](classes.html)は無名クラスのインスタンス化と組み合わせてよく使われます。
+これを説明するために、今から整数のリストを参照するシーケンスバッファーを扱うプログラムを見てみます。
+
+```tut
+abstract class IntSeqBuffer extends SeqBuffer {
+  type U = Int
+}
+
+
+def newIntSeqBuf(elem1: Int, elem2: Int): IntSeqBuffer =
+  new IntSeqBuffer {
+       type T = List[U]
+       val element = List(elem1, elem2)
+     }
+val buf = newIntSeqBuf(7, 8)
+println("length = " + buf.length)
+println("content = " + buf.element)
+```
+ここで、ファクトリー`newIntSeqBuf`は抽象型`T`を具体的な型`List[Int]`に設定するために、`IntSeqBuf`(つまり`new IntSeqBuffer`)を無名クラスで実装します。
+
+抽象型メンバーをクラスの型パラメータに変えることも、その逆も可能です。以下は上記コードの型パラメータのみを使うバージョンです。
+
+```tut
+abstract class Buffer[+T] {
+  val element: T
+}
+abstract class SeqBuffer[U, +T <: Seq[U]] extends Buffer[T] {
+  def length = element.length
+}
+
+def newIntSeqBuf(e1: Int, e2: Int): SeqBuffer[Int, Seq[Int]] =
+  new SeqBuffer[Int, List[Int]] {
+    val element = List(e1, e2)
+  }
+
+val buf = newIntSeqBuf(7, 8)
+println("length = " + buf.length)
+println("content = " + buf.element)
+```
+ここでは(`+T <: Seq[U]`)をメソッド`newIntSeqBuf`から戻されるオブジェクトの具体的なシーケンス実装の型を隠すために [変位指定アノテーション](variances.html)を使わなければなりません。さらに、抽象型メンバをパラメータで置換することができないケースがあります。

_ja/tour/annotations.md

@@ -0,0 +1,130 @@
+---
+layout: tour
+title: アノテーション
+language: ja
+
+discourse: true
+
+partof: scala-tour
+
+num: 32
+next-page: default-parameter-values
+previous-page: by-name-parameters
+
+redirect_from: "/tutorials/tour/annotations.html"
+---
+
+アノテーションはメタ情報と定義を関連づけます。例えば、メソッドの前のアノテーション`@deprecated`はメソッドが使われたらコンパイラに警告を出力させます。
+```
+object DeprecationDemo extends App {
+  @deprecated("deprecation message", "release # which deprecates method")
+  def hello = "hola"
+
+  hello  
+}
+```
+これはコンパイルされますが、コンパイラは警告"there was one deprecation warning"を出力します。
+
+アノテーション句はそれに続く最初の定義か宣言に適用されます。定義と宣言の前には1つ以上のアノテーション句を置くことができます。これらの句の順番は重要ではありません。
+
+
+## エンコーディングの正確性を保証するアノテーション
+条件が一致しない場合にコンパイルを失敗させるアノテーションもあります。例えば、アノテーション`@tailrec`はメソッドが[末尾再帰](https://en.wikipedia.org/wiki/Tail_call)であると保証します。末尾再帰ではメモリ使用量が一定になります。こちらは階乗を計算するメソッドの中での使われ方です。
+```tut
+import scala.annotation.tailrec
+
+def factorial(x: Int): Int = {
+
+  @tailrec
+  def factorialHelper(x: Int, accumulator: Int): Int = {
+    if (x == 1) accumulator else factorialHelper(x - 1, accumulator * x)
+  }
+  factorialHelper(x, 1)
+}
+```
+`factorialHelper`メソッドは`@tailrec`を持ちます。`@tailrec`はメソッドが実際に末尾再帰であると保証します。もし`factorialHelper`の実装を以下のように変更すれば、失敗し
+```
+import scala.annotation.tailrec
+
+def factorial(x: Int): Int = {
+  @tailrec
+  def factorialHelper(x: Int): Int = {
+    if (x == 1) 1 else x * factorialHelper(x - 1)
+  }
+  factorialHelper(x)
+}
+```
+"Recursive call not in tail position"というメッセージを受け取ります。
+
+
+## コード生成に影響するアノテーション
+`@inline`のようなアノテーションは生成されたコードに影響します(つまり、アノテーションを使わなかった場合とでjarファイルのバイト数が異なる場合があります)。インライン化とは、メソッドを呼び出している箇所にメソッド本体のコードを挿入することを意味します。結果のバイトコードはより長くなりますが、上手くいけば実行が早くなります。アノテーション`@inline`を使ってもメソッドのインライン化が保証されるわけではありません。しかし、生成されたコードのサイズに関するヒューリスティックスが満たされた場合に限りコンパイラにインライン化をさせます。
+
+### Javaのアノテーション ###
+Javaと相互運用するScalaのコードを書いている時、記述するアノテーション構文は少し違います。
+
+**注:** Javaアノテーションを使う場合、`-target:jvm-1.8`オプションを使ってください。
+
+Javaには[アノテーション](https://docs.oracle.com/javase/tutorial/java/annotations/)の形をしたユーザー定義メタデータがあります。Javaのアノテーションの特徴は、要素の初期化のために名前と値のペアを指定する必要があることです。例えば、クラスのソースを追いかけるためのアノテーションが必要なとき、以下のように定義するかもしれません。
+
+```
+@interface Source {
+  public String URL();
+  public String mail();
+}
+```
+
+そして、それは以下のように適用されます。
+
+```
+@Source(URL = "http://coders.com/",
+        mail = "support@coders.com")
+public class MyClass extends TheirClass ...
+```
+
+Scalaでのアノテーションの適用はコンストラクタの呼び出しと似ています。Javaのアノテーションをインスタンス化するためには名前付き引数を使う必要があります。
+
+```
+@Source(URL = "http://coders.com/",
+        mail = "support@coders.com")
+class MyScalaClass ...
+```
+
+アノテーションが(デフォルト値を除き)要素を1つだけ含む場合、この構文はかなり退屈です。そのため慣例により、名前が`value`と指定されていれば、コンストラクタのような構文でJavaに適用できます。
+
+```
+@interface SourceURL {
+    public String value();
+    public String mail() default "";
+}
+```
+
+そして以下のように適用します。
+
+```
+@SourceURL("http://coders.com/")
+public class MyClass extends TheirClass ...
+```
+
+この場合、Scalaでも同じことができます。
+
+```
+@SourceURL("http://coders.com/")
+class MyScalaClass ...
+```
+
+`mail`要素はデフォルト値つきで定義されているので、明示的に値を指定する必要がありません。しかしながら、もし値を指定する必要がある場合、Javaでは2つのスタイルを混ぜて組み合わせることはできません。
+
+```
+@SourceURL(value = "http://coders.com/",
+           mail = "support@coders.com")
+public class MyClass extends TheirClass ...
+```
+
+Scalaはこの点においてより柔軟です。
+
+```
+@SourceURL("http://coders.com/",
+           mail = "support@coders.com")
+    class MyScalaClass ...
+```

_ja/tour/automatic-closures.md

@@ -0,0 +1,62 @@
+---
+layout: tour
+title: Automatic Type-Dependent Closure Construction
+language: ja
+
+discourse: true
+
+partof: scala-tour
+---
+
+Scala allows parameterless function names as parameters of methods. When such a method is called, the actual parameters for parameterless function names are not evaluated and a nullary function is passed instead which encapsulates the computation of the corresponding parameter (so-called *call-by-name* evaluation).
+
+The following code demonstrates this mechanism:
+
+    object TargetTest1 extends Application {
+      def whileLoop(cond: => Boolean)(body: => Unit): Unit =
+        if (cond) {
+          body
+          whileLoop(cond)(body)
+        }
+      var i = 10
+      whileLoop (i > 0) {
+        println(i)
+        i -= 1
+      }
+    }
+
+The function whileLoop takes two parameters `cond` and `body`. When the function is applied, the actual parameters do not get evaluated. But whenever the formal parameters are used in the body of `whileLoop`, the implicitly created nullary functions will be evaluated instead. Thus, our method `whileLoop` implements a Java-like while-loop with a recursive implementation scheme.
+
+We can combine the use of [infix/postfix operators](operators.html) with this mechanism to create more complex statements (with a nice syntax).
+
+Here is the implementation of a loop-unless statement:
+
+    object TargetTest2 extends Application {
+      def loop(body: => Unit): LoopUnlessCond =
+        new LoopUnlessCond(body)
+      protected class LoopUnlessCond(body: => Unit) {
+        def unless(cond: => Boolean) {
+          body
+          if (!cond) unless(cond)
+        }
+      }
+      var i = 10
+      loop {
+        println("i = " + i)
+        i -= 1
+      } unless (i == 0)
+    }
+The `loop` function just accepts a body of a loop and returns an instance of class `LoopUnlessCond` (which encapsulates this body object). Note that the body didn't get evaluated yet. Class `LoopUnlessCond` has a method `unless` which we can use as a *infix operator*. This way, we achieve a quite natural syntax for our new loop: `loop { < stats > } unless ( < cond > )`.
+
+Here's the output when `TargetTest2` gets executed:
+
+    i = 10
+    i = 9
+    i = 8
+    i = 7
+    i = 6
+    i = 5
+    i = 4
+    i = 3
+    i = 2
+    i = 1