Kotlin文法 - アノテーション、リフレクション、型安全なビルダー、動的型

Kotlin 文法 - this、等価性、演算子オーバーロード、Null 安全、例外の続き。

Kotlin Referenceの Other 章 Annotations, Reflection, Type-Safe Builders, Dynamic Type の大雑把日本語訳。適宜説明を変えたり端折ったり補足したりしている。

この記事は Qiita の記事 と同じものです。

アノテーション

アノテーション宣言

アノテーションはコードにメタデータを付加する手段。アノテーションを宣言するには、class の前に annotation 修飾子を付ける。

// Fancyアノテーションを宣言する
annotation class Fancy

アノテーションクラスをメタアノテーションで修飾することで、アノテーションの付加属性を指定できる。

  • @Target はアノテーションを付けられる要素のあり得る種類(クラス、関数、プロパティ、式など)を指定する。
  • @Retention は、アノテーションをコンパイルされたクラスファイルに含めるかと、実行時にリフレクションを通して可視化するかどうかを指定する。デフォルトはどちらも true
  • @Repetableは1つのエレメントに同じアノテーションを複数回使うことを許可する。
  • @MustBeDocumented はアノテーションを公開 API の一部とするか、生成される API ドキュメントに表示されるクラスやメソッドのシグネチャに含めるべきかどうかを指定する。
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION,
        AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION)
@Retention(AnnotationRetention.SOURCE)
@MustBeDocumented
public annotation class Fancy

使い方

@Fancy class Foo {
  @Fancy fun baz(@Fancy foo: Int): Int {
    return (@Fancy 1)
  }
}

もしクラスのプライマリコンストラクタを修飾したいなら、コンストラクタ宣言で constructor を付ける必要がある。アノテーションはその前に付ける。

class Foo @Inject constructor(dependency: MyDependency) {
  // ...
}

アクセサにも付けられる。

class Foo {
    var x: MyDependency? = null
        @Inject set
}

コンストラクタ

アノテーションはパラメータを取るコンストラクタを持つかもしれない。

annotation class Special(val why: String)

@Special("example") class Foo {}

パラメータの型として許されるのは以下。

  • Java のプリミティブ型に対応する型(Int, Long など)
  • 文字列
  • クラス(Foo::class)
  • enum
  • 他のアノテーション
  • 上に挙げた型の配列

アノテーションを他のアノテーションのパラメータとして使う場合、その名前の前に @ は付けない。

public annotation class ReplaceWith(val expression: String)

public annotation class Deprecated(
        val message: String,
        val replaceWith: ReplaceWith = ReplaceWith(""))

@Deprecated("This function is deprecated, use === instead", ReplaceWith("this === other"))

ラムダ

アノテーションはラムダにも使うことができる。ラムダのボディが生成される先の invoke() メソッドに適用される。これはQuasar(並列性の制御にアノテーションを使う)のようなフレームワークで便利。

annotation class Suspendable

val f = @Suspendable { Fiber.sleep(10) }

アノテーション利用場所ターゲット

プロパティやプライマリコンストラクタのパラメータを修飾するとき、Kotlin の要素に対応する Java 要素が複数生成され、それゆえ生成される Java バイトコードにアノテーションが配置される場所が複数生じてしまう。アノテーションの生成を正確に指定するため、以下の書式が使える。

// コンストラクタの引数にvalを付けるとプロパティも一緒に生成される。
// プロパティにはバッキングフィールドとゲッターが生成される。
// アノテーションは引数に付くの?プロパティのフィールド?それともゲッター?
class Example(@field:Ann val foo,    // Javaフィールドを修飾する
              @get:Ann val bar,      // Javaのgetterを修飾する
              @param:Ann val quux)   // Javaコンストラクタ引数を修飾する

同じ書式はファイル全体の修飾にも使える。それにはファイルのトップレベルで、package 命令の前か、デフォルトパッケージなら全ての import の前に、file ターゲット付きのアノテーションを置く。

@file:JvmName("Foo")

package org.jetbrains.demo

同じターゲットに複数のアノテーションが必要なら、括弧を使って中にアノテーションを並べることで、ターゲットを繰り返し書くのを避けられる。

class Example {
     // @set:Inject @set:VisibleForTesting と書かなくても以下のように書ける
     @set:[Inject VisibleForTesting]
     public var collaborator: Collaborator
}

