Kotlinの公式リファレンスを日本語化してみた[後編]

この記事は [第2のドワンゴ Advent Calendar 2016](http://qiita.com/advent-calendar/2016/dwango2) の19日目の記事です。

皆さんこんにちは。ドワンゴ新卒2年目のdogwood008と申します。以前途中まで翻訳した（[Kotlinの公式リファレンスを日本語化してみた[前編]](http://qiita.com/dogwood008/items/6e8d3225ea9bb0fe3099)）のですが、"Other" やその他メインでない部分を除いた残りを続きとして翻訳しました。

[日本語版Kotlinリファレンス](http://dogwood008.github.io/kotlin-web-site-ja/docs/reference/)

基本的には上記ページの内容と、本ページの内容は同じです。個別のページで見たい人用と、一覧で見たい人用です。ただし、上記のリファレンスでは、マウスカーソルをあてると原文が表示されるようになっております。翻訳に誤りがあればお教えいただけると幸いです（PRいただけるともっとうれしいです）。

ちなみに、[前編で翻訳した](http://qiita.com/dogwood008/items/6e8d3225ea9bb0fe3099)ときの文章は、全て書き直してあります。

---

# データクラス

<!--original
# Data Classes
-->

何もしない、データを保持するためだけのクラスを作成することはよくあります。そのようなクラスでは、いくつかの標準機能は、データから機械的に推論できます。Kotlinでは、これは _データクラス_ と呼ばれ、 `data` としてマークされています。

<!--original
We frequently create a class to do nothing but hold data. In such a class some standard functionality is often mechanically
derivable from the data. In Kotlin, this is called a _data class_ and is marked as `data`:
-->
 
``` kotlin
data class User(val name: String, val age: Int)
```

<!--original
``` kotlin
data class User(val name: String, val age: Int)
```
-->

プライマリコンストラクタで宣言されたすべてのプロパティから、コンパイラは自動的に次のメンバを推論します：

<!--original
The compiler automatically derives the following members from all properties declared in the primary constructor:
-->
  
  * `equals()` / `hashCode()` のペア、
  * `"User(name=John, age=42)"` 形式の `toString()` 、
  * 宣言した順番でプロパティに対応する [`componentN()` 関数](multi-declarations.html)、
  * `copy()` 関数（下記参照）。

<!--original
  * `equals()`/`hashCode()` pair, 
  * `toString()` of the form `"User(name=John, age=42)"`,
  * [`componentN()` functions](multi-declarations.html) corresponding to the properties in their order of declaration,
  * `copy()` function (see below).
-->
  
これらの機能のいずれかが明示的にクラス本体に定義されているか、基本型から継承されている場合は、生成されません。

<!--original
If any of these functions is explicitly defined in the class body or inherited from the base types, it will not be generated.
-->

生成されたコードの一貫性と意味のある動作を保証するために、データクラスは、次の要件を満たさなければなりません：

<!--original
To ensure consistency and meaningful behavior of the generated code, data classes have to fulfil the following requirements:
-->

  * プライマリコンストラクタは、少なくとも1つのパラメータを持っている必要があります。
  * すべてのプライマリコンストラクタのパラメータは、 `val` または `var` としてマークする必要があります。
  * データクラスは、 abstract, open, sealed または inner にすることはできません。
  * データクラスは他のクラスを拡張しない場合があります（ただし、インターフェイスを実装することはできます）。

<!--original
  * The primary constructor needs to have at least one parameter;
  * All primary constructor parameters need to be marked as `val` or `var`;
  * Data classes cannot be abstract, open, sealed or inner;
  * Data classes may not extend other classes (but may implement interfaces).
-->
  
> JVM上で、生成されたクラスがパラメータなしのコンストラクタを持つ必要がある場合は、すべてのプロパティのデフォルト値を指定する必要があります（[コンストラクタ](classes.html#constructors)を参照してください）。
>
> ``` kotlin
> data class User(val name: String = "", val age: Int = 0)
> ```

<!--original
> On the JVM, if the generated class needs to have a parameterless constructor, default values for all properties have to be specified
> (see [Constructors](classes.html#constructors)).
>
> ``` kotlin
> data class User(val name: String = "", val age: Int = 0)
> ```
-->

## コピー

<!--original
## Copying
-->
  
プロパティの _いくつか_ を変更し、残りをそのままにしてオブジェクトをコピーする、ということが必要になるのはよくあることです。これが `copy()` 関数が作成される理由です。次のような `User` クラスの場合、その実装は次のようになります。

<!--original
It's often the case that we need to copy an object altering _some_ of its properties, but keeping the rest unchanged. 
This is what `copy()` function is generated for. For the `User` class above, its implementation would be as follows:
-->

``` kotlin
fun copy(name: String = this.name, age: Int = this.age) = User(name, age)     
```     

<!--original
``` kotlin
fun copy(name: String = this.name, age: Int = this.age) = User(name, age)     
```     
-->

これは次のように書くことができます：

<!--original
This allows us to write
-->

``` kotlin
val jack = User(name = "Jack", age = 1)
val olderJack = jack.copy(age = 2)
```

<!--original
``` kotlin
val jack = User(name = "Jack", age = 1)
val olderJack = jack.copy(age = 2)
```
-->

## データクラスと分解宣言 (Destructuring Declarations)

<!--original
## Data Classes and Destructuring Declarations
-->

データクラスのために生成した _コンポーネント関数_ は、[分解宣言](multi-declarations.html)内で使用できます。

<!--original
_Component functions_ generated for data classes enable their use in [destructuring declarations](multi-declarations.html):
-->

``` kotlin
val jane = User("Jane", 35) 
val (name, age) = jane
println("$name, $age years of age") // "Jane, 35 years of age" を出力する
```

<!--original
``` kotlin
val jane = User("Jane", 35) 
val (name, age) = jane
println("$name, $age years of age") // prints "Jane, 35 years of age"
```
-->

## 標準データクラス

<!--original
## Standard Data Classes
-->

標準ライブラリは、 `Pair` と `Triple` を提供します。プロパティのために意味のある名前を提供することにより、コードを読みやすくするため、というのが理由です。ほとんどのケースでは、名前付きデータクラスは、設計上のより良い選択ですが。

<!--original
The standard library provides `Pair` and `Triple`. In most cases, though, named data classes are a better design choice, 
because they make the code more readable by providing meaningful names for properties.
-->

# ジェネリクス

<!--original
# Generics
-->

Javaと同じように、Kotlinのクラスは型パラメータを持っている場合があります。

<!--original
As in Java, classes in Kotlin may have type parameters:
-->

``` kotlin
class Box<T>(t: T) {
  var value = t
}
```

<!--original
``` kotlin
class Box<T>(t: T) {
  var value = t
}
```
-->

一般的に、このようなクラスのインスタンスを作成するために、我々は、型引数を提供する必要があります。

<!--original
In general, to create an instance of such a class, we need to provide the type arguments:
-->

``` kotlin
val box: Box<Int> = Box<Int>(1)
```

<!--original
``` kotlin
val box: Box<Int> = Box<Int>(1)
```
-->

しかし、パラメータを推測することができる場合には、（例えば、コンストラクタの引数から、または何らかの他の手段によって）、「1」は、型引数を省略することができます：

<!--original
But if the parameters may be inferred, e.g. from the constructor arguments or by some other means, one is allowed to omit the type arguments:
-->

``` kotlin
val box = Box(1) // 1 は Int型をもつため、ここでは Box<Int> について話しているとコンパイラはわかる
```

<!--original
``` kotlin
val box = Box(1) // 1 has type Int, so the compiler figures out that we are talking about Box<Int>
```
-->

## 分散

<!--original
## Variance
-->

Javaの型システムの最もトリッキーな部分の一つは、ワイルドカードの種類（[JavaのジェネリックのFAQ](http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html)を参照してください）です。そして、Kotlinは、いずれも持っていません。その代わり、2つの別のものがあります：宣言箇所の分散と型プロジェクションです。

<!--original
One of the most tricky parts of Java's type system is wildcard types (see [Java Generics FAQ](http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html)).
And Kotlin doesn't have any. Instead, it has two other things: declaration-site variance and type projections.
-->

まずは、Javaがこれらの神秘的なワイルドカードを必要とする理由について考えてみましょう。この問題は[Effective Java](http://www.oracle.com/technetwork/java/effectivejava-136174.html)の項目28「APIの柔軟性を高めるためのバインドされたワイルドカードの使用」で説明されています。まず、Javaでジェネリック型は不変です。これは、 `List<String>` は `List<Object>` のサブタイプ **ではない** ことを意味します。なぜそうなのか？もしリストが **不変** でなかった場合は、次のコードはコンパイルされ、実行時に例外を発生させていたので、それは、Javaの配列より良いものではなかったでしょう。

<!--original
First, let's think about why Java needs those mysterious wildcards. The problem is explained in [Effective Java](http://www.oracle.com/technetwork/java/effectivejava-136174.html), Item 28: *Use bounded wildcards to increase API flexibility*.
First, generic types in Java are **invariant**, meaning that `List<String>` is **not** a subtype of `List<Object>`. 
Why so? If List was not **invariant**, it would have been no 
better than Java's arrays, since the following code would have compiled and caused an exception at runtime:
-->

``` java
// Java
List<String> strs = new ArrayList<String>();
List<Object> objs = strs; // !!! 今後の問題の原因はここにあります。 Javaはこれを禁止しています！
objs.add(1); // Integer を Strings のリストへ入れる
String s = strs.get(0); // !!! ClassCastException: Integer を String へキャストできない
```
つまり、Javaの実行時の安全性を保証するためにそのようなことを禁止しているのです。しかし、これはいくつかの意味があります。例えば、 `Collection` インタフェースからの `addAll()` メソッドを考えます。このメソッドのシグネチャは何でしょうか？直感的に、我々はそれをこのように置くと思います。

<!--original
``` java
// Java
List<String> strs = new ArrayList<String>();
List<Object> objs = strs; // !!! The cause of the upcoming problem sits here. Java prohibits this!
objs.add(1); // Here we put an Integer into a list of Strings
String s = strs.get(0); // !!! ClassCastException: Cannot cast Integer to String
```
So, Java prohibits such things in order to guarantee run-time safety. But this has some implications. For example, consider the `addAll()` method from `Collection` 
interface. What's the signature of this method? Intuitively, we'd put it this way:
-->

``` java
// Java
interface Collection<E> ... {
  void addAll(Collection<E> items);
}
```

<!--original
``` java
// Java
interface Collection<E> ... {
  void addAll(Collection<E> items);
}
```
-->

しかし、その後、次のような簡単なこと（完全に安全である）を行うことができなくなります。

<!--original
But then, we would not be able to do the following simple thing (which is perfectly safe):
-->

``` java
// Java
void copyAll(Collection<Object> to, Collection<String> from) {
  to.addAll(from); // !!! addAllのネイティブの宣言ではコンパイルできません：
                   //       Collection<String> は Collection <Object> のサブタイプではありません
}
```

<!--original
``` java
// Java
void copyAll(Collection<Object> to, Collection<String> from) {
  to.addAll(from); // !!! Would not compile with the naive declaration of addAll:
                   //       Collection<String> is not a subtype of Collection<Object>
}
```
-->

（Javaでは、この教訓に堅い方法を学びました。 [Effective Java](http://www.oracle.com/technetwork/java/effectivejava-136174.html)の項目25「 *配列よりリストを好む* 」を参照してください。）

<!--original
(In Java, we learned this lesson the hard way, see [Effective Java](http://www.oracle.com/technetwork/java/effectivejava-136174.html), Item 25: *Prefer lists to arrays*)

-->

これが、 `addAll()` の実際のシグネチャが以下の通りになる理由です：

<!--original
That's why the actual signature of `addAll()` is the following:
-->

``` java
// Java
interface Collection<E> ... {
  void addAll(Collection<? extends E> items);
}
```

<!--original
``` java
// Java
interface Collection<E> ... {
  void addAll(Collection<? extends E> items);
}
```
-->

**ワイルドカード型引数** `? extends T` は、このメソッドが受け入れるコレクションは `T` **のサブタイプ** のオブジェクトであって、 `T` 自身ではないことを示します。
私たちが安全に `T` の項目（このコレクションの要素は `T` のサブクラスのインスタンスです）を **読み取る** ことができても、未知の `T` のサブタイプに対して、どのオブジェクトが応じるかわからないため、 **書き込みができない** 理由はこれです。
この制限と引き換えに、私たちは望んだ動作を得ます： `Collection<String>` は `Collection<? extends Object>` のサブタイプ *である* ということ。
「賢い言葉」で言い換えると、 **拡張する** バインド（ **上昇** のバインド）のワイルドカードは **型共変** になります。

<!--original
The **wildcard type argument** `? extends T` indicates that this method accepts a collection of objects of *some subtype of* `T`, not `T` itself. 
This means that we can safely **read** `T`'s from items (elements of this collection are instances of a subclass of T), but **cannot write** to 
it since we do not know what objects comply to that unknown subtype of `T`. 
In return for this limitation, we have the desired behaviour: `Collection<String>` *is* a subtype of `Collection<? extends Object>`. 
In "clever words", the wildcard with an **extends**\-bound (**upper** bound) makes the type **covariant**.
-->

このトリックがなぜ働くのかを理解するための鍵は、かなりシンプルです：コレクションからアイテムを **取り出す** ことだけできるのならば、`String` のコレクションを使用して、 `Object` で読み出せば良いのです。
反対に、コレクションにアイテムを _入れる_ ことだけできるのならば、 `Object` のコレクションを使用し、 `String` を入れても良いのです。 Javaでは `List<Object>` の **スーパータイプ** である、 `List<? super String>` を使用します。

<!--original
The key to understanding why this trick works is rather simple: if you can only **take** items from a collection, then using a collection of `String`s
and reading `Object`s from it is fine. Conversely, if you can only _put_ items into the collection, it's OK to take a collection of
`Object`s and put `String`s into it: in Java we have `List<? super String>` a **supertype** of `List<Object>`.
-->
 
後者は **反変性** と呼ばれ、 String を `List<? super String>` の引数としたメソッドを呼ぶことのみができます（例えば、 `add(String)` や `set(int, String)` を呼ぶことができます）。ただし、`List<T>` で `T` を返す何かを呼んだとき、得るのは `String` ではなく `Object` ですが。

<!--original
The latter is called **contravariance**, and you can only call methods that take String as an argument on `List<? super String>` 
(e.g., you can call `add(String)` or `set(int, String)`), while 
if you call something that returns `T` in `List<T>`, you don't get a `String`, but an `Object`.
-->

ジョシュア・ブロック (Joshua Bloch) はこれらのオブジェクトを 「 **プロデューサ（生産者）** からのみ **読み込み** 、**コンシューマ（消費者）** にのみ **書き込む** 」と呼びました。彼の勧めによると、 *「最大の柔軟性を得るために、プロデューサやコンシューマを表す入力パラメータにワイルドカードタイプを使用する」* 。 次の記憶術 (mnemonic) も提案しています。

<!--original
Joshua Bloch calls those objects you only **read** from **Producers**, and those you only **write** to **Consumers**. He recommends: "*For maximum flexibility, use wildcard types on input parameters that represent producers or consumers*", and proposes the following mnemonic:
-->

*PECSはProducer-Extends, Consumer-Super を意味します。*

<!--original
*PECS stands for Producer-Extends, Consumer-Super.*
-->

*注* ：プロデューサオブジェクトを使用する場合（たとえば、 `List<? extends Foo>` ）、このオブジェクト上の `add()` や `set()` を呼び出すことができません。しかし、このオブジェクトは **イミュータブル（不変）** であるというわけでもありません。例えば、 `clear()` は全くパラメータを取らないため、リストからすべての項目を削除するために `clear()` を呼び出しても構いません。ワイルドカード（または分散の他の型）によって唯一保証されるのは **型の安全性** です。不変性は全く別の話です。

<!--original
*NOTE*: if you use a producer-object, say, `List<? extends Foo>`, you are not allowed to call `add()` or `set()` on this object, but this does not mean 
that this object is **immutable**: for example, nothing prevents you from calling `clear()` to remove all items from the list, since `clear()` 
does not take any parameters at all. The only thing guaranteed by wildcards (or other types of variance) is **type safety**. Immutability is a completely different story.
-->

### 宣言箇所分散

<!--original
### Declaration-site variance
-->

ジェネリックインターフェイスの `Source<T>` があると仮定します。また、パラメータとして `T` をとるメソッドを持たず、 `T` を返すメソッドのみを持つとします。 

<!--original
Suppose we have a generic interface `Source<T>` that does not have any methods that take `T` as a parameter, only methods that return `T`:
-->

``` java
// Java
interface Source<T> {
  T nextT();
}
```

<!--original
``` java
// Java
interface Source<T> {
  T nextT();
}
```
-->

それは `Source<Object>` 型の変数（呼び出せるコンシューマメソッドがない）内で `Source<String>` のインスタンスへの参照を保持するのに完全に安全です。 -- しかし、Javaはこれを知っているし、まだそれを禁止していません：

<!--original
Then, it would be perfectly safe to store a reference to an instance of `Source<String>` in a variable of type `Source<Object>` -- there are no consumer-methods to call. But Java does not know this, and still prohibits it:
-->

``` java
// Java
void demo(Source<String> strs) {
  Source<Object> objects = strs; // !!! Java では許可されていない
  // ...
}
```

<!--original
``` java
// Java
void demo(Source<String> strs) {
  Source<Object> objects = strs; // !!! Not allowed in Java
  // ...
}
```
-->

これを修正するために、`Source<? extends Object>` 型のオブジェクトを宣言する必要があります。全ての同メソッドを前のような変数で呼ぶことができるので、順序に意味はなく、より複雑な型で追加することに価値はありません。しかし、コンパイラはそれを知りません。

<!--original
To fix this, we have to declare objects of type `Source<? extends Object>`, which is sort of meaningless, because we can call all the same methods on such a variable as before, so there's no value added by the more complex type. But the compiler does not know that.
-->

Kotlinでは、コンパイラにこの種の問題を説明する方法があります。これは、 **宣言箇所分散** と呼ばれています：ソースの **型パラメータ** `T` を `Source<T>` のメンバからのみ **返し** （プロデュースする）、消費されることがないということを確認するために、アノテーションを付けることができます。これを行うために、我々は **out** 修飾子を提供します。

<!--original
In Kotlin, there is a way to explain this sort of thing to the compiler. This is called **declaration-site variance**: we can annotate the **type parameter** `T` of Source to make sure that it is only **returned** (produced) from members of `Source<T>`, and never consumed. 
To do this we provide the **out** modifier:
-->

``` kotlin
abstract class Source<out T> {
  abstract fun nextT(): T
}

fun demo(strs: Source<String>) {
  val objects: Source<Any> = strs // これは OK 、なぜなら T はoutパラメータのため
  // ...
}
```

<!--original
``` kotlin
abstract class Source<out T> {
  abstract fun nextT(): T
}

fun demo(strs: Source<String>) {
  val objects: Source<Any> = strs // This is OK, since T is an out-parameter
  // ...
}
```
-->

一般的なルールは次のとおりです。クラス `C` の型パラメータ `T` が、 **out** として宣言されているとき、 `C` のメンバの中で **out** の位置でのみそれが起きることがあります。 しかし、 `C<Base>` を返すときは `C<Derived>` のスーパータイプに安全になり得ます。

<!--original
The general rule is: when a type parameter `T` of a class `C` is declared **out**, it may occur only in **out**\-position in the members of `C`, but in return `C<Base>` can safely be a supertype 
of `C<Derived>`.
-->

「賢い言葉」でいうと、クラス `C` は、パラメータ `T` に **共変** である、または `T` が **共変** の型パラメータであるとなります。 `C` は `T` の **プロデューサ** であり、 `T` の **コンシューマ** ではない、と考えることができます。

<!--original
In "clever words" they say that the class `C` is **covariant** in the parameter `T`, or that `T` is a **covariant** type parameter. 
You can think of `C` as being a **producer** of `T`'s, and NOT a **consumer** of `T`'s.
-->

**out** 修飾子は、 **分散アノテーション** と呼ばれ、それは型パラメータの宣言箇所で提供されているので、我々は **宣言箇所分散** について話しています。
これは、ワイルドカードが使用時に型を共変にする、Javaの **使用箇所分散** とは対照的です。

<!--original
The **out** modifier is called a **variance annotation**, and  since it is provided at the type parameter declaration site, we talk about **declaration-site variance**. 
This is in contrast with Java's **use-site variance** where wildcards in the type usages make the types covariant.
-->

**out** に加えて、Kotlinは **in** という補完的な分散アノテーションを提供します。これは、型パラメータの **反変** を行います。消費されるのみであり、決してプロデュース（生産）されません。
反変クラスの良い例は `Comparable` です：

<!--original
In addition to **out**, Kotlin provides a complementary variance annotation: **in**. It makes a type parameter **contravariant**: it can only be consumed and never 
produced. A good example of a contravariant class is `Comparable`:
-->

``` kotlin
abstract class Comparable<in T> {
  abstract fun compareTo(other: T): Int
}

fun demo(x: Comparable<Number>) {
  x.compareTo(1.0) // 1.0 は Number のサブタイプである Double 型をもつ
  // それゆえ、 x を Comparable<Double> 型の変数へ代入できる
  val y: Comparable<Double> = x // OK!
}
```

<!--original
``` kotlin
abstract class Comparable<in T> {
  abstract fun compareTo(other: T): Int
}

fun demo(x: Comparable<Number>) {
  x.compareTo(1.0) // 1.0 has type Double, which is a subtype of Number
  // Thus, we can assign x to a variable of type Comparable<Double>
  val y: Comparable<Double> = x // OK!
}
```
-->

（C#で何度も成功しているように）**in** と **out** は自己説明的であるゆえに、以前述べた記憶術（ニーモニック）は本当は不要で、より高次の目的のために言い換えることができます：

<!--original
We believe that the words **in** and **out** are self-explaining (as they were successfully used in C# for quite some time already), 
thus the mnemonic mentioned above is not really needed, and one can rephrase it for a higher purpose:
-->

**[実存的](http://en.wikipedia.org/wiki/Existentialism)言い換え：コンシューマ（消費者）は in、プロデューサ（生産者）は out ！** :-)

<!--original
**[The Existential](http://en.wikipedia.org/wiki/Existentialism) Transformation: Consumer in, Producer out\!** :-)
-->

## タイププロジェクション（型投影）

<!--original
## Type projections
-->

### 利用箇所の分散：タイププロジェクション

<!--original
### Use-site variance: Type projections
-->

*out* 型パラメータTを宣言し、使用箇所のサブタイプとの問題がないことは非常に便利です。
そう、それは問題のクラスが実際に `T` のインスタンスのみを返すよう制限 **できる** ときですが、できないのはどんなときでしょう。この良い例は、Arrayです。

<!--original
It is very convenient to declare a type parameter T as *out* and have no trouble with subtyping on the use site. Yes, it is, when the class in question **can** actually be restricted to only return `T`'s, but what if it can't? 
A good example of this is Array:
-->

``` kotlin
class Array<T>(val size: Int) {
  fun get(index: Int): T { /* ... */ }
  fun set(index: Int, value: T) { /* ... */ }
}
```

<!--original
``` kotlin
class Array<T>(val size: Int) {
  fun get(index: Int): T { /* ... */ }
  fun set(index: Int, value: T) { /* ... */ }
}
```
-->

このクラスは `T` の共変または反変のいずれかにもなることはできません。そして、これは特定の不撓（ふとう）性（曲げられない特性）を課しています。次の関数を考えてみます：

<!--original
This class cannot be either co\- or contravariant in `T`. And this imposes certain inflexibilities. Consider the following function:
-->

``` kotlin
fun copy(from: Array<Any>, to: Array<Any>) {
  assert(from.size == to.size)
  for (i in from.indices)
    to[i] = from[i]
}
```

<!--original
``` kotlin
fun copy(from: Array<Any>, to: Array<Any>) {
  assert(from.size == to.size)
  for (i in from.indices)
    to[i] = from[i]
}
```
-->

この関数は、ある配列から別の配列へ、アイテムをコピーすることになっています。それでは、実際にそれを適用してみましょう：

<!--original
This function is supposed to copy items from one array to another. Let's try to apply it in practice:
-->

``` kotlin
val ints: Array<Int> = arrayOf(1, 2, 3)
val any = Array<Any>(3)
copy(ints, any) // エラー： (Array<Any>, Array<Any>) が期待されている
```

<!--original
``` kotlin
val ints: Array<Int> = arrayOf(1, 2, 3)
val any = Array<Any>(3)
copy(ints, any) // Error: expects (Array<Any>, Array<Any>)
```
-->

ここで同じようなよくある問題に遭遇します： `Array<T>` は `T` において **不変** であり、ゆえに `Array<Int>` も `Array<Any>` も他のサブタイプではありません。
どうして？コピーが何か悪いこと（すなわち `from` への文字列の **書き込み** や出力の試行）をやっている **可能性がある** ためです。また `Int` の配列を実際に渡されると、`ClassCastException` が時々後で投げられるでしょう。

<!--original
Here we run into the same familiar problem: `Array<T>` is **invariant** in `T`, thus neither of `Array<Int>` and `Array<Any>` 
is a subtype of the other. Why? Again, because copy **might** be doing bad things, i.e. it might attempt to **write**, say, a String to `from`,
and if we actually passed an array of `Int` there, a `ClassCastException` would have been thrown sometime later.
-->

ここで、唯一の保証したいことは、`copy()` がいかなる悪さもしないということです。 `copy()` が `from` に書き込むことを禁止したく、それを行うことはできます：

<!--original
Then, the only thing we want to ensure is that `copy()` does not do any bad things. We want to prohibit it from **writing** to `from`, and we can:
-->

``` kotlin
fun copy(from: Array<out Any>, to: Array<Any>) {
 // ...
}
```

<!--original
``` kotlin
fun copy(from: Array<out Any>, to: Array<Any>) {
 // ...
}
```
-->

ここで起こったことは、 **タイププロジェクション（型投影）** と呼ばれています。 `from` は単純に配列なのではなく、制限された（ **投影された** ）ものであるということです。型パラメータ `T` を返すこれらのメソッドはこのケースでのみ呼び出すことができます。
つまり、 `get()` を呼ぶことのみができるということです。これが、 **使用箇所分散** のための我々のアプローチであり、Javaの `Array<? extends Object>` に対応しますが、少しだけ簡単な方法です。

<!--original
What has happened here is called **type projection**: we said that `from` is not simply an array, but a restricted (**projected**) one: we can only call those methods that return the type parameter 
`T`, in this case it means that we can only call `get()`. This is our approach to **use-site variance**, and corresponds to Java's `Array<? extends Object>`, 
but in a slightly simpler way.
-->

このように **in** でタイププロジェクション（型投影）を使用できます：

<!--original
You can project a type with **in** as well:
-->

``` kotlin
fun fill(dest: Array<in String>, value: String) {
  // ...
}
```

<!--original
``` kotlin
fun fill(dest: Array<in String>, value: String) {
  // ...
}
```
-->

`Array<in String>` は Javaの `Array<? super String>` に対応します。すなわち、 `CharSequence` の配列や `Object` の配列を `fill()` 関数へ渡すことができます。

<!--original
`Array<in String>` corresponds to Java's `Array<? super String>`, i.e. you can pass an array of `CharSequence` or an array of `Object` to the `fill()` function.
-->

### スタープロジェクション (star-projections)

<!--original
### Star-projections
-->

型引数について何も知らないが、それでも安全な方法で使用したいと、時には言いたくなることもあるでしょう。ここでの安全な方法とは、ジェネリック型のそのようなプロジェクションを定義することです。ジェネリック型を具体的にインスタンス化すると、全てそのプロジェクションのサブタイプになります。

<!--original
Sometimes you want to say that you know nothing about the type argument, but still want to use it in a safe way.
The safe way here is to define such a projection of the generic type, that every concrete instantiation of that generic type would be a subtype of that projection.
-->

Kotlinはこのために、いわゆる **スタープロジェクション (star-projection)** 構文を提供します：

<!--original
Kotlin provides so called **star-projection** syntax for this:
-->

 - `Foo <out T>` の場合、`T` は上限 `TUpper` を持つ共変の型のパラメータであり、 `Foo <*>` は `Foo<out TUpper>` と等価です。これは、 `T` が不明な場合に、安全には `Foo <*>` から `TUpper` の値を読み取ることができることを意味します。
 - `T` が反変の型パラメータである `Foo<in T>` については、 `Foo<*>` は `Foo <in Nothing>` と等価です。それは `T` は不明である場合は安全な方法で `Foo <*>` に書き込むことができる方法がないことを意味します。
 - `Foo <T>` の場合、 `T` は上限 `TUpper` を持つ不変の型パラメータであり、値を読み込むための `Foo<out TUpper>`および値を書き込むための `Foo<in Nothing>` と `Foo <*>` は同等です。

<!--original
 - For `Foo<out T>`, where `T` is a covariant type parameter with the upper bound `TUpper`, `Foo<*>` is equivalent to `Foo<out TUpper>`. It means that when the `T` is unknown you can safely *read* values of `TUpper` from `Foo<*>`.
 - For `Foo<in T>`, where `T` is a contravariant type parameter, `Foo<*>` is equivalent to `Foo<in Nothing>`. It means there is nothing you can *write* to `Foo<*>` in a safe way when `T` is unknown.
 - For `Foo<T>`, where `T` is an invariant type parameter with the upper bound `TUpper`, `Foo<*>` is equivalent to `Foo<out TUpper>` for reading values and to `Foo<in Nothing>` for writing values.
-->

ジェネリック型がいくつかの型パラメータをもつ場合、それらは独立してプロジェクション（投影）することができます。
例えば、型が `interface Function<in T, out U>` として宣言されている場合ならが、次のようなスタープロジェクションを想像することができます：

<!--original
If a generic type has several type parameters each of them can be projected independently.
For example, if the type is declared as `interface Function<in T, out U>` we can imagine the following star-projections:
-->

 - `Function<*, String>` は `Function<in Nothing, String>` を意味します
 - `Function<Int, *>` は `Function<Int, out Any?>` を意味します
 - `Function<*, *>` は `Function<in Nothing, out Any?>` を意味します

<!--original
 - `Function<*, String>` means `Function<in Nothing, String>`;
 - `Function<Int, *>` means `Function<Int, out Any?>`;
 - `Function<*, *>` means `Function<in Nothing, out Any?>`.
-->

*注意* ：スタープロジェクションは非常にJavaの raw タイプににていますが、安全です。

<!--original
*Note*: star-projections are very much like Java's raw types, but safe.
-->

# ジェネリック関数

<!--original
# Generic functions
-->

型パラメータを持つことができるのはクラスだけではありません。関数も同じです。
型パラメータは、関数名の前に置かれます。

<!--original
Not only classes can have type parameters. Functions can, too. Type parameters are placed before the name of the function:
-->

``` kotlin
fun <T> singletonList(item: T): List<T> {
  // ...
}

fun <T> T.basicToString() : String {  // 拡張関数
  // ...
}
```

<!--original
``` kotlin
fun <T> singletonList(item: T): List<T> {
  // ...
}

fun <T> T.basicToString() : String {  // extension function
  // ...
}
```
-->

ジェネリック関数を呼び出すには、関数名の **後に** 呼び出し箇所で型引数を指定します。

<!--original
To call a generic function, specify the type arguments at the call site **after** the name of the function:
-->

``` kotlin
val l = singletonList<Int>(1)
```

<!--original
``` kotlin
val l = singletonList<Int>(1)
```
-->

# ジェネリックの制約

<!--original
# Generic constraints
-->

与えられる型パラメータに置換することができるすべての許容される型の集合は、 **ジェネリックの制約** によって制限されてもかまいません。

<!--original
The set of all possible types that can be substituted for a given type parameter may be restricted by **generic constraints**.
-->

## 上限 (Upper bounds)

<!--original
## Upper bounds
-->

制約の最も一般的なタイプは、Javaの extends キーワードに対応する **上限** です。

<!--original
The most common type of constraint is an **upper bound** that corresponds to Java's *extends* keyword:
-->

``` kotlin
fun <T : Comparable<T>> sort(list: List<T>) {
  // ...
}
```

<!--original
``` kotlin
fun <T : Comparable<T>> sort(list: List<T>) {
  // ...
}
```
-->

コロンの後に指定されたタイプが **上限** です。 `Comparable<T>` のサブタイプは `T` の代わりに使用することができます。例えば：

<!--original
The type specified after a colon is the **upper bound**: only a subtype of `Comparable<T>` may be substituted for `T`. For example
-->

``` kotlin
sort(listOf(1, 2, 3)) // OK. Int は Comparable<Int> のサブタイプです
sort(listOf(HashMap<Int, String>())) // エラー： HashMap<Int, String> は Comparable<HashMap<Int, String>> のサブタイプではない
```

<!--original
``` kotlin
sort(listOf(1, 2, 3)) // OK. Int is a subtype of Comparable<Int>
sort(listOf(HashMap<Int, String>())) // Error: HashMap<Int, String> is not a subtype of Comparable<HashMap<Int, String>>
```
-->

デフォルトの上限（いずれも指定されていない場合）は `Any?` です。唯一の上限を、角括弧内で指定することができます。
同じ型パラメータに複数の上限を必要とする場合、それぞれ独立した **where** 句が必要になります：

<!--original
The default upper bound (if none specified) is `Any?`. Only one upper bound can be specified inside the angle brackets.
If the same type parameter needs more than one upper bound, we need a separate **where**\-clause:
-->

``` kotlin
fun <T> cloneWhenGreater(list: List<T>, threshold: T): List<T>
    where T : Comparable,
          T : Cloneable {
  return list.filter { it > threshold }.map { it.clone() }
}
```

<!--original
``` kotlin
fun <T> cloneWhenGreater(list: List<T>, threshold: T): List<T>
    where T : Comparable,
          T : Cloneable {
  return list.filter { it > threshold }.map { it.clone() }
}
```
-->

# ネストされたクラス

<!--original
# Nested Classes
-->

クラスは他のクラスの中に入れ子にすることができます：

<!--original
Classes can be nested in other classes
-->

``` kotlin
class Outer {
  private val bar: Int = 1
  class Nested {
    fun foo() = 2
  }
}

val demo = Outer.Nested().foo() // == 2
```

<!--original
``` kotlin
class Outer {
  private val bar: Int = 1
  class Nested {
    fun foo() = 2
  }
}

val demo = Outer.Nested().foo() // == 2
```
-->

## 内部クラス

<!--original
## Inner classes
-->

クラスは、外部クラスのメンバーにアクセスできるように *inner*{:.keyword} としてマークされてもかまいません。内部クラスは、外部クラスのオブジェクトへの参照をもちます：

<!--original
A class may be marked as *inner*{: .keyword } to be able to access members of outer class. Inner classes carry a reference to an object of an outer class:
-->

``` kotlin
class Outer {
  private val bar: Int = 1
  inner class Inner {
    fun foo() = bar
  }
}

val demo = Outer().Inner().foo() // == 1
```

<!--original
``` kotlin
class Outer {
  private val bar: Int = 1
  inner class Inner {
    fun foo() = bar
  }
}

val demo = Outer().Inner().foo() // == 1
```
-->

内部クラス内での *this*{:.keyword} の曖昧さ回避について学ぶために、[修飾された *this*{:.keyword} 式](this-expressions.html)を参照してください。

<!--original
See [Qualified *this*{: .keyword } expressions](this-expressions.html) to learn about disambiguation of *this*{: .keyword } in inner classes.
-->

## 無名内部クラス

<!--original
## Anonymous inner classes
-->

無名内部クラスのインスタンスは[オブジェクト式](object-declarations.html#object-expressions)を使用して作成されます：

<!--original
Anonymous inner class instances are created using an [object expression](object-declarations.html#object-expressions):
-->
                                                      
``` kotlin
window.addMouseListener(object: MouseAdapter() {
  override fun mouseClicked(e: MouseEvent) {
    // ...
  }
                                                      
  override fun mouseEntered(e: MouseEvent) {
    // ...
  }
})
```

<!--original
``` kotlin
window.addMouseListener(object: MouseAdapter() {
  override fun mouseClicked(e: MouseEvent) {
    // ...
  }
                                                      
  override fun mouseEntered(e: MouseEvent) {
    // ...
  }
})
```
-->

オブジェクトが機能的なJavaインタフェースのインスタンス（つまり、あるJavaインタフェースがひとつの抽象メソッドとひもづく）である場合は、インタフェースの型が前に付いたラムダ式を使用してオブジェクトを作成できます。

<!--original
If the object is an instance of a functional Java interface (i.e. a Java interface with a single abstract method),
you can create it using a lambda expression prefixed with the type of the interface:
-->

``` kotlin
val listener = ActionListener { println("clicked") }
```

<!--original
``` kotlin
val listener = ActionListener { println("clicked") }
```
-->

# 列挙型クラス (Enum Classes)

<!--original
# Enum Classes
-->

列挙型クラスの最も基本的な使用法は、型安全な列挙型を実装しています：

<!--original
The most basic usage of enum classes is implementing type-safe enums
-->

``` kotlin
enum class Direction {
  NORTH, SOUTH, WEST, EAST
}
```

<!--original
``` kotlin
enum class Direction {
  NORTH, SOUTH, WEST, EAST
}
```
-->

各列挙型の定数はオブジェクトです。列挙型定数はカンマで区切られます。

<!--original
Each enum constant is an object. Enum constants are separated with commas.
-->

## 初期化

<!--original
## Initialization
-->

各列挙型は列挙型クラスのインスタンスなので、初期化することができます：

<!--original
Since each enum is an instance of the enum class, they can be initialized
-->

``` kotlin
enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF)
}
```

<!--original
``` kotlin
enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF)
}
```
-->

## 無名クラス

<!--original
## Anonymous Classes
-->

列挙型定数は、独自の無名クラスを宣言することができます：

<!--original
Enum constants can also declare their own anonymous classes
-->

``` kotlin
enum class ProtocolState {
  WAITING {
    override fun signal() = TALKING
  },

  TALKING {
    override fun signal() = WAITING
  };

  abstract fun signal(): ProtocolState
}
```

<!--original
``` kotlin
enum class ProtocolState {
  WAITING {
    override fun signal() = TALKING
  },

  TALKING {
    override fun signal() = WAITING
  };

  abstract fun signal(): ProtocolState
}
```
-->

それらに対応するメソッド、オーバーライドした基本メソッドも同様に併せて宣言できます。列挙型クラスでメンバが定義されている場合は、Javaの場合と同様に、メンバ定義から 列挙型 定数定義をセミコロンで区切る必要があります。

<!--original
with their corresponding methods, as well as overriding base methods. Note that if the enum class defines any
members, you need to separate the enum constant definitions from the member definitions with a semicolon, just like
in Java.
-->

## 列挙型定数を使用した作業

<!--original
## Working with Enum Constants
-->

ちょうどJavaと同じように、Kotlinの列挙型クラスは、定義された列挙型定数を羅列し、その名前で列挙型定数を得ることを可能にする合成メソッドを持っています。（列挙型クラスの名前を `EnumClass` と仮定して）これらのメソッドのシグネチャは次のとおりです。

<!--original
Just like in Java, enum classes in Kotlin have synthetic methods allowing to list
the defined enum constants and to get an enum constant by its name. The signatures
of these methods are as follows (assuming the name of the enum class is `EnumClass`):
-->

``` kotlin
EnumClass.valueOf(value: String): EnumClass
EnumClass.values(): Array<EnumClass>
```

<!--original
``` kotlin
EnumClass.valueOf(value: String): EnumClass
EnumClass.values(): Array<EnumClass>
```
-->

指定された名前が、クラスで定義されている列挙型定数のいずれとも一致しない場合、`valueOf()` メソッドは `IllegalArgumentException` をスローします。

<!--original
The `valueOf()` method throws an `IllegalArgumentException` if the specified name does
not match any of the enum constants defined in the class.
-->

すべての列挙型定数は、列挙型クラス宣言でその名前と位置を取得するためのプロパティがあります。

<!--original
Every enum constant has properties to obtain its name and position in the enum class declaration:
-->

``` kotlin
val name: String
val ordinal: Int
```

<!--original
``` kotlin
val name: String
val ordinal: Int
```
-->

列挙型定数は列挙型クラスで定義された順序である自然な順序で、[Comparable](/api/latest/jvm/stdlib/kotlin/-comparable/index.html) インタフェースも実装します。

<!--original
The enum constants also implement the [Comparable](/api/latest/jvm/stdlib/kotlin/-comparable/index.html) interface,
with the natural order being the order in which they are defined in the enum class.
-->

# オブジェクト式と宣言

<!--original
# Object Expressions and Declarations
-->

時にはあるクラスをわずかに修正しただけのオブジェクトをそれのための新しいサブクラスを明示的に宣言せずに、作成する必要があります。Javaでは *無名内部クラス* でこの事例を処理します。
Kotlinではたった *オブジェクト式* と *オブジェクトの宣言* だけでこの概念を一般化します。

<!--original
Sometimes we need to create an object of a slight modification of some class, without explicitly declaring a new subclass for it.
Java handles this case with *anonymous inner classes*.
Kotlin slightly generalizes this concept with *object expressions* and *object declarations*.
-->

## オブジェクト式

<!--original
## Object expressions
-->

いくつかの型（1つでも複数でも）から継承する無名クラスのオブジェクトを作成するには、このようにします：

<!--original
To create an object of an anonymous class that inherits from some type (or types), we write:
-->

``` kotlin
window.addMouseListener(object : MouseAdapter() {
  override fun mouseClicked(e: MouseEvent) {
    // ...
  }

  override fun mouseEntered(e: MouseEvent) {
    // ...
  }
})
```

<!--original
``` kotlin
window.addMouseListener(object : MouseAdapter() {
  override fun mouseClicked(e: MouseEvent) {
    // ...
  }

  override fun mouseEntered(e: MouseEvent) {
    // ...
  }
})
```
-->

スーパータイプがコンストラクタを持っている場合は、適切なコンストラクタのパラメータが渡されなければなりません。多くのスーパータイプは、コロンの後にコンマ区切りのリストとして指定することができます：

<!--original
If a supertype has a constructor, appropriate constructor parameters must be passed to it.
Many supertypes may be specified as a comma-separated list after the colon:

-->

``` kotlin
open class A(x: Int) {
  public open val y: Int = x
}

interface B {...}

val ab: A = object : A(1), B {
  override val y = 15
}
```

<!--original
``` kotlin
open class A(x: Int) {
  public open val y: Int = x
}

interface B {...}

val ab: A = object : A(1), B {
  override val y = 15
}
```
-->

万が一、自明でないスーパータイプの「オブジェクトのみ」が必要な場合は、単純に次のように言うことができます：

<!--original
If, by any chance, we need "just an object", with no nontrivial supertypes, we can simply say:
-->

``` kotlin
val adHoc = object {
  var x: Int = 0
  var y: Int = 0
}
print(adHoc.x + adHoc.y)
```

<!--original
``` kotlin
val adHoc = object {
  var x: Int = 0
  var y: Int = 0
}
print(adHoc.x + adHoc.y)
```
-->

ただ、Javaの無名内部クラスのように、内包するスコープからオブジェクト式のコードが変数にアクセスすることができます。（Javaのとは違って、これは final の変数に限定されるものではありません。）

<!--original
Just like Java's anonymous inner classes, code in object expressions can access variables from the enclosing scope.
(Unlike Java, this is not restricted to final variables.)
-->

``` kotlin
fun countClicks(window: JComponent) {
  var clickCount = 0
  var enterCount = 0

  window.addMouseListener(object : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) {
      clickCount++
    }

    override fun mouseEntered(e: MouseEvent) {
      enterCount++
    }
  })
  // ...
}
```

<!--original
``` kotlin
fun countClicks(window: JComponent) {
  var clickCount = 0
  var enterCount = 0

  window.addMouseListener(object : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) {
      clickCount++
    }

    override fun mouseEntered(e: MouseEvent) {
      enterCount++
    }
  })
  // ...
}
```
-->

## オブジェクトの宣言

<!--original
## Object declarations
-->

[シングルトン](http://en.wikipedia.org/wiki/Singleton_pattern)は非常に便利なパターンであり、Kotlin（Scalaの後です）は、シングルトンを容易に宣言で切るようにしました：

<!--original
[Singleton](http://en.wikipedia.org/wiki/Singleton_pattern) is a very useful pattern, and Kotlin (after Scala) makes it easy to declare singletons:
-->

``` kotlin
object DataProviderManager {
  fun registerDataProvider(provider: DataProvider) {
    // ...
  }

  val allDataProviders: Collection<DataProvider>
    get() = // ...
}
```
- これは、オブジェクトの宣言と呼ばれ、それは常に object キーワードの後に名前を持ちます。ちょうど変数宣言と同じように、オブジェクトの宣言は式ではなく、代入文の右側に使用することはできません。

<!--original
``` kotlin
object DataProviderManager {
  fun registerDataProvider(provider: DataProvider) {
    // ...
  }

  val allDataProviders: Collection<DataProvider>
    get() = // ...
}
```
-
This is called an *object declaration*, and it always has a name following the *object*{: .keyword } keyword.
Just like a variable declaration, an object declaration is not an expression, and cannot be used on the right hand side of an assignment statement.
-->

オブジェクトを参照するために、その名前を直接使用します。

<!--original
To refer to the object, we use its name directly:
-->

``` kotlin
DataProviderManager.registerDataProvider(...)
```

<!--original
``` kotlin
DataProviderManager.registerDataProvider(...)
```
-->

このようなオブジェクトは、スーパータイプを持つことができます：

<!--original
Such objects can have supertypes:
-->

``` kotlin
object DefaultListener : MouseAdapter() {
  override fun mouseClicked(e: MouseEvent) {
    // ...
  }

  override fun mouseEntered(e: MouseEvent) {
    // ...
  }
}
```

<!--original
``` kotlin
object DefaultListener : MouseAdapter() {
  override fun mouseClicked(e: MouseEvent) {
    // ...
  }

  override fun mouseEntered(e: MouseEvent) {
    // ...
  }
}
```
-->

**注**：オブジェクト宣言はローカルにすることはできません（つまり、関数内で直接ネストしてください）。ただし、他のオブジェクト宣言または非内部クラスにネストすることもできます。

<!--original
**NOTE**: object declarations can't be local (i.e. be nested directly inside a function), but they can be nested into other object declarations or non-inner classes.

-->

### コンパニオンオブジェクト (Companion Objects)

<!--original
### Companion Objects
-->

クラス内のオブジェクトの宣言は、 *companion*{: .keyword } キーワードでマークすることができます。

<!--original
An object declaration inside a class can be marked with the *companion*{: .keyword } keyword:
-->

``` kotlin
class MyClass {
  companion object Factory {
    fun create(): MyClass = MyClass()
  }
}
```

<!--original
``` kotlin
class MyClass {
  companion object Factory {
    fun create(): MyClass = MyClass()
  }
}
```
-->

コンパニオンオブジェクトのメンバーは修飾子として単にクラス名を使用して呼び出すことができます：

<!--original
Members of the companion object can be called by using simply the class name as the qualifier:
-->

``` kotlin
val instance = MyClass.create()
```

<!--original
``` kotlin
val instance = MyClass.create()
```
-->

コンパニオンオブジェクトの名前を省略することができます。この場合、 `Companion` という名前が使用されます。

<!--original
The name of the companion object can be omitted, in which case the name `Companion` will be used:
-->

``` kotlin
class MyClass {
  companion object {
  }
}

val x = MyClass.Companion
```

<!--original
``` kotlin
class MyClass {
  companion object {
  }
}

val x = MyClass.Companion
```
-->

コンパニオンオブジェクトのメンバは、他の言語のスタティックメンバのように見えますが、実行時にはそれらはまだ実際のオブジェクトのインスタンスメンバであり、たとえばインターフェイスを実装できます：

<!--original
Note that, even though the members of companion objects look like static members in other languages, at runtime those
are still instance members of real objects, and can, for example, implement interfaces:
-->

``` kotlin
interface Factory<T> {
  fun create(): T
}


class MyClass {
  companion object : Factory<MyClass> {
    override fun create(): MyClass = MyClass()
  }
}
```

<!--original
``` kotlin
interface Factory<T> {
  fun create(): T
}


class MyClass {
  companion object : Factory<MyClass> {
    override fun create(): MyClass = MyClass()
  }
}
```
-->

しかしながら、JVM上では、 `@JvmStatic` アノテーションを使用すると、コンパニオンオブジェクトのメンバを実際の静的メソッドやフィールドとして生成することができます。詳細については、[Javaの相互運用性](java-to-kotlin-interop.html#static-fields)のセクションを参照してください。

<!--original
However, on the JVM you can have members of companion objects generated as real static methods and fields, if you use
the `@JvmStatic` annotation. See the [Java interoperability](java-to-kotlin-interop.html#static-fields) section
for more details.

-->

### オブジェクト式と宣言の間の意味の違い

<!--original
### Semantic difference between object expressions and declarations
-->

オブジェクト式とオブジェクトの宣言の間には、ある重要な意味上の違いがあります：

<!--original
There is one important semantic difference between object expressions and object declarations:
-->

* オブジェクト式は **すぐに** 実行され（初期化され）、そこで使用されます
* オブジェクト宣言は、初回アクセス時に **遅延して** 初期化されます
* コンパニオンオブジェクトは、対応するクラスが読み込まれた（解決）されたときに初期化され、これは Java の静的初期化子のセマンティクスに一致します

<!--original
* object expressions are executed (and initialized) **immediately**, where they are used
* object declarations are initialized **lazily**, when accessed for the first time
* a companion object is initialized when the corresponding class is loaded (resolved), matching the semantics of a Java static initializer
-->

# 委譲 (Delegation)

<!--original
# Delegation
-->

## クラスの委譲

<!--original
## Class Delegation
-->

[Delegationパターン](https://en.wikipedia.org/wiki/Delegation_pattern)は、実装継承の良い代替手段であることが証明されており、Kotlinはネイティブでそれをサポートし、かつ定型コードを必要としません。
`Derivced` クラスは、 `Base` インターフェイスから継承することができ、指定されたオブジェクトへの public メソッドのすべてを委譲することができます。

<!--original
The [Delegation pattern](https://en.wikipedia.org/wiki/Delegation_pattern) has proven to be a good alternative to implementation inheritance,
and Kotlin supports it natively requiring zero boilerplate code.
A class `Derived` can inherit from an interface `Base` and delegate all of its public methods to a specified object:
-->

``` kotlin
interface Base {
  fun print()
}

class BaseImpl(val x: Int) : Base {
  override fun print() { print(x) }
}

class Derived(b: Base) : Base by b

fun main(args: Array<String>) {
  val b = BaseImpl(10)
  Derived(b).print() // 出力：10
}
```

<!--original
``` kotlin
interface Base {
  fun print()
}

class BaseImpl(val x: Int) : Base {
  override fun print() { print(x) }
}

class Derived(b: Base) : Base by b

fun main(args: Array<String>) {
  val b = BaseImpl(10)
  Derived(b).print() // prints 10
}
```
-->

`Derived` のスーパータイプのリスト中の *by*{:.keyword} 節は、 `b` が `Derived` のオブジェクトに内部的に格納されることを示し、コンパイラは `b` に取り次ぐ `Base` のすべてのメソッドを生成します。

<!--original
The *by*{: .keyword }-clause in the supertype list for `Derived` indicates that `b` will be stored internally in objects of `Derived`
and the compiler will generate all the methods of `Base` that forward to `b`.

-->

# 委譲プロパティ (Delegated Properties)

<!--original
# Delegated Properties
-->

必要なときに手動で実装することはできますが、一度実装してライブラリに入っていると非常にうれしいといった、ある種のよくある一般的なのプロパティはあります。例としては、

<!--original
There are certain common kinds of properties, that, though we can implement them manually every time we need them, 
would be very nice to implement once and for all, and put into a library. Examples include
-->

* 遅延プロパティ (lazy properties) ：値は最初のアクセス時に初めて計算されます
* オブザーバブルプロパティ (observable properties) ：リスナがこのプロパティの変更に関する通知を受け取ります
* フィールドとは分かれていない、map内での格納プロパティ (storing properties)

<!--original
* lazy properties: the value gets computed only upon first access,
* observable properties: listeners get notified about changes to this property,
* storing properties in a map, not in separate field each.
-->

これら（およびその他）のケースをカバーするために、Kotlinは、 _委譲プロパティ (delegated properties)_ をサポートしています。

<!--original
To cover these (and other) cases, Kotlin supports _delegated properties_:
-->

``` kotlin
class Example {
  var p: String by Delegate()
}
```

<!--original
``` kotlin
class Example {
  var p: String by Delegate()
}
```
-->

構文は次のとおりです `val/var <property name>: <Type> by <expression>`
`get()` （と `set()` ）はその `getValue()` および `setValue()` メソッドに委譲されるプロパティに対応するため、 `by` の後に続く式は、 _委譲 (delegate)_ です。プロパティの委譲には、任意のインターフェイスを実装する必要はありませんが、 `getValue()` 関数（そして `setValue()` --- *var*{:.keyword}用に）を提供する必要があります。例えば：

<!--original
The syntax is: `val/var <property name>: <Type> by <expression>`. The expression after *by*{:.keyword} is the _delegate_, 
because `get()` (and `set()`) corresponding to the property will be delegated to its `getValue()` and `setValue()` methods.
Property delegates don’t have to implement any interface, but they have to provide a `getValue()` function (and `setValue()` --- for *var*{:.keyword}'s).
For example:
-->

``` kotlin
class Delegate {
  operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
    return "$thisRef, thank you for delegating '${property.name}' to me!"
  }
 
  operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
    println("$value has been assigned to '${property.name} in $thisRef.'")
  }
}
```

<!--original
``` kotlin
class Delegate {
  operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
    return "$thisRef, thank you for delegating '${property.name}' to me!"
  }
 
  operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
    println("$value has been assigned to '${property.name} in $thisRef.'")
  }
}
```
-->

Delegate インスタンスのデリゲートである `p` を読み込むとき、 `Delegate` の`getValue()` 関数が呼び出されています。そのため、その最初のパラメータは、 `p` を読み取る先のオブジェクトであり、2番目のパラメータは、 `p` 自体の説明を保持しています（例えば、あなたがその名前を得ることができます）。例えば：

<!--original
When we read from `p` that delegates to an instance of `Delegate`, the `getValue()` function from `Delegate` is called,
so that its first parameter is the object we read `p` from and the second parameter holds a description of `p` itself 
(e.g. you can take its name). For example:
-->

``` kotlin
val e = Example()
println(e.p)
```

<!--original
``` kotlin
val e = Example()
println(e.p)
```
-->

これは次の通り出力します

<!--original
This prints 
-->

```
Example@33a17727, thank you for delegating ‘p’ to me!
```

<!--original
```
Example@33a17727, thank you for delegating ‘p’ to me!
```
-->
 
`p` に代入するのと同様に、`setValue()` 関数が呼び出されます。最初の2つのパラメータは同じであり、3つ目は、割り当てられた値を保持します。

<!--original
Similarly, when we assign to `p`, the `setValue()` function is called. The first two parameters are the same, and the third holds the value being assigned:
-->

``` kotlin
e.p = "NEW"
```

<!--original
``` kotlin
e.p = "NEW"
```
-->

これは次の通り出力します

<!--original
This prints
-->
 
```
NEW has been assigned to ‘p’ in Example@33a17727.
```

<!--original
```
NEW has been assigned to ‘p’ in Example@33a17727.
```
-->

## プロパティデリゲートの要件

<!--original
## Property Delegate Requirements
-->

ここでは、オブジェクトを委譲するための要件をまとめます。

<!--original
Here we summarize requirements to delegate objects. 
-->

**読み取り専用**プロパティ（すなわち *val*{:.keyword}）のために、デリゲートは、次のパラメータを取る `getValue` という名前の関数を提供する必要があります。

<!--original
For a **read-only** property (i.e. a *val*{:.keyword}), a delegate has to provide a function named `getValue` that takes the following parameters:
-->

* レシーバ --- _プロパティ所有者_ のものと同じかスーパータイプでなければなりません（拡張プロパティー --- 拡張されるタイプの場合）。
* メタデータ --- 型 `KProperty <*>`またはそのスーパータイプでなければなりません。

<!--original
* receiver --- must be the same or a supertype of the _property owner_ (for extension properties --- the type being extended),
* metadata --- must be of type `KProperty<*>` or its supertype,
-->

この関数は、プロパティ（またはそのサブタイプ）と同じ型を返さなければなりません。

<!--original
this function must return the same type as property (or its subtype).
-->

**変更可能な** プロパティ ( *var*{:.keyword} ) の場合、デリゲートは、さらに次のパラメータを取り `setValue` という名前の関数を _追加で_ 提供する必要があります。

<!--original
For a **mutable** property (a *var*{:.keyword}), a delegate has to _additionally_ provide a function named `setValue` that takes the following parameters:
-->
 
* レシーバ --- `getValue()` と同じ
* メタデータ --- `getValue()` と同じ
* 新しい値 --- プロパティまたはそのスーパータイプと同じタイプでなければなりません。

<!--original
* receiver --- same as for `getValue()`,
* metadata --- same as for `getValue()`,
* new value --- must be of the same type as a property or its supertype.
-->
 
`getValue()` および/または `setValue()` 関数は、いずれかの委譲クラスや拡張機能のメンバ関数として提供することができます。これらの機能を提供していないオブジェクトにプロパティを委譲する必要がある場合、後者が便利です。関数の両方を `operator` キーワードでマークする必要があります。

<!--original
`getValue()` and/or `setValue()` functions may be provided either as member functions of the delegate class or extension functions.
The latter is handy when you need to delegate property to an object which doesn't originally provide these functions.
Both of the functions need to be marked with the `operator` keyword.

## 標準デリゲート

<!--original
## Standard Delegates
-->

Kotlin標準ライブラリでは、いくつかの有用なデリゲートのファクトリメソッドを提供します。

<!--original
The Kotlin standard library provides factory methods for several useful kinds of delegates.
-->

### 遅延 (lazy)

<!--original
### Lazy
-->

`lazy()` はラムダをとり、遅延プロパティを実装するためのデリゲートとして機能する `Lazy<T>` のインスタンスを返す関数です。`get()` の最初の呼び出しは `lazy()` に渡されたラムダを実行し、結果を保持します。 それ以降、`get()` を呼び出すと、単に記憶された結果が返されます。

<!--original
`lazy()` is a function that takes a lambda and returns an instance of `Lazy<T>` which can serve as a delegate for implementing a lazy property:
the first call to `get()` executes the lambda passed to `lazy()` and remembers the result, 
subsequent calls to `get()` simply return the remembered result. 
-->

``` kotlin
val lazyValue: String by lazy {
    println("computed!")
    "Hello"
}

fun main(args: Array<String>) {
    println(lazyValue)
    println(lazyValue)
}
```

<!--original
``` kotlin
val lazyValue: String by lazy {
    println("computed!")
    "Hello"
}

fun main(args: Array<String>) {
    println(lazyValue)
    println(lazyValue)
}
```
-->

デフォルトでは、遅延特性の評価が **同期されます** 。値は1つのスレッドで計算され、すべてのスレッドで同じ値が表示されます。もし初期化デリゲートの同期が必要ではない場合は、 複数のスレッドが同時に初期化を実行できるように `LazyThreadSafetyMode.PUBLICATION` を `lazy()` 関数のパラメータとして渡します。初期化が常に単一のスレッドで起こると確信しているなら、任意のスレッドの安全性の保証および関連するオーバーヘッドが発生しない `LazyThreadSafetyMode.NONE` モードを使用することができます。

<!--original
By default, the evaluation of lazy properties is **synchronized**: the value is computed only in one thread, and all threads
will see the same value. If the synchronization of initialization delegate is not required, so that multiple threads
can execute it simultaneously, pass `LazyThreadSafetyMode.PUBLICATION` as a parameter to the `lazy()` function. 
And if you're sure that the initialization will always happen on a single thread, you can use `LazyThreadSafetyMode.NONE` mode, 
which doesn't incur any thread-safety guarantees and the related overhead.

-->

### オブザーバブル (Observable)

<!--original
### Observable
-->

`Delegates.observable()` は、2つの引数を取ります。初期値と修正のためのハンドラです。ハンドラは（割り当てが行われた _後_ に）プロパティに割り当てるたびに呼び出されます。それには3つのパラメータがあり、割り当てられているプロパティ、古い値、そして新しい値です：

<!--original
`Delegates.observable()` takes two arguments: the initial value and a handler for modifications.
The handler gets called every time we assign to the property (_after_ the assignment has been performed). It has three
parameters: a property being assigned to, the old value and the new one:
-->

``` kotlin
import kotlin.properties.Delegates

class User {
    var name: String by Delegates.observable("<no name>") {
        prop, old, new ->
        println("$old -> $new")
    }
}

fun main(args: Array<String>) {
    val user = User()
    user.name = "first"
    user.name = "second"
}
```

<!--original
``` kotlin
import kotlin.properties.Delegates

class User {
    var name: String by Delegates.observable("<no name>") {
        prop, old, new ->
        println("$old -> $new")
    }
}

fun main(args: Array<String>) {
    val user = User()
    user.name = "first"
    user.name = "second"
}
```
-->

この例の出力：

<!--original
This example prints
-->

```
<no name> -> first
first -> second
```

<!--original
```
<no name> -> first
first -> second
```
-->

もし代入を傍受し、それに対し 「拒否権」を発動できるようにしたい場合は、observable() の代わりに `vetoable()` を使います。 `vetoable` に渡されたハンドラは、新しいプロパティ値の割り当てが行われる _前_ に呼び出されます。

<!--original
If you want to be able to intercept an assignment and "veto" it, use `vetoable()` instead of `observable()`.
The handler passed to the `vetoable` is called _before_ the assignment of a new property value has been performed.
-->

## Map 中の格納プロパティ（ストアリングプロパティ） (Storing Properties in a Map)

<!--original
## Storing Properties in a Map
-->

一般的な使用例のひとつとして、map 内のプロパティの値を記憶することが挙げられます。これはJSONをパースしたり、他の「動的」なことをやるようなアプリケーションで頻繁に起こっています。この事例では、委譲プロパティのデリゲートとして map のインスタンス自体を使用することができます。

<!--original
One common use case is storing the values of properties in a map.
This comes up often in applications like parsing JSON or doing other “dynamic” things.
In this case, you can use the map instance itself as the delegate for a delegated property.
-->

``` kotlin
class User(val map: Map<String, Any?>) {
    val name: String by map
    val age: Int     by map
}
```

<!--original
``` kotlin
class User(val map: Map<String, Any?>) {
    val name: String by map
    val age: Int     by map
}
```
-->

この例では、コンストラクタは、 map を取ります。

<!--original
In this example, the constructor takes a map:
-->

``` kotlin
val user = User(mapOf(
    "name" to "John Doe",
    "age"  to 25
))
```

<!--original
``` kotlin
val user = User(mapOf(
    "name" to "John Doe",
    "age"  to 25
))
```
-->

委譲プロパティは、このマップから（文字列 --- この場合プロパティの名前 --- のキーを使って）値を取ります：

<!--original
Delegated properties take values from this map (by the string keys --- names of properties):

-->

``` kotlin
println(user.name) // 出力："John Doe"
println(user.age)  // 出力：25
```

<!--original
``` kotlin
println(user.name) // Prints "John Doe"
println(user.age)  // Prints 25
```
-->

読み取り専用 `Map` の代わりに `MutableMap` を使用すると、これは *var*{:.keyword} のプロパティに対しても動作します：

<!--original
This works also for *var*{:.keyword}’s properties if you use a `MutableMap` instead of read-only `Map`:
-->

``` kotlin
class MutableUser(val map: MutableMap<String, Any?>) {
    var name: String by map
    var age: Int     by map
}
```

<!--original
``` kotlin
class MutableUser(val map: MutableMap<String, Any?>) {
    var name: String by map
    var age: Int     by map
}
```
-->

# 関数

<!--original
# Functions
-->

## 関数の宣言

<!--original
## Function Declarations
-->

Kotlinの関数は *fun*{: .keyword } キーワードを使用して宣言されています。

<!--original
Functions in Kotlin are declared using the *fun*{: .keyword } keyword
-->

``` kotlin
fun double(x: Int): Int {
}
```

<!--original
``` kotlin
fun double(x: Int): Int {
}
```
-->

## 関数の使い方

<!--original
## Function Usage
-->

関数の呼び出しは、伝統的なアプローチを採用しています。

<!--original
Calling functions uses the traditional approach
-->

``` kotlin
val result = double(2)
```


<!--original
``` kotlin
val result = double(2)
```

-->

メンバ関数の呼び出しは、ドット表記を使用します。

<!--original
Calling member functions uses the dot notation
-->

``` kotlin
Sample().foo() // Sampleクラスのインスタンスを作ってfooを呼ぶ
```

<!--original
``` kotlin
Sample().foo() // create instance of class Sample and calls foo
```
-->

### 中置記法

<!--original
### Infix notation
-->

次のようなとき、中置表記法 (infix notations) を使用して関数を呼び出すことができます：

<!--original
Functions can also be called using infix notations when
-->

* メンバ関数や[拡張関数](extensions.html)であるとき
* 単一のパラメータを持っているとき
* `infix` キーワードでマークされているとき

<!--original
* They are member functions or [extension functions](extensions.html)
* They have a single parameter
* They are marked with the `infix` keyword
-->

``` kotlin
// Intにエクステンションを定義
infix fun Int.shl(x: Int): Int {
...
}

// 拡張関数を infix ノーテーションを使用して呼ぶ

1 shl 2

// これは次と同じ

1.shl(2)
```

<!--original
``` kotlin
// Define extension to Int
infix fun Int.shl(x: Int): Int {
...
}

// call extension function using infix notation

1 shl 2

// is the same as

1.shl(2)
```
-->

### パラメーター

<!--original
### Parameters
-->

関数のパラメータはパスカル記法、すなわち *名前*: *タイプ* を使用して定義されています。パラメータはカンマを使用して分離されます。各パラメータは、明示的に入力する必要があります。

<!--original
Function parameters are defined using Pascal notation, i.e. *name*: *type*. Parameters are separated using commas. Each parameter must be explicitly typed.
-->

``` kotlin
fun powerOf(number: Int, exponent: Int) {
...
}
```

<!--original
``` kotlin
fun powerOf(number: Int, exponent: Int) {
...
}
```
-->

### デフォルトの引数

<!--original
### Default Arguments
-->

関数パラメータは、対応する引数が省略されているときに使用されるデフォルト値をもつことができます。これにより、他言語に比べてオーバーロード数を減らすことができます。

<!--original
Function parameters can have default values, which are used when a corresponding argument is omitted. This allows for a reduced number of overloads compared to
other languages.
-->

``` kotlin
fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size()) {
...
}
```

<!--original
``` kotlin
fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size()) {
...
}
```
-->

デフォルト値は値と共に記述した後に **=** を使用して定義されます。

<!--original
Default values are defined using the **=** after type along with the value.
-->

オーバーライドメソッドは、常にベースメソッドと同じデフォルトのパラメータ値を使用します。デフォルトのパラメータ値を持つメソッドをオーバーライドする場合は、デフォルトのパラメータ値は、シグネチャから省略されている必要があります。

<!--original
Overriding methods always use the same default parameter values as the base method.
When overriding a method with default parameters values, the default parameter values must be omitted from the signature:
-->

``` kotlin
open class A {
    open fun foo(i: Int = 10) { ... }
}

class B : A() {
    override fun foo(i: Int) { ... }  // デフォルト値は使用できない
}
```

<!--original
``` kotlin
open class A {
    open fun foo(i: Int = 10) { ... }
}

class B : A() {
    override fun foo(i: Int) { ... }  // no default value allowed
}
```
-->

### 名前付き引数

<!--original
### Named Arguments
-->

関数を呼び出すとき、関数のパラメータに名前を付けることができます。これは関数が沢山のパラメータやデフォルトのパラメータを持つ場合に非常に便利です。

<!--original
Function parameters can be named when calling functions. This is very convenient when a function has a high number of parameters or default ones.
-->

次の関数を考えます：

<!--original
Given the following function
-->

``` kotlin
fun reformat(str: String,
             normalizeCase: Boolean = true,
             upperCaseFirstLetter: Boolean = true,
             divideByCamelHumps: Boolean = false,
             wordSeparator: Char = ' ') {
...
}
```

<!--original
``` kotlin
fun reformat(str: String,
             normalizeCase: Boolean = true,
             upperCaseFirstLetter: Boolean = true,
             divideByCamelHumps: Boolean = false,
             wordSeparator: Char = ' ') {
...
}
```
-->

私たちは、デフォルト引数を使用して、これを呼び出すことができます：

<!--original
we could call this using default arguments
-->

``` kotlin
reformat(str)
```

<!--original
``` kotlin
reformat(str)
```
-->

しかし、デフォルト値が無い場合はそれの呼び出しは次のようになります：

<!--original
However, when calling it with non-default, the call would look something like
-->

``` kotlin
reformat(str, true, true, false, '_')
```

<!--original
``` kotlin
reformat(str, true, true, false, '_')
```
-->

名前付き引数で、コードをはるかに読みやすくすることができます：

<!--original
With named arguments we can make the code much more readable
-->

``` kotlin
reformat(str,
    normalizeCase = true,
    upperCaseFirstLetter = true,
    divideByCamelHumps = false,
    wordSeparator = '_'
  )
```

<!--original
``` kotlin
reformat(str,
    normalizeCase = true,
    upperCaseFirstLetter = true,
    divideByCamelHumps = false,
    wordSeparator = '_'
  )
```
-->

すべての引数を必要としない場合：

<!--original
and if we do not need all arguments
-->

``` kotlin
reformat(str, wordSeparator = '_')
```

<!--original
``` kotlin
reformat(str, wordSeparator = '_')
```
-->

Javaバイトコードは常に関数パラメータの名を保存しないため、Java関数を呼び出すときに名前付き引数構文を使用できないことに注意してください。

<!--original
Note that the named argument syntax cannot be used when calling Java functions, because Java bytecode does not
always preserve names of function parameters.

-->

### Unit を返す関数

<!--original
### Unit-returning functions
-->

関数が任意の有用な値を返さない場合、その戻り値の型は `Unit` です。 `Unit` は、唯一の値 ( `Unit` ) だけを持つ型です。
この値は、明示的に return されなくてもかまいません：

<!--original
If a function does not return any useful value, its return type is `Unit`. `Unit` is a type with only one value - `Unit`. This
value does not have to be returned explicitly
-->

``` kotlin
fun printHello(name: String?): Unit {
    if (name != null)
        println("Hello ${name}")
    else
        println("Hi there!")
    // `return Unit` または `return` は必須ではない
}
```

<!--original
``` kotlin
fun printHello(name: String?): Unit {
    if (name != null)
        println("Hello ${name}")
    else
        println("Hi there!")
    // `return Unit` or `return` is optional
}
```
-->

`Unit` の戻り型の宣言も任意です。上記のコードは次と等価です：

<!--original
The `Unit` return type declaration is also optional. The above code is equivalent to
-->

``` kotlin
fun printHello(name: String?) {
    ...
}
```

<!--original
``` kotlin
fun printHello(name: String?) {
    ...
}
```
-->

### 単一式関数

<!--original
### Single-Expression functions
-->

関数は、単一の式を返すと中括弧を省略することができ、本体は **=** 記号の後に指定されています：

<!--original
When a function returns a single expression, the curly braces can be omitted and the body is specified after a **=** symbol
-->

``` kotlin
fun double(x: Int): Int = x * 2
```

<!--original
``` kotlin
fun double(x: Int): Int = x * 2
```
-->

コンパイラによって戻り値の型を推論することができる時には、明示的な戻り値の型の宣言は任意です：

<!--original
Explicitly declaring the return type is [optional](#explicit-return-types) when this can be inferred by the compiler
-->

``` kotlin
fun double(x: Int) = x * 2
```

<!--original
``` kotlin
fun double(x: Int) = x * 2
```
-->

### 明示的な戻り値の型

<!--original
### Explicit return types
-->

`Unit` を返すことを意図していない限り、ブロック本体を持つ関数は、それが任意である場合には、常に明示的に戻り値の型を指定しなければなりません。Kotlinはブロック本体と関数の戻り値の型を推論することはありません。なぜならこのような機能は本体内に複雑な制御フローをもつことがあり、戻り値の型が読み手（時にはコンパイラ）に自明ではないからです。

<!--original
Functions with block body must always specify return types explicitly, unless it's intended for them to return `Unit`, [in which case it is optional](#unit-returning-functions).
Kotlin does not infer return types for functions with block bodies because such functions may have complex control flow in the body, and the return
type will be non-obvious to the reader (and sometimes even for the compiler). 

-->

### 可変長引数（可変引数, Varargs）

<!--original
### Variable number of arguments (Varargs)
-->

関数（通常は最後のひとつ）のパラメータは、 `vararg` 修飾子でマークされることがあります：

<!--original
A parameter of a function (normally the last one) may be marked with `vararg` modifier:
-->

``` kotlin
fun <T> asList(vararg ts: T): List<T> {
  val result = ArrayList<T>()
  for (t in ts) // ts は配列
    result.add(t)
  return result
}
```

<!--original
``` kotlin
fun <T> asList(vararg ts: T): List<T> {
  val result = ArrayList<T>()
  for (t in ts) // ts is an Array
    result.add(t)
  return result
}
```
-->

関数に渡される引数を可変数にすることができます：

<!--original
allowing a variable number of arguments to be passed to the function:
-->

```kotlin
  val list = asList(1, 2, 3)
```

<!--original
```kotlin
  val list = asList(1, 2, 3)
```
-->

関数の中では、 `T` 型の `vararg` をつけたパラメータは `T` の配列として見えます。すなわち、前述例での `ts` 変数は `Array<out T>` 型を持ちます。

<!--original
Inside a function a `vararg`-parameter of type `T` is visible as an array of `T`, i.e. the `ts` variable in the example above has type `Array<out T>`.
-->

唯一のパラメータが `vararg` としてマークされることがあります。 `vararg` パラメータが変数リストの最後のひとつでない場合には、名前付き引数の構文を使用して、またはパラメータが関数型をもっている場合、括弧の外でラムダを渡すことによって、リストにおける次のパラメータの値を渡すことができます。 

<!--original
Only one parameter may be marked as `vararg`. If a `vararg` parameter is not the last one in the list, values for the
following parameters can be passed using the named argument syntax, or, if the parameter has a function type, by passing
a lambda outside parentheses.
-->

`vararg` をもつ関数を呼び出すとき、例えば `asList(1, 2, 3)` のように、一つずつ引数を渡すことができます。または、すでに配列を持っており、関数にその内容を渡したい場合は、（ * を配列名の接頭辞にする） **spread** 演算子を使用します：

<!--original
When we call a `vararg`-function, we can pass arguments one-by-one, e.g. `asList(1, 2, 3)`, or, if we already have an array
 and want to pass its contents to the function, we use the **spread** operator (prefix the array with `*`):
-->

```kotlin
val a = arrayOf(1, 2, 3)
val list = asList(-1, 0, *a, 4)
```

<!--original
```kotlin
val a = arrayOf(1, 2, 3)
val list = asList(-1, 0, *a, 4)
```
-->

## 関数のスコープ

<!--original
## Function Scope
-->

Kotlinでは、関数はファイルのトップレベルで宣言することができます。これは、関数を保持するためのクラスを作成する必要がないことを意味します。JavaやC#, Scalaなどの言語と同じように。トップレベルの関数に加えて、Kotlinの関数はメンバ関数や拡張機能として、ローカルに宣言することもできます。

<!--original
In Kotlin functions can be declared at top level in a file, meaning you do not need to create a class to hold a function, like languages such as Java, C# or Scala. In addition
to top level functions, Kotlin functions can also be declared local, as member functions and extension functions.
-->

### ローカル関数

<!--original
### Local Functions
-->

Kotlinはローカル関数、すなわち、ある関数内の別の関数をサポートしています。

<!--original
Kotlin supports local functions, i.e. a function inside another function
-->

``` kotlin
fun dfs(graph: Graph) {
  fun dfs(current: Vertex, visited: Set<Vertex>) {
    if (!visited.add(current)) return
    for (v in current.neighbors)
      dfs(v, visited)
  }

  dfs(graph.vertices[0], HashSet())
}
```

<!--original
``` kotlin
fun dfs(graph: Graph) {
  fun dfs(current: Vertex, visited: Set<Vertex>) {
    if (!visited.add(current)) return
    for (v in current.neighbors)
      dfs(v, visited)
  }

  dfs(graph.vertices[0], HashSet())
}
```
-->

ローカル関数は、外側の関数（すなわちクロージャ）のローカル変数にアクセスすることができます。これにより、上記の場合には、 visited をローカル変数にすることができます。

<!--original
Local function can access local variables of outer functions (i.e. the closure), so in the case above, the *visited* can be a local variable
-->

``` kotlin
fun dfs(graph: Graph) {
  val visited = HashSet<Vertex>()
  fun dfs(current: Vertex) {
    if (!visited.add(current)) return
    for (v in current.neighbors)
      dfs(v)
  }

  dfs(graph.vertices[0])
}
```

<!--original
``` kotlin
fun dfs(graph: Graph) {
  val visited = HashSet<Vertex>()
  fun dfs(current: Vertex) {
    if (!visited.add(current)) return
    for (v in current.neighbors)
      dfs(v)
  }

  dfs(graph.vertices[0])
}
```
-->

### メンバ関数

<!--original
### Member Functions
-->

メンバ関数は、クラスやオブジェクトの内部で定義される関数です。

<!--original
A member function is a function that is defined inside a class or object
-->

``` kotlin
class Sample() {
  fun foo() { print("Foo") }
}
```

<!--original
``` kotlin
class Sample() {
  fun foo() { print("Foo") }
}
```
-->

メンバ関数は、ドット表記と呼ばれています。

<!--original
Member functions are called with dot notation
-->

``` kotlin
Sample().foo() // Sampleクラスのインスタンスを作り、 foo を呼ぶ
```

<!--original
``` kotlin
Sample().foo() // creates instance of class Sample and calls foo
```
-->

クラスおよびオーバーライドするメンバの詳細については クラスと継承 を参照してください。

<!--original
For more information on classes and overriding members see [Classes](classes.html) and [Inheritance](classes.html#inheritance)
-->

## ジェネリック関数

<!--original
## Generic Functions
-->

関数は、関数名の前に山括弧（訳注：＜＞のことです）を使用して、ジェネリックパラメータを持つことができます。

<!--original
Functions can have generic parameters which are specified using angle brackets before the function name
-->

``` kotlin
fun <T> singletonList(item: T): List<T> {
  // ...
}
```

<!--original
``` kotlin
fun <T> singletonList(item: T): List<T> {
  // ...
}
```
-->

ジェネリック関数の詳細については、[ジェネリクス](generics.html) を参照してください。

<!--original
For more information on generic functions see [Generics](generics.html)
-->

## インライン関数

<!--original
## Inline Functions
-->

インライン関数は、 [ここ](inline-functions.html) で説明されています。

<!--original
Inline functions are explained [here](inline-functions.html)
-->

## 拡張関数

<!--original
## Extension Functions
-->

拡張機能は、 [拡張関数](extensions.html) で説明されています。

<!--original
Extension functions are explained in [their own section](extensions.html)
-->

## 高階関数とラムダ

<!--original
## Higher-Order Functions and Lambdas
-->

高階関数とラムダは、 [高階関数とラムダ](lambdas.html) で説明されています。

<!--original
Higher-Order functions and Lambdas are explained in [their own section](lambdas.html)
-->

## 末尾再帰関数

<!--original
## Tail recursive functions
-->

Kotlinは[末尾再帰](https://en.wikipedia.org/wiki/Tail_call)として知られている関数型プログラミングのスタイルをサポートしています。これは通常ループを使用して書かれるいくつかのアルゴリズムを代わりに再帰で、しかし、普通の再帰と違ってスタックオーバーフローのリスクがないように書くことです。ある関数が `tailrec` 修飾子でマークされ、必要な形式を満たしている場合、コンパイラは高速かつ効率的なループベースのバージョンを残して、再帰を最適化します。

<!--original
Kotlin supports a style of functional programming known as [tail recursion](https://en.wikipedia.org/wiki/Tail_call).
This allows some algorithms that would normally be written using loops to instead be written using a recursive function, but without the risk of stack overflow.
When a function is marked with the `tailrec` modifier and meets the required form the compiler optimises out the recursion, leaving behind a fast and efficient loop based version instead.
-->

``` kotlin
tailrec fun findFixPoint(x: Double = 1.0): Double
        = if (x == Math.cos(x)) x else findFixPoint(Math.cos(x))
```

<!--original
``` kotlin
tailrec fun findFixPoint(x: Double = 1.0): Double
        = if (x == Math.cos(x)) x else findFixPoint(Math.cos(x))
```
-->

このコードは、数学定数であるコサインの不動点（固定点, fixpoint）を算出します。それは Math.cos を 1.0 から始めて結果に0.7390851332151607の結果を得、それ以上変化しなくなるまで単に繰り返し呼び出します。その結果生成されたコードは、このより伝統的なスタイルに相当します。

<!--original
This code calculates the fixpoint of cosine, which is a mathematical constant. It simply calls Math.cos repeatedly starting at 1.0 until the result doesn't change any more, yielding a result of 0.7390851332151607. The resulting code is equivalent to this more traditional style:
-->

``` kotlin
private fun findFixPoint(): Double {
    var x = 1.0
    while (true) {
        val y = Math.cos(x)
        if (x == y) return y
        x = y
    }
}
```

<!--original
``` kotlin
private fun findFixPoint(): Double {
    var x = 1.0
    while (true) {
        val y = Math.cos(x)
        if (x == y) return y
        x = y
    }
}
```
-->

`tailrec` 修飾子の対象となるためには、関数は実行する最後の操作として自身を呼び出す必要があります。再帰呼び出しの後に多くのコードがあるときは、末尾再帰を使用することはできません。 try / catch / finally ブロック内で使用することもできません。現在、末尾再帰はJVMのバックエンドでのみサポートされています。

<!--original
To be eligible for the `tailrec` modifier, a function must call itself as the last operation it performs. You cannot use tail recursion when there is more code after the recursive call, and you cannot use it within try/catch/finally blocks. Currently tail recursion is only supported in the JVM backend.

-->

# 高階関数とラムダ

<!--original
# Higher-Order Functions and Lambdas
-->

## 高階関数

<!--original
## Higher-Order Functions
-->

高階関数はパラメータとして関数を取るか、関数を返す関数です。このような機能の良い例が `lock()` のような関数です。これは lock オブジェクトと関数を受け取り、 lock をかけ、関数を実行して lock を解放します。

<!--original
A higher-order function is a function that takes functions as parameters, or returns a function.
A good example of such a function is `lock()` that takes a lock object and a function, acquires the lock, runs the function and releases the lock:
-->

``` kotlin
fun <T> lock(lock: Lock, body: () -> T): T {
  lock.lock()
  try {
    return body()
  }
  finally {
    lock.unlock()
  }
}
```

<!--original
``` kotlin
fun <T> lock(lock: Lock, body: () -> T): T {
  lock.lock()
  try {
    return body()
  }
  finally {
    lock.unlock()
  }
}
```
-->

それでは、上記のコードを見てみましょう。 `body` は[関数型](#function-types): `() -> T` を持ちます。つまり、パラメータを取らず、型 `T` の値を返す関数と考えられます。 `body` は `lock` によって保護されながら、 *try*{: .keyword } ブロック内で呼び出され、その結果は `lock()` 関数によって返されます。

<!--original
Let's examine the code above: `body` has a [function type](#function-types): `() -> T`,
so it's supposed to be a function that takes no parameters and returns a value of type `T`.
It is invoked inside the *try*{: .keyword }-block, while protected by the `lock`, and its result is returned by the `lock()` function.
-->

`lock()` を呼び出したい場合は、引数として別の関数を渡すことができます（[関数の参照](reflection.html#function-references)を参照してください）：

<!--original
If we want to call `lock()`, we can pass another function to it as an argument (see [function references](reflection.html#function-references)):
-->

``` kotlin
fun toBeSynchronized() = sharedResource.operation()

val result = lock(lock, ::toBeSynchronized)
```

<!--original
``` kotlin
fun toBeSynchronized() = sharedResource.operation()

val result = lock(lock, ::toBeSynchronized)
```
-->

別手段として、多くの場合、より便利な方法は[ラムダ式](#lambda-expressions-and-anonymous-functions)を渡すことです：

<!--original
Another, often more convenient way is to pass a [lambda expression](#lambda-expressions-and-anonymous-functions):
-->

``` kotlin
val result = lock(lock, { sharedResource.operation() })
```

<!--original
``` kotlin
val result = lock(lock, { sharedResource.operation() })
```
-->

ラムダ式は[以下でより詳細に](#lambda-expressions-and-anonymous-functions)説明しますが、このセクションを継続したいので、今は簡単な概要を見てみましょう：

<!--original
Lambda expressions are described in more [detail below](#lambda-expressions-and-anonymous-functions), but for purposes of continuing this section, let's see a brief overview:
-->

* ラムダ式は、常に中括弧で囲まれています
* そのパラメータは、（もしあれば） `->` の前で宣言されます（パラメータの型を省略してもかまいません）
* 本体が `->` に続きます（存在する場合）

<!--original
* A lambda expression is always surrounded by curly braces,
* Its parameters (if any) are declared before `->` (parameter types may be omitted),
* The body goes after `->` (when present).
-->

Kotlinでは、関数の最後のパラメータが関数である場合、そのパラメータは括弧の外に指定することができるという慣習があります：

<!--original
In Kotlin, there is a convention that if the last parameter to a function is a function, that parameter can be specified outside of the parentheses:
-->

``` kotlin
lock (lock) {
  sharedResource.operation()
}
```

<!--original
``` kotlin
lock (lock) {
  sharedResource.operation()
}
```
-->

別の例で高階関数が `map()` になっています：

<!--original
Another example of a higher-order function would be `map()`:
-->

``` kotlin
fun <T, R> List<T>.map(transform: (T) -> R): List<R> {
  val result = arrayListOf<R>()
  for (item in this)
    result.add(transform(item))
  return result
}
```

<!--original
``` kotlin
fun <T, R> List<T>.map(transform: (T) -> R): List<R> {
  val result = arrayListOf<R>()
  for (item in this)
    result.add(transform(item))
  return result
}
```
-->

この関数を次のように呼び出すことができます。

<!--original
This function can be called as follows:
-->

``` kotlin
val doubled = ints.map { it -> it * 2 }
```

<!--original
``` kotlin
val doubled = ints.map { it -> it * 2 }
```
-->

ラムダがその呼び出しに唯一の引数である場合、呼び出しの括弧を完全に省略することができることに注意してください。

<!--original
Note that the parentheses in a call can be omitted entirely if the lambda is the only argument to that call.
-->

### `it` : 単一パラメータの暗黙の名前

<!--original
### `it`: implicit name of a single parameter
-->

もう一つの有用な慣習は、関数リテラルがパラメータを1つだけ持つ場合、その宣言を（ `->` と一緒に）省略してもよいということです。その場合、その名前は、 it になります。

<!--original
One other helpful convention is that if a function literal has only one parameter,
its declaration may be omitted (along with the `->`), and its name will be `it`:
-->

``` kotlin
ints.map { it * 2 }
```

<!--original
``` kotlin
ints.map { it * 2 }
```
-->

これらの慣習により、 [LINQスタイル](http://msdn.microsoft.com/en-us/library/bb308959.aspx) のコードを書くことができます：

<!--original
These conventions allow to write [LINQ-style](http://msdn.microsoft.com/en-us/library/bb308959.aspx) code:
-->

``` kotlin
strings.filter { it.length == 5 }.sortBy { it }.map { it.toUpperCase() }
```

<!--original
``` kotlin
strings.filter { it.length == 5 }.sortBy { it }.map { it.toUpperCase() }
```
-->

## インライン関数

<!--original
## Inline Functions
-->

場合によっては、[インライン関数](inline-functions.html)の使用は高階関数のパフォーマンスの向上に有効です。

<!--original
Sometimes it is beneficial to enhance performance of higher-order functions using [inline functions](inline-functions.html).
-->

## ラムダ式と無名関数

<!--original
## Lambda Expressions and Anonymous Functions
-->

ラムダ式や無名関数は「関数リテラル」です。すなわち、その関数は宣言されたのではなく、表現としてすぐに渡されたということです。次の例を考えてみます：

<!--original
A lambda expression or an anonymous function is a "function literal", i.e. a function that is not declared,
but passed immediately as an expression. Consider the following example:
-->

``` kotlin
max(strings, { a, b -> a.length < b.length })
```

<!--original
``` kotlin
max(strings, { a, b -> a.length < b.length })
```
-->

関数 `max` は高階関数です。すなわち2番目の引数として関数値をとります。この2番目の引数はそれ自体が関数である式、すなわち関数リテラルです。関数としては、次と等価です：

<!--original
Function `max` is a higher-order function, i.e. it takes a function value as the second argument.
This second argument is an expression that is itself a function, i.e. a function literal. As a function, it is equivalent to
-->

``` kotlin
fun compare(a: String, b: String): Boolean = a.length < b.length
```

<!--original
``` kotlin
fun compare(a: String, b: String): Boolean = a.length < b.length
```
-->

### 関数型

<!--original
### Function Types
-->

関数がパラメータとして別の関数を受け入れられるようにするために、そのパラメータの関数型を指定する必要があります。たとえば、次のように前述の関数 `max` が定義されているとします：

<!--original
For a function to accept another function as a parameter, we have to specify a function type for that parameter.
For example the abovementioned function `max` is defined as follows:
-->

``` kotlin
fun <T> max(collection: Collection<T>, less: (T, T) -> Boolean): T? {
  var max: T? = null
  for (it in collection)
    if (max == null || less(max, it))
      max = it
  return max
}
```

<!--original
``` kotlin
fun <T> max(collection: Collection<T>, less: (T, T) -> Boolean): T? {
  var max: T? = null
  for (it in collection)
    if (max == null || less(max, it))
      max = it
  return max
}
```
-->

パラメータ `less` は `(T, T) -> Boolean` 型、すなわち2つの `T` 型のパラメータをとり、前者が後者より小さければ `Boolean` : true を返す関数です。

<!--original
The parameter `less` is of type `(T, T) -> Boolean`, i.e. a function that takes two parameters of type `T` and returns a `Boolean`:
true if the first one is smaller than the second one.
-->

本体の4行目では、 `less` は関数として使用されています。つまり、型 `T` の2つの引数を渡すことによってその関数は呼び出されました。

<!--original
In the body, line 4, `less` is used as a function: it is called by passing two arguments of type `T`.
-->

関数型は前述の通り、または各パラメータの意味をドキュメント化する場合は、名前付きパラメータを使用することがあります。

<!--original
A function type is written as above, or may have named parameters, if you want to document the meaning of each parameter.
-->

``` kotlin
val compare: (x: T, y: T) -> Int = ...
```

<!--original
``` kotlin
val compare: (x: T, y: T) -> Int = ...
```
-->

### ラムダ式の構文

<!--original
### Lambda Expression Syntax
-->

ラムダ式、つまり関数型リテラルの完全な構文形式は、次のとおりです。

<!--original
The full syntactic form of lambda expressions, i.e. literals of function types, is as follows:
-->

``` kotlin
val sum = { x: Int, y: Int -> x + y }
```

<!--original
``` kotlin
val sum = { x: Int, y: Int -> x + y }
```
-->

ラムダ式は常に中括弧で囲まれ、完全な構文形式のパラメータ宣言はカッコ内にあり、型注釈を持つことができ、本体は `->` 記号の後に置かれます。必須ではない注釈をすべて省略した場合、残っているものは次のようになります：

<!--original
A lambda expression is always surrounded by curly braces,
parameter declarations in the full syntactic form go inside parentheses and have optional type annotations,
the body goes after an `->` sign.
If we leave all the optional annotations out, what's left looks like this:
-->

``` kotlin
val sum: (Int, Int) -> Int = { x, y -> x + y }
```

<!--original
``` kotlin
val sum: (Int, Int) -> Int = { x, y -> x + y }
```
-->

ラムダ式がパラメータを1つだけ持っていることはよくあることです。もしKotlinが署名自体を理解することができれば、唯一のパラメータ宣言を省略することができ、暗黙のうちにそれを `it` という名で宣言します。

<!--original
It's very common that a lambda expression has only one parameter.
If Kotlin can figure the signature out itself, it allows us not to declare the only parameter, and will implicitly
declare it for us under the name `it`:
-->

``` kotlin
ints.filter { it > 0 } // このリテラルは '(it: Int) -> Boolean' 型
```

<!--original
``` kotlin
ints.filter { it > 0 } // this literal is of type '(it: Int) -> Boolean'
```
-->

関数が最後のパラメータとして別の関数を取る場合は、ラムダ式の引数は括弧で囲まれた引数リストの外に渡すことができることに注意してください。[callSuffix](grammar.html#call-suffix)のための文法を参照してください。

<!--original
Note that if a function takes another function as the last parameter, the lambda expression argument can be passed
outside the parenthesized argument list.
See the grammar for [callSuffix](grammar.html#call-suffix).
-->

### 無名関数

<!--original
### Anonymous Functions
-->

上記のラムダ式の構文から一つ欠落しているのは、関数の戻り値の型を指定する機能です。ほとんどの場合は、戻り型を自動的に推論することができるので不要です。しかし、それを明示的に指定する必要がある場合、別の構文を使用することができます。_無名関数_です。

<!--original
One thing missing from the lambda expression syntax presented above is the ability to specify the return type of the
function. In most cases, this is unnecessary because the return type can be inferred automatically. However, if you
do need to specify it explicitly, you can use an alternative syntax: an _anonymous function_.
-->

``` kotlin
fun(x: Int, y: Int): Int = x + y
```

<!--original
``` kotlin
fun(x: Int, y: Int): Int = x + y
```
-->

無名関数は、その名が省略されていることを除いて、通常の関数の宣言と非常のよく似ています。その本体は、式（上記のように）、またはブロックのいずれかになります：

<!--original
An anonymous function looks very much like a regular function declaration, except that its name is omitted. Its body
can be either an expression (as shown above) or a block:
-->

``` kotlin
fun(x: Int, y: Int): Int {
  return x + y
}
```

<!--original
``` kotlin
fun(x: Int, y: Int): Int {
  return x + y
}
```
-->

パラメータおよび戻り型は、それらが文脈から推測することができ、パラメータの種類を省略することができる場合を除き、通常の関数と同じ方法で指定されます。

<!--original
The parameters and the return type are specified in the same way as for regular functions, except that the parameter
types can be omitted if they can be inferred from context:
-->

``` kotlin
ints.filter(fun(item) = item > 0)
```

<!--original
``` kotlin
ints.filter(fun(item) = item > 0)
```
-->

無名関数の戻り値の型推論は普通の関数のように動作します：戻り値の型は式本体と無名関数のために自動的に推論され、ブロック本体で無名関数のために明示的に指定され（または `Unit` とされ）ます。

<!--original
The return type inference for anonymous functions works just like for normal functions: the return type is inferred
automatically for anonymous functions with an expression body and has to be specified explicitly (or is assumed to be
`Unit`) for anonymous functions with a block body.
-->

無名関数のパラメータは、常にかっこ内に渡されることに注意してください。括弧の外の関数を残すことができるように、速記構文はラムダ式に対してのみ機能します。

<!--original
Note that anonymous function parameters are always passed inside the parentheses. The shorthand syntax allowing
to leave the function outside the parentheses works only for lambda expressions.
-->

ラムダ式と無名関数の間のもう一つの違いは、[非局所的なリターン](inline-functions.html#non-local-returns)の動作です。ラベルなしの *return*{: .keyword } 文は、常に *fun*{: .keyword } キーワードで宣言された関数から返されます。これは、ラムダ式の内側からの *return*{: .keyword } は囲んでいる関数から返される一方で、無名関数の内部 *return*{: .keyword } は無名関数自体から返されることを意味します。

<!--original
One other difference between lambda expressions and anonymous functions is the behavior of
[non-local returns](inline-functions.html#non-local-returns). A *return*{: .keyword }  statement without a label
always returns from the function declared with the *fun*{: .keyword } keyword. This means that a *return*{: .keyword }
inside a lambda expression will return from the enclosing function, whereas a *return*{: .keyword } inside
an anonymous function will return from the anonymous function itself.
-->

### クロージャ

<!--original
### Closures
-->

ラムダ式や無名関数（ならびに[ローカル関数](functions.html#local-functions)や[オブジェクト式](object-declarations.html#object-expressions)）は、その _クロージャ_ 、すなわち、外側のスコープで宣言された変数にアクセスすることができます。Javaとは異なり、クロージャに取り込まれた変数を変更することができます。

<!--original
A lambda expression or anonymous function (as well as a [local function](functions.html#local-functions) and an [object expression](object-declarations.html#object-expressions))
can access its _closure_, i.e. the variables declared in the outer scope. Unlike Java, the variables captured in the closure can be modified:
-->

``` kotlin
var sum = 0
ints.filter { it > 0 }.forEach {
  sum += it
}
print(sum)
```


<!--original
``` kotlin
var sum = 0
ints.filter { it > 0 }.forEach {
  sum += it
}
print(sum)
```

-->

### レシーバ付き関数リテラル

<!--original
### Function Literals with Receiver
-->

Kotlinは、指定された _レシーバ・オブジェクト_ と関数リテラルを呼び出す機能を提供します。リテラル関数の本体内では、任意の追加の修飾子なしでそのレシーバオブジェクトのメソッドを呼び出すことができます。これは、関数の本体内にあるレシーバオブジェクトのメンバにアクセスすることを可能にする拡張機能に似ています。それらの使用法の最も重要な例の一つは、[型安全のGroovyスタイルのビルダー](type-safe-builders.html)です。

<!--original
Kotlin provides the ability to call a function literal with a specified _receiver object_.
Inside the body of the function literal, you can call methods on that receiver object without any additional qualifiers.
This is similar to extension functions, which allow you to access members of the receiver object inside the body of the function.
One of the most important examples of their usage is [Type-safe Groovy-style builders](type-safe-builders.html).
-->

このような関数リテラルの型は、レシーバを持つ関数型です：

<!--original
The type of such a function literal is a function type with receiver:
-->

``` kotlin
sum : Int.(other: Int) -> Int
```

<!--original
``` kotlin
sum : Int.(other: Int) -> Int
```
-->

それはレシーバオブジェクトのメソッドであるかのように関数リテラルを呼び出すことができます。

<!--original
The function literal can be called as if it were a method on the receiver object:
-->

``` kotlin
1.sum(2)
```

<!--original
``` kotlin
1.sum(2)
```
-->

無名関数の構文は、直接関数リテラルのレシーバの種類を指定することができます。レシーバを持つ関数型の変数を宣言し、後でそれを使用する必要がある場合に役立ちます。

<!--original
The anonymous function syntax allows you to specify the receiver type of a function literal directly.
This can be useful if you need to declare a variable of a function type with receiver, and to use it later.
-->

``` kotlin
val sum = fun Int.(other: Int): Int = this + other
```

<!--original
``` kotlin
val sum = fun Int.(other: Int): Int = this + other
```
-->

レシーバ型は文脈から推測することができる場合、ラムダ式は、レシーバ関数リテラルとして使用することができます。

<!--original
Lambda expressions can be used as function literals with receiver when the receiver type can be inferred from context.
-->

``` kotlin
class HTML {
    fun body() { ... }
}

fun html(init: HTML.() -> Unit): HTML {
  val html = HTML()  // レシーバオブジェクトを生成
  html.init()        // そのレシーバオブジェクトをラムダに渡す
  return html
}


html {       // レシーバ付きラムダがここから始まる
    body()   // レシーバオブジェクトのメソッドを呼んでいる
}
```

<!--original
``` kotlin
class HTML {
    fun body() { ... }
}

fun html(init: HTML.() -> Unit): HTML {
  val html = HTML()  // create the receiver object
  html.init()        // pass the receiver object to the lambda
  return html
}


html {       // lambda with receiver begins here
    body()   // calling a method on the receiver object
}
```
-->

# インライン関数

<!--original
# Inline Functions
-->

[高階関数](lambdas.html)を使用すると、特定のランタイムペナルティを課せられます。各関数はオブジェクトであり、それはクロージャ、すなわち、関数の本体でアクセスされるそれらの変数をキャプチャします。メモリ割り当て（関数オブジェクトとクラス用の両方）と仮想呼び出しは、実行時のオーバーヘッドを招きます。

<!--original
Using [higher-order functions](lambdas.html) imposes certain runtime penalties: each function is an object, and it captures a closure,
i.e. those variables that are accessed in the body of the function.
Memory allocations (both for function objects and classes) and virtual calls introduce runtime overhead.
-->

しかし、多くの場合、オーバーヘッドのこの種のラムダ式をインライン化することによって解消することができると思われます。以下に示す関数は、このような状況の良い例です。すなわち、`lock()` 関数は、簡単に呼び出し箇所でインライン化することができました。次のケースを考えてみます。

<!--original
But it appears that in many cases this kind of overhead can be eliminated by inlining the lambda expressions.
The functions shown above are good examples of this situation. I.e., the `lock()` function could be easily inlined at call-sites.
Consider the following case:
-->

``` kotlin
lock(l) { foo() }
```

<!--original
``` kotlin
lock(l) { foo() }
```
-->

パラメータやコールの生成のために関数オブジェクトを作成する代わりに、コンパイラは次のコードを放出する可能性があります：

<!--original
Instead of creating a function object for the parameter and generating a call, the compiler could emit the following code
-->

``` kotlin
l.lock()
try {
  foo()
}
finally {
  l.unlock()
}
```

<!--original
``` kotlin
l.lock()
try {
  foo()
}
finally {
  l.unlock()
}
```
-->

それは我々が当初から欲しかったものではないですか？

<!--original
Isn't it what we wanted from the very beginning?
-->

コンパイラがこれをできるようにするために、 `inline` 修飾子で `lock()` 関数をマークする必要があります：

<!--original
To make the compiler do this, we need to mark the `lock()` function with the `inline` modifier:
-->

``` kotlin
inline fun lock<T>(lock: Lock, body: () -> T): T {
  // ...
}
```

<!--original
``` kotlin
inline fun lock<T>(lock: Lock, body: () -> T): T {
  // ...
}
```
-->

`inline` 修飾子は、関数自体やそれに渡されたラムダの両方に影響を与えます。それらのすべては、呼び出し箇所の中でインライン化されます。

<!--original
The `inline` modifier affects both the function itself and the lambdas passed to it: all of those will be inlined
into the call site.
-->

インライン化では生成されるコードが大きくなる可能性がありますが、合理的な方法で（大きな関数をインライン化しないで）実行すると、特にループ内の 「メガモーフィック (megamorphic)」な呼び出し箇所でパフォーマンスが向上します。

<!--original
Inlining may cause the generated code to grow, but if we do it in a reasonable way (do not inline big functions)
it will pay off in performance, especially at "megamorphic" call-sites inside loops.
-->

## noinline

<!--original
## noinline
-->

インライン関数に渡されたラムダのうちのいくつかだけをインライン関数にしたい場合は、関数パラメータのいくつかに `noinline` 修飾子を付けることができます：

<!--original
In case you want only some of the lambdas passed to an inline function to be inlined, you can mark some of your function
parameters with the `noinline` modifier:
-->

``` kotlin
inline fun foo(inlined: () -> Unit, noinline notInlined: () -> Unit) {
  // ...
}
```

<!--original
``` kotlin
inline fun foo(inlined: () -> Unit, noinline notInlined: () -> Unit) {
  // ...
}
```
-->

Inlinableラムダは、インライン関数内でのみ呼び出すことができます。または、インライン展開可能な引数として渡すこともできますが、 `noinline` は、好きなように操作できます。例えば、フィールドに保持したり、誰かに渡したり等。

<!--original
Inlinable lambdas can only be called inside the inline functions or passed as inlinable arguments,
but `noinline` ones can be manipulated in any way we like: stored in fields, passed around etc.
-->

インライン関数にインライナブル関数パラメータがなく、[具体化型パラメータ](#reified-type-parameters)が指定されていない場合、コンパイラは警告を発します。このような関数のインライン展開は有益ではないためです（インライン展開が必要な場合は警告を抑制できます）。

<!--original
Note that if an inline function has no inlinable function parameters and no
[reified type parameters](#reified-type-parameters), the compiler will issue a warning, since inlining such functions is
 very unlikely to be beneficial (you can suppress the warning if you are sure the inlining is needed).
-->

## 非局所リターン

<!--original
## Non-local returns
-->

Kotlinでは、名前付き関数または無名関数を終了するには、通常、ラベル無し `return` のみを使用することができます。これは、ラムダを終了するには[ラベル](returns.html#return-at-labels)を使用しなければならず、ラムダが自身を内包する関数からの `return` を作ることができないため、ラムダ内での裸のリターンは禁止されていることを意味します。

<!--original
In Kotlin, we can only use a normal, unqualified `return` to exit a named function or an anonymous function.
This means that to exit a lambda, we have to use a [label](returns.html#return-at-labels), and a bare `return` is forbidden
inside a lambda, because a lambda can not make the enclosing function return:
-->

``` kotlin
fun foo() {
  ordinaryFunction {
     return // エラー: `foo` をここで return することはできない
  }
}
```

<!--original
``` kotlin
fun foo() {
  ordinaryFunction {
     return // ERROR: can not make `foo` return here
  }
}
```
-->

しかし、ラムダがインライン化されるために渡された関数の場合は、リターンも同様にインライン化することができ、それが許可されています。

<!--original
But if the function the lambda is passed to is inlined, the return can be inlined as well, so it is allowed:
-->

``` kotlin
fun foo() {
  inlineFunction {
    return // OK: ラムダはインライン
  }
}
```

<!--original
``` kotlin
fun foo() {
  inlineFunction {
    return // OK: the lambda is inlined
  }
}
```
-->

（ラムダに位置するが、内包する関数から抜ける）このようなリターンは、 *非局所リターン* と呼ばれています。私たちは、インライン関数がしばしば内包するこのようなループの構造に慣れています。

<!--original
Such returns (located in a lambda, but exiting the enclosing function) are called *non-local* returns. We are used to
this sort of constructs in loops, which inline functions often enclose:
-->

``` kotlin
fun hasZeros(ints: List<Int>): Boolean {
  ints.forEach {
    if (it == 0) return true // hasZeros から return する
  }
  return false
}
```

<!--original
``` kotlin
fun hasZeros(ints: List<Int>): Boolean {
  ints.forEach {
    if (it == 0) return true // returns from hasZeros
  }
  return false
}
```
-->

インライン関数の中には、渡されたラムダを、関数本体から直接ではなく、ローカルオブジェクトやネストされた関数などの別の実行コンテキストからのパラメータとして呼び出すものがあります。このような場合には、非局所制御フローもラムダでは許可されません。それを示すために、ラムダパラメータを `crossinline` 修飾子でマークする必要があります

<!--original
Note that some inline functions may call the lambdas passed to them as parameters not directly from the function body,
but from another execution context, such as a local object or a nested function. In such cases, non-local control flow
is also not allowed in the lambdas. To indicate that, the lambda parameter needs to be marked with
the `crossinline` modifier:
-->

``` kotlin
inline fun f(crossinline body: () -> Unit) {
    val f = object: Runnable {
        override fun run() = body()
    }
    // ...
}
```


<!--original
``` kotlin
inline fun f(crossinline body: () -> Unit) {
    val f = object: Runnable {
        override fun run() = body()
    }
    // ...
}
```

-->

`break` と `continue` はインライン化されたラムダではまだ利用できませんが、我々はそれらをサポートすることを計画しています。

<!--original
> `break` and `continue` are not yet available in inlined lambdas, but we are planning to support them too
-->

## 具体化型パラメータ (Reified type parameters)

<!--original
## Reified type parameters
-->

時にはパラメータとして渡された型にアクセスする必要があります。

<!--original
Sometimes we need to access a type passed to us as a parameter:
-->

``` kotlin
fun <T> TreeNode.findParentOfType(clazz: Class<T>): T? {
    var p = parent
    while (p != null && !clazz.isInstance(p)) {
        p = p?.parent
    }
    @Suppress("UNCHECKED_CAST")
    return p as T
}
```

<!--original
``` kotlin
fun <T> TreeNode.findParentOfType(clazz: Class<T>): T? {
    var p = parent
    while (p != null && !clazz.isInstance(p)) {
        p = p?.parent
    }
    @Suppress("UNCHECKED_CAST")
    return p as T
}
```
-->

ここでは、ツリーをたどってリフレクションを使用して、ノードに特定のタイプがあるかどうかを確認します。全く問題はないのですが、呼び出し箇所はそれほど美味しくなりません：

<!--original
Here, we walk up a tree and use reflection to check if a node has a certain type.
It’s all fine, but the call site is not very pretty:
-->

``` kotlin
myTree.findParentOfType(MyTreeNodeType::class.java)
```

<!--original
``` kotlin
myTree.findParentOfType(MyTreeNodeType::class.java)
```
-->

私たちが実際にしたいのはこの関数に型を渡すだけ、すなわち、このように呼び出すだけです：

<!--original
What we actually want is simply pass a type to this function, i.e. call it like this:
-->

``` kotlin
myTree.findParentOfType<MyTreeNodeType>()
```

<!--original
``` kotlin
myTree.findParentOfType<MyTreeNodeType>()
```
-->

これを有効にするには、インライン関数が *具体化型パラメータ* をサポートするので、私たちはこのように書くことができます：

<!--original
To enable this, inline functions support *reified type parameters*, so we can write something like this:
-->

``` kotlin
inline fun <reified T> TreeNode.findParentOfType(): T? {
    var p = parent
    while (p != null && p !is T) {
        p = p?.parent
    }
    return p as T
}
```

<!--original
``` kotlin
inline fun <reified T> TreeNode.findParentOfType(): T? {
    var p = parent
    while (p != null && p !is T) {
        p = p?.parent
    }
    return p as T
}
```
-->

私たちは `reified` 修飾子で型パラメータを修飾しました。これで、関数内でアクセス可能になり、これは通常のクラスと同じように機能します。関数はインライン化されているので、リフレクションは必要ありません。 `!is` や `as` のような通常の演算子が動作するようになります。また、前述したようなやりかたで呼び出すことができます：`myTree.findParentOfType<MyTreeNodeType>()`

<!--original
We qualified the type parameter with the `reified` modifier, now it’s accessible inside the function,
almost as if it were a normal class. Since the function is inlined, no reflection is needed, normal operators like `!is`
and `as` are working now. Also, we can call it as mentioned above: `myTree.findParentOfType<MyTreeNodeType>()`.
-->

リフレクションは多くの場合に必要とされないかもしれませんが、まだ具体化型パラメータでそれを使用することができます：

<!--original
Though reflection may not be needed in many cases, we can still use it with a reified type parameter:
-->

``` kotlin
inline fun <reified T> membersOf() = T::class.members

fun main(s: Array<String>) {
  println(membersOf<StringBuilder>().joinToString("\n"))
}
```

<!--original
``` kotlin
inline fun <reified T> membersOf() = T::class.members

fun main(s: Array<String>) {
  println(membersOf<StringBuilder>().joinToString("\n"))
}
```
-->

通常の機能（インラインとしてマークされていない）は具体化パラメータをもつことはできません。実行時表現を持たない型（例えば、非reified型パラメータや `Nothing` のような架空の型）は、reified 型のパラメータの引数として使用できません。

<!--original
Normal functions (not marked as inline) can not have reified parameters.
A type that does not have a run-time representation (e.g. a non-reified type parameter or a fictitious type like `Nothing`)
can not be used as an argument for a reified type parameter.
-->

低レベルの説明については、[仕様書](https://github.com/JetBrains/kotlin/blob/master/spec-docs/reified-type-parameters.md)を参照してください。

<!--original
For a low-level description, see the [spec document](https://github.com/JetBrains/kotlin/blob/master/spec-docs/reified-type-parameters.md).
-->


---

# ※権利関係について
リファレンスのオリジナルを作ったJetBrain社は[Contributing to Kotlin](https://kotlinlang.org/contribute.html#translations)で、「あなたの言語に翻訳し、Webサイト上で閲覧可能にすることを歓迎する。」 ( _You are welcome to translate the Kotlin documentation into your own language and to publish your translation on your Web site._ ) と宣言しています。

また、オリジナルは[github上のプロジェクト](https://github.com/JetBrains/kotlin-web-site)で管理されており、ライセンス表示が[Apache License ver. 2.0](https://github.com/JetBrains/kotlin-web-site/blob/master/LICENSE)で宣言されています。従って本ドキュメントもそれにならって、ライセンスを[Apache License ver. 2.0](https://github.com/dogwood008/kotlin-web-site-ja/blob/master/LICENSE)とします。