利用場所ターゲットの全てのリストは以下。

  • file
  • property (このターゲット付きのアノテーションは Java からは見えない)
  • field
  • get(プロパティのゲッター)
  • set(プロパティのセッター)
  • receiver(拡張関数やプロパティのレシーバパラメータ)
  • param(コンストラクタ引数)
  • setparam(プロパティのセッター引数)

拡張関数のレシーバパラメータを修飾するには以下の書式を使う。

fun @receiver:Fancy String.myExtension() { }

利用場所ターゲットを指定しない場合、利用されているアノテーションの @Target に従って選択される。もし複数のターゲットがあり得るなら、次のリストから最初の適用可能なターゲットが使われる。

  • param
  • property
  • field

Java アノテーション

Java アノテーションは Kotlin と 100%互換性がある。

import org.junit.Test
import org.junit.Assert.*

class Tests {
  @Test fun simple() {
    assertEquals(42, getTheAnswer())
  }
}

Java で書かれたアノテーションのパラメータは順番が定義されていないので、引数を渡すのに通常の関数呼び出しの書式は利用できない。代わりに名前付き引数を使う必要がある。

// Java
public @interface Ann {
    int intValue();
    String stringValue();
}
// Kotlin
@Ann(intValue = 1, stringValue = "abc") class C

Java と同様に value パラメータは特別で、名前を明示しなくていい。

// Java
public @interface AnnWithValue {
    String value();
}
// Kotlin
@AnnWithValue("abc") class C

もし Java の value パラメータが配列なら、Kotlin では vararg (可変長)パラメータになる。

// Java
public @interface AnnWithArrayValue {
    String[] value();
}
// Kotlin
@AnnWithArrayValue("abc", "foo", "bar") class C

もしアノテーションの引数としてクラスを指定する必要があるなら、Kotlin クラス(KClass)を使う。Kotlin コンパイラは自動的にそれを Java クラスに変換するので、Java コードは普通にアノテーションと引数を見ることができる。

import kotlin.reflect.KClass

annotation class Ann(val arg1: KClass<*>, val arg2: KClass<out Any?>)

@Ann(String::class, Int::class) class MyClass

アノテーションインスタンスの値は Kotlin コードにはプロパティに見える。

// Java
public @interface Ann {
    int value();
}
// Kotlin
fun foo(ann: Ann) {
    val i = ann.value
}

リフレクション

リフレクションは実行時にプログラムの構造を覗き見ることを可能とする言語やライブラリの仕組みである。Kotlin は関数やプロパティを第 1 級市民にしており、それらを覗き見る(つまり実行時に関数やプロパティの型や名前が分かる)ことは関数型やリアクティブスタイルを簡単に用いることと密接に結びついている。

注:Java プラットフォームでは、リフレクション機能を使うランタイムコンポーネントは別の JAR ファイル(kotlin-reflect.jar)として配布される。これによってリフレクションを使わないアプリケーションに要求されるランタイムライブラリサイズを削減している。もしリフレクションを使うなら、プロジェクトのクラスパスにその .jar ファイルを追加するのを忘れないこと。

クラス参照

最も基本的なリフレクション機能は、Kotlin クラスへの実行時参照を取得すること。静的に分かっている Kotlin クラスへの参照を取得するには、クラスリテラル書式が利用できる。

val c = MyClass::class

参照は KClass 型の値。

Kotlin クラス参照は Java クラス参照と同じではないことに注意。Java クラス参照を得るには、KClass インスタンスの .java プロパティを使う。

関数参照

以下のような名前付き関数があるとき、

fun isOdd(x: Int) = x % 2 != 0

これを簡単に直接呼び出せる( isOdd(5) )。けどこれを値として渡すこともできる。つまり他の関数に。それには :: 演算子を使う。

val numbers = listOf(1, 2, 3)
println(numbers.filter(::isOdd)) // [1, 3]を表示する

ここで ::isOdd(Int) -> Boolean 関数型の値である。

:: 演算子はオーバーロード関数には使えないことに注意。将来的には、関数の特定のオーバーロードが選択可能なようにパラメータ型を指定する書式を提供することを計画している。

例:関数合成

次の関数を考えてみる。

fun <A, B, C> compose(f: (B) -> C, g: (A) -> B): (A) -> C {
    return { x -> f(g(x)) }
}

これは渡された2つの関数を合成したものを返す。つまり compose(f, g) = f(g(*)) 。これを呼び出し可能な参照に適用できる。

fun length(s: String) = s.size

// isOdd(length(s)) の動作をする関数を作って oddLength に格納する
val oddLength = compose(::isOdd, ::length)
val strings = listOf("a", "ab", "abc")

// 渡した文字列のリストのうち、長さが奇数のものだけ表示する
println(strings.filter(oddLength)) // "[a, abc]"と表示される

プロパティ参照

Kotlin で第 1 級オブジェクトとしてプロパティにアクセスするのにも、:: 演算子が利用できる。

var x = 1

fun main(args: Array<String>) {
    println(::x.get()) // "1"が表示される
    ::x.set(2)
    println(x)         // "2"が表示される
}

::xKProperty<Int> 型のプロパティオブジェクトと等価である1。これを使うと get() で値を読みだしたり、name プロパティでプロパティ名を取得したりできる。詳細はKProperty クラスのドキュメントを参照。

変更可能なプロパティ(例えば var y = 1)には、::yset() を持つ KMutableProperty<Int> を返す。

プロパティ参照は引数のない関数が期待される場所で使うことができる。

val strs = listOf("a", "bc", "def")
// mapの処理として、各String要素のlengthプロパティを指定する
println(strs.map(String::length)) // [1, 2, 3] を表示する

クラスメンバのプロパティにアクセスするには修飾する。

class A(val p: Int)

fun main(args: Array<String>) {
    val prop = A::p         // Aクラスのpプロパティ参照をpropに代入
    println(prop.get(A(1))) // "1"を表示する
}

拡張プロパティには以下のようにする。

// StringにlastChar拡張プロパティを用意
val String.lastChar: Char
  get() = this[size - 1]

fun main(args: Array<String>) {
  println(String::lastChar.get("abc")) // "c"を表示する
}

Java リフレクションとの相互運用性

Java プラットフォームでは、標準ライブラリがリフレクションクラスの拡張を用意している。その拡張が Java リフレクションオブジェクトとの間のマッピングを提供する。例えば、バッキングフィールドや Kotlin プロパティの getter として提供される Java メソッドを見つけるために、こんな風に書ける。

// 標準ライブラリが提供しているJavaとのリフレクション相互運用拡張を使う
import kotlin.reflect.jvm.*

class A(val p: Int)

fun main(args: Array<String>) {
    // KotlinクラスであるAのプロパティpのJavaでのGetterメソッドを表示
    println(A::p.javaGetter) // "public final int A.getP()" と表示される
    // KotlinクラスであるAのプロパティpのJavaでのバッキングフィールドを表示
    println(A::p.javaField)  // "private final int A.p" と表示される
}

Java クラスに対応する Kotlin クラスを取得するには、.kotlin 拡張プロパティを使う。

fun getKClass(o: Any): KClass<Any> = o.javaClass.kotlin

コンストラクタ参照

コンストラクタもメソッドやプロパティと同じように参照できる。コンストラクタと引数が同じで適切な型の戻り値を持つ関数型オブジェクトが期待される場所なら、どこでも利用できる。コンストラクタは :: 演算子の後にクラス名を加えることで参照できる。「引数なしで Foo を返す関数」を引数として期待する、次の関数を考えてみよう。

class Foo

fun function(factory : () -> Foo) {
    val x : Foo = factory()
}

::Foo を使うことで、Foo の引数なしコンストラクタを、こんな風に簡単に呼び出せる。

function(::Foo)

型安全なビルダー

ビルダーの概念は Groovy コミュニティではかなりポピュラー。ビルダーを用いると準宣言的にデータを定義できる。ビルダーはXML 生成UI コンポーネントのレイアウト3D シーンの描写などで便利。

多くの利用ケースで、Kotlin は型安全なビルダーを提供できる。型安全性であることで Groovy での動的型付け実装よりも魅力的なものになる。

残りの事例では、Kotlin は動的片付けビルダーをサポートする。

型安全なビルダーの例

次のコードを考えてみよう。

import com.example.html.*

fun result(args: Array<String>) =
  html {
    head {
      title {+"KotlinでのXMLエンコーディング"}
    }
    body {
      h1 {+"KotlinでのXMLエンコーディング"}
      p  {+"このフォーマットはXMLマークアップの代替として利用できる。"}

      // 属性とテキストを持つ要素
      a(href = "http://kotlinlang.org") {+"Kotlin"}

      // 複合コンテンツ
      p {
        +"これは幾つかの"
        b {+"複合された"}
        +"テキスト。詳細は"
        a(href = "http://kotlinlang.org") {+"Kotlin"}
        +"プロジェクトを参照。"
      }
      p {+"いくらかのテキスト"}

      // 生成される内容
      p {
        for (arg in args)
          +arg
      }
    }
  }

これは完全に正当な Kotlin コードである。ここで(変更してブラウザで実行して)このコードをオンラインで試すことができる。

どうやって動作しているか

Kotlin での型安全なビルダーの実装メカニズムを順に見ていこう。まず最初に組み立てたいモデルを定義する。ここの例では HTML タグのモデルが必要だ。これは一連のクラスを用意すれば済む。例えば <html> タグを表すのは HTML クラスで、これは <head><body> を子供として定義する。(宣言は下を参照。)

コードの中でこんな風に書けるのは何故なのか思い出してみよう。

html {
 // ...
}

html は実際にはラムダ式を引数に取る関数だ。この関数は次のように定義されている。

fun html(init: HTML.() -> Unit): HTML {
  val html = HTML()
  html.init()
  return html
}

この関数はinit という名前の1つの引数を取り、その引数自身が関数である。(引数の)関数の型は HTML.() -> Unit で、これはレシーバ付きの関数だ。これは関数に HTML 型のインスタンス(レシーバ)を渡さなければならず、関数の中でそのインスタンスのメンバを呼び出せることを意味する。レシーバは this キーワードを通してアクセスできる。

html {
  this.head { /* ... */ }
  this.body { /* ... */ }
}

headbodyhtml のメンバ関数。)

ここで this は普通は省略できる。もうすでにすごくビルダーっぽい感じに見える。

html {
  head { /* ... */ }
  body { /* ... */ }
}

それで、この呼び出しは何をやってるんだろう?上で定義した html 関数のボディを見てくれ。新しい HTML インスタンスを生成してる。それから引数として渡された関数を呼び出して初期化する(この例では HTML インスタンスの headbody を呼び出しを行ってる)。それからそのインスタンスを返す。これこそビルダーがやるべきことだ。

HTML クラスの headbody 関数は html に似た感じで定義されている。唯一の違いは構築したインスタンスを HTML インスタンスの children に追加することだけ。

fun head(init: Head.() -> Unit) : Head {
  val head = Head()
  head.init()
  children.add(head)  // 内部のコレクションに追加する
  return head
}

fun body(init: Body.() -> Unit) : Body {
  val body = Body()
  body.init()
  children.add(body)  // 内部のコレクションに追加する
  return body

実際これら2つの関数は同じことをやっているので、ジェネリックバージョン initTag を用意できる。

  protected fun <T : Element> initTag(tag: T, init: T.() -> Unit): T {
    tag.init()
    children.add(tag)
    return tag
  }

するとさっきの関数はすっきりとこうなる。

fun head(init: Head.() -> Unit) = initTag(Head(), init)

fun body(init: Body.() -> Unit) = initTag(Body(), init)

これで headbody タグを構築するのにこれらが使えるようになった。

もう一個ここで考察するのは、どうやってテキストをタグの中に入れるかだ。上の例でこんな感じで書いた。

html {
  head {
    title {+"XML encoding with Kotlin"}
  }
  // ...
}

基本的にはタグの中に文字列を書くだけなのだが、その前に + がある。これは unaryPlus() 演算子関数を呼び出す。この演算子は(Title の親の)TagWithText 抽象クラスのメンバである拡張関数 unaryPlus によって定義されている。

// title内で + をStringに対して呼び出すと、StringのunaryPlusメソッドまたは拡張関数を探す。
// するとTitleの親クラスであるこのTagWithTextクラスに、String.unaryPlus拡張関数が見つかるので、
// 文字列をレシーバにしてこれを呼び出す。
abstract class TagWithText(name: String) : Tag(name) {
    operator fun String.unaryPlus() {
        children.add(TextElement(this))  // ここでのthisはレシーバで、型はString
    }
}

ここで前置の + がやっているのは、文字列を TextElement のインスタンスにラップして、それを children コレクションに追加している。これで文字列はタグ木構造の正式な一部になれた。

これら全ては上の方にあるビルダーの例のトップで import している com.example.html パッケージに定義されている。

com.example.html パッケージの定義全部

package com.example.html

interface Element {
    fun render(builder: StringBuilder, indent: String)
}

class TextElement(val text: String) : Element {
    override fun render(builder: StringBuilder, indent: String) {
        builder.append("$indent$text\n")
    }
}

abstract class Tag(val name: String) : Element {
    val children = arrayListOf<Element>()
    val attributes = hashMapOf<String, String>()

    protected fun <T : Element> initTag(tag: T, init: T.() -> Unit): T {
        tag.init()
        children.add(tag)
        return tag
    }

    override fun render(builder: StringBuilder, indent: String) {
        builder.append("$indent<$name${renderAttributes()}>\n")
        for (c in children) {
            c.render(builder, indent + "  ")
        }
        builder.append("$indent</$name>\n")
    }

    private fun renderAttributes(): String? {
        val builder = StringBuilder()
        for (a in attributes.keys) {
            builder.append(" $a=\"${attributes[a]}\"")
        }
        return builder.toString()
    }


    override fun toString(): String {
        val builder = StringBuilder()
        render(builder, "")
        return builder.toString()
    }
}

abstract class TagWithText(name: String) : Tag(name) {
    operator fun String.unaryPlus() {
        children.add(TextElement(this))
    }
}

class HTML() : TagWithText("html") {
    fun head(init: Head.() -> Unit) = initTag(Head(), init)

    fun body(init: Body.() -> Unit) = initTag(Body(), init)
}

class Head() : TagWithText("head") {
    fun title(init: Title.() -> Unit) = initTag(Title(), init)
}

class Title() : TagWithText("title")

abstract class BodyTag(name: String) : TagWithText(name) {
    fun b(init: B.() -> Unit) = initTag(B(), init)
    fun p(init: P.() -> Unit) = initTag(P(), init)
    fun h1(init: H1.() -> Unit) = initTag(H1(), init)
    fun a(href: String, init: A.() -> Unit) {
        val a = initTag(A(), init)
        a.href = href
    }
}

class Body() : BodyTag("body")
class B() : BodyTag("b")
class P() : BodyTag("p")
class H1() : BodyTag("h1")

class A() : BodyTag("a") {
    public var href: String
        get() = attributes["href"]!!
        set(value) {
            attributes["href"] = value
        }
}

fun html(init: HTML.() -> Unit): HTML {
    val html = HTML()
    html.init()
    return html
}

動的型

注:JVM をターゲットにしたコードでは動的型はサポートされない。

Kotlin は静的型付け言語でありながら、Javascript エコシステムのような型のないまたは型付けのゆるい環境とも相互運用しないといけない。これらの利用状況を手助けするために、言語内で動的な型が利用できる。

val dyn: dynamic = ...

動的型は基本的に Kotlin の型チェックを止める。

  • この型の値はどんな変数にも入れられ、パラメータとしてどこにでも渡せる。
  • どんな値も dynamic 型の変数に代入でき、パラメータとして dynamic を取る関数に渡せる。
  • これらの値で null チェックは無効

dynamic 型の最も特徴的な機能は dynamic 変数に対してどんなプロパティや関数も呼び出せること。

dyn.whatever(1, "foo", dyn) // 'whatever' はどこにも定義されていない
dyn.whatever(*array(1, 2, 3))

Javascript プラットフォームでは、このコードは「そのまま」コンパイルされる。つまり Kotlin での dyn.whatever(1) は生成された Javascript コードでは dyn.whatever(1) となる。

動的呼び出しは常に結果として dynamic を返す。なので自由にチェイン呼び出しできる。

dyn.foo().bar.baz()

動的呼び出しにラムダを渡す時は、デフォルトで全てのパラメータの型は dynamic になる。

dyn.foo {
  x -> x.bar() // x は dynamic
}

次へ

これで Kotlin 文法はおしまい。お疲れ様!!

次はKotlin - Java との相互運用をどうぞ。


  1. 上の例で x は var なので KMutablePropertyになるはず。KPropertyになるのは val のとき。

Tags