コトリン❤FP

"Habrahabr"の読者に記事"Functional programming in Kotlin"の無料翻訳を提供します。 この出版物の著者はマイク・ハーンです。







.NETを使用している人は、おそらくCLRの汎用機能プログラミング言語であるF＃を聞いたことがあるでしょう。 .NETコミュニティ以外のプログラマーは、Haskell言語に関連した関数型プログラミングを知っている可能性が高いです。



いずれにせよ、多くの人が似たような言語を好むと思いますが、JVMには高度なツールがあり、機能的なスタイルですべてを行う必要はありません。



JetBrainsの Kotlin言語（ kotlinlang.org ）は、Javaの甘いもののように見えるかもしれません：構文規則、型推論など。 しかし、その単純なシェルの下では、関数型言語の最も一般的で進歩的な構成をすべて見つけることができます。



典型的な機能構成の簡単な例から始めましょう。

代数データ型

この構文は、ほとんどの機能言語の非常に典型的なものです。

data Maybe a = Nothing | Just a deriving (Eq, Ord)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これはHaskellであり、Maybe型が定義されています。この型には、NothingとJustの2つのコンストラクターがあります。 Justコンストラクターは、未定義の型の単一のパラメーターを受け入れます。 「派生」キーワードは、タイプオブジェクトを比較し、等しいかどうかをチェックするためのコードを自動的に生成します。



KotlinにはMaybeクラスは必要ありません。値を返すかどうかを返す機能は、型システムに既に備わっているためです。 結果のオプション性はプログラムで非常に一般的であるため、言語のコアでそれを維持するのが理にかなっています。 これにより、利便性とパフォーマンスの両方が向上します。

 val s: String? = if (Math.random() < 0.5) "Yay!" else null println("length of string is .... ${ s.length() }")
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

行の長さを計算しようとしているため、2行目はここではコンパイルされません。 これは簡単に修復できます。

 val s: String? = if (Math.random() < 0.5) "Yay!" else null println("length of string is .... ${ s?.length() ?: -1 }")
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

「s？.Length（）」コンストラクトは、文字列が「null」だった場合は「null」を返し、「?:」演算子は「null」が左側にあるときに右側を返します。 つまり、突然行がまだない場合、コードは「-1」を出力します。



Kotlinには「null」型を操作するための完全なツールセットがありますので、ご安心ください。 しかし、簡潔にするためにこれについては話さないでください。



代わりに、単に説明のために、Kotlinで多分対応するものを定義しましょう。

 sealed class Maybe<out T> { object None : Maybe<Nothing>() data class Just<T>(val t: T) : Maybe<T>() }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

もちろん、構文はHaskellほど短くはありませんが、かなり受け入れられます。 「データ」修飾子はオプションですが、いくつかの便利な機能が追加されています。



すべてが驚くことなく機能します。

 val j = Maybe.Just(1) val (i) = j
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここでは、内部に数値（Int）を含むだけを定義してから、数値を抽出して戻します。 言及されたタイプはありません。それらはすべて自動的に表示されます。 ちょうどいくつかのフィールドがあった場合、それらすべてを抽出することができます。これが実際にこの構築の目的です：

 data class Pet(val name: String, val age: Int) val alice = Pet("Alice", 6) val (name, age) = alice
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

しかし、パターンマッチングはどうでしょうか。 これはまさに「封印された」キーワードを必要としていたものです。 これにより、コンパイラは、JustおよびNone以外にMaybeの他のサブクラスが存在できないことを認識し、すべてのバリアントを分岐する場合、else分岐は不要です。

 class User(val age: Int) fun lookupFromDB(s: String): Maybe<User> = Maybe.None fun printUser(username: String) { val rec = lookupFromDB(username) when (rec) { is Maybe.None -> println("not found") is Maybe.Just<User> -> println("${rec.t.age} years old") } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

単一の不変の「年齢」フィールドを持つ単純なクラスは上記で定義されています。 lookupFromDBメソッドはデータベースへのアクセスを模倣し、 `Maybe`を返します。 私たちの場合、常にNoneですが、これは単なる例です。



その後、戻り値は「when」演算子を使用して型にマップされます。 `when`構文を使用すると、多くのことができます。 特に、引数を型と正しく一致させた後、右側の内側で、引数はそれに応じて型を変更します。 そのため、2番目のブランチの右側では、クラス「User」のフィールド「t」を不必要な式なしで使用できます。

不変性

Kotlinは純粋に機能的な言語ではないため、不変オブジェクトは同等の条件で可変オブジェクトと共存します。 設計では、プログラマーが不変オブジェクトを使用することを控えめに奨励しますが、一般に、選択は開発者に常にあります。



たとえば、ここに：

 data class Person(var name: String, var age: Int) val p = Person("Mike", 31) p.name = "Bob"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここで、「p」は不変の値（値）です。 Javaの「最終変数」、またはHaskell / F＃の「let」に似ています。 ただし、このオブジェクトの内容は可変変数（可変）で構成されているため、再割り当てできます。 IDEの強調表示は、可変フィールドと不変フィールドを区別するのに役立ちます。



同じ例ですが、すべてのリンクは不変です：

 data class Person(val name: String, val age: Int) val mike = Person("Mike", 31) val olderMike = mike.copy(age = 32)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

`data`クラスのコピーメソッドは自動的に作成されます。 クラスの各フィールドには、デフォルトで現在の値に等しい名前付きパラメーターがあります。 結果として、新しい「微調整」オブジェクトを作成するために使用すると便利です。



リストはデフォルトで不変です：

 val people = listOf(mike, olderMike) people.add(Person("Bob", 50)) // ERROR val peopleDB = arrayListOf(mike, olderMike) peopleDB.add(Person("Bob", 50)) val view: List<Person> = peopleDB val snapshot = peopleDB.toList()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

2行目はコンパイルしません： `listOf（）`は不変リストを返します。 しかし、4行目では、すべてが整然としています。これは、変更可能な「ArrayList」を具体的に要求したためです。 もちろん、どのリストも常に不変の `List`インターフェースに持ち込まれ、「読み取り専用ビュー」を作成できます。



現時点では、言語にはリストの組み込み構文がないため、可変数の引数を持つ関数を使用してリストを作成します。

マッピング、フィルタリング、削減、その他の利点

Kotlinはラムダ式をサポートし、機能的な世界からの一般的なメソッドで標準JDKコレクションを拡張します。 これはJava 6まで使用できるため、どのAndroidデバイスでも使用できます。

 val nums = listOf(1, 2, 3, 4) val r = nums.map { it * 2 }.sum() // r == 20
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

「it」はラムダパラメータの自動名であり、ラムダが引数を1つだけ取る場合に表示されることに注意してください。 もちろん、自分でいつでもよりわかりやすい名前を設定できます。 そのため、たとえば、ネストされたラムダで行うことをお勧めします。



ここで、「map」は拡張機能です。 Kotlinでは、このような関数を任意のクラスに追加して、外部APIを改善できます。 これは、静的メソッドを使用するjava `FooUtils`に似ていますが、はるかに便利です。 拡張関数は標準ライブラリで積極的に使用され、Javaからクラスに機能を追加し、Kotlin自体のインターフェイスの量を減らします。



より高度な例：

 val strs = listOf("fish", "tree", "dog", "tree", "fish", "fish") val freqs = strs.groupBy { it }.mapValues { it.value.size() } println(freqs) // {fish=3, tree=2, dog=1}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

再帰

関数型プログラミングのパラダイムでは、循環コードはしばしば再帰的な関数呼び出しとして便利に表現されます。 パフォーマンスを失わないために、Haskellのような言語コンパイラは、いわゆる末尾呼び出し最適化（末尾呼び出し最適化）を使用します。 この最適化は、再帰呼び出しが関数の最後の操作である場合にのみ機能し、Kotlinコンパイラーはそれをチェックします。



最も単純な例：数学関数の固定小数点は、関数の結果がその引数と等しくなる値です。 固定コサインポイントを検索する場合は、すべてが安定するまでサイクルでコサイン結果を転送できます。 手続き的な実装：

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

非常に簡単：1.0から始めて、結果が引数と等しくなるまでコサインを計算します。



同じことですが、再帰を通じて：

 tailrec fun cosFixpoint(x: Double = 1.0): Double { val r = Math.cos(x) return if (x == r) x else cosFixpoint(r) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

または、1行でも：

 import java.lang.Math.cos tailrec fun f(x: Double = 1.0): Double = if (x == cos(x)) x else f(cos(x)))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

JITが `Math.cos（x）`へのコールバックを最適化する方法を見つけ出せば、このバージョンは他の2つと同じくらい速く動作するはずです。

カレー、部分使用、作曲

これらはすべての関数型言語が持たなければならないものですが、日常のタスクに非常に必要であるとは言えません。 カリー化は、多くの変数の機能を1つの引数の複数の機能のチェーンに分割します。 部分適用により、関数の一部のパラメーターを修正し、引数の少ない関数を取得できます。



Kotlinはそのような「すぐに使える」喜びを提供しませんが、十分に柔軟なので、これらすべてをfunKtionaleライブラリにエレガントに実装できます。

 import org.funktionale.currying.* val sum2ints = { x: Int, y: Int -> x + y } val curried: (Int) -> (Int) -> Int = sum2ints.curried() assertEquals(curried(2)(4), 6) val add5 = curried(5) assertEquals(add5(7), 12)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

...また...

 import org.funktionale.partials.* val format = { prefix: String, x: String, postfix: String -> "${prefix}${x}${postfix}" } val prefixAndBang = format(p3 = "!") // Passing just the first parameter will return a new function val hello = prefixAndBang(p1 = "Hello, ") println(hello("world"))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

遅延パフォーマンス（遅延）

Kotlinは「怠lazな」言語に属していません。つまり、記述されている場所で計算が行われます（おっと、違う方法で起こります！）。 私の知る限り、Haskell以外の共通言語はデフォルトでlazy-by-defaultを使用しません。



もちろん、遅延計算はライブラリを介して利用できます。 実際の例を考えてみましょう。ロギングが無効になっている場合にログ行を作成しない方法は？

 val loggingEnabled = System.getProperty("log") != null fun log(s: String): Unit = if (loggingEnabled) println(s) fun log(ls: () -> String): Unit = if (loggingEnabled) println(ls())
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここで、ロギング関数 `log`はオーバーロードされます-文字列を渡すか、要求に応じて文字列を計算する関数を渡すことができます：

 log("now!") log { "calculate me later" }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

関数型プログラミングでは、無限の長さのリストを作成し、「可能な限り怠laかつ並列」にリストを操作すると便利なことがよくあります。 このような操作の単純さは、一般的な関数型プログラミングの重要な機能の1つです。



バージョン8以降、Javaでもそれが可能になり、Kotlinを使用した場合：

 val ONE = BigInteger.ONE fun primes(n: Long) = Stream .iterate(ONE) { it + ONE } .filter { it.isProbablePrime(16) } .limit(n) .toList()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Javaでは、無限リストはストリームと呼ばれます。 すべての正の整数の遅延リストを作成します。 次に、Miller-Rabin検定に従って確率（1-（1/4）^ 16）で単純なもののみを選択します。 その後、それらの最初の `n`を通常のリストの形式で返します。 古典的な関数型プログラミング。



しかし、どれだけ速く動作しますか？

 repeat(3) { val t = measureTimeMillis { primes(100000) } println("Took $t msec") }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

私のラップトップでは、2回目の実行（JITをウォームアップ）から、計算に1.5秒かかりました。



しかし、副作用のない関数のチェーンを作成することのすべては、並列化の容易さにあります。 パンツの腕の簡単な動きが回って......

 fun primes(n: Long) = Stream .iterate(ONE) { it + ONE } .parallel() .filter { it.isProbablePrime(16) } .limit(n) .toArray()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

私たちがしたことは、ストリームに `parallel（）`呼び出しを挿入することだけでした。 これにより、以降のすべての操作は複数のスレッドで起動されます。 測定では、生産性が3倍に増加しました。わずか0.5秒です。 私にとってはそれほど悪くない！

ソフトウェアトランザクションメモリ

ソフトウェアトランザクションメモリ（STM）は、並列コードを記述する1つの方法です。 この手法は、Haskellの祖先の1人であるSimon Peyton-Jonesの記事で詳しく説明されています 。



ロックを使用する代わりに、次のように記述します。

 var account1 = 5 var account2 = 0 fun transfer(amount: Int) { atomic { account1 -= amount account2 += amount } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

プログラマーの観点から見ると、アトミックブロック内で発生するすべては単一のトランザクションで即座に実行され、内部に競合状態はありません。 ただし、同時に、このブロックに複数のスレッドが同時に存在することを妨げるものはありません。 とてもエレガント。



単純な実装では1つのグローバルロックを使用できますが、非常に遅くなります。 したがって、実際には、システムは1つのストリームのすべてのデータ変更を記録し、競合状況をキャッチします。 競合が発生した場合、ユニットは再起動します。 これはHaskellでうまく実装されています。



ここでも、KotlinはSTMを直接サポートしていません。 しかし、これは決して問題ではありません。JVMを介してScala STMなどのライブラリ、さらにはより低レベルのトランザクションメモリ（ハードウェアトランザクションメモリ）を自由に使用できるからです。 わあ



Intelの最新（非常に最新の）チップは、TSXと呼ばれる一連の拡張機能をサポートしています。 TSXを使用すると、鉄レベルでアトミックトランザクションを作成できます。 RAMの変更はキャッシュに書き込まれ、スレッド間の競合はCPU自体によって追跡されます。 競合が発生した場合、CPUは、プログラムが再試行するか、通常のロックを使用することを期待してトランザクションをキャンセルします。 すべてが計画どおりに進んだ場合、キャッシュは一度にRAMと同期されます。



Java 8「Update 40」以降、互換性のあるプロセッサでは、いわゆる「RTMロック」がデフォルトで有効になっています^[1] 。 これにより、Javaのすべての同期ブロックがTSXを使用して低レベルのトランザクションに魔法のように変換されます。 これはつまり、コードが実際に並行して実行されるようになったことを意味します。 JVMはさらにアプリケーションをプロファイリングして、頻繁に再起動するブロックを見つけ、それらを標準ロックに変換します。 KotlinはJVMで実行されるため、すべて自動的に動作します。



これにより、すべての重要なコードを1つの大きな同期ブロックに記述でき、速度に大きな問題を感じることはありません。 もちろん、最新のハードウェアをお持ちの場合。



ただし、制限があります-STMは、ブロックの停止/再起動/キャンセルなどの追加のソフトウェア機能を提供します。 TSXはこれを行うことができません。むしろ、JVMは現時点ではサポートしていません。 したがって、さらに制御が必要な場合は、トランザクション変数をケースに接続する必要があります。

 import scala.concurrent.stm.japi.STM.* val counter = newRef(10) try { atomic { increment(counter, 1) println("counter is ${counter.get()}") // -> 11 throw Exception("roll back!!") } } catch(e: Exception) { println("counter is ${counter.get()}") // -> 10 }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Haskellには別のエレガントなトリックがあります-その型システムは、トランザクション変数が同期ブロック内で排他的に利用可能であることを保証します。これにより、好きな方法でマルチスレッドを忘れることができません。 Kotlinでも同様のことができます。

 class ThreadBox<T>(v: T) { private val value = v @Synchronized fun locked<R>(f: T.() -> R): R = value.f() } val bank = ThreadBox(object { val accounts = intArrayOf(10, 0, 0, 0) }) fun transfer(from: Int, to: Int, amount: Int) { bank.locked { accounts[from] -= amount accounts[to] += amount } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

「ThreadBox」は、任意の「値」オブジェクトへの「プライベート」ポインターを保存するクラスです。 したがって、このオブジェクトへの外部リンクがない場合、TreadBoxを介してのみ使用できます。 バンクオブジェクトを宣言するとき、object-expresionを使用して名前のないオブジェクトを作成し、ThreadBoxコンストラクターに渡します。これにより、オブジェクトへの外部参照がないことが保証されます。 そして、ThreadBoxは、@ Synchronizedアノテーションで保護された「ロック」メソッド内のポインターのみを提供します。



Kotlin構文は、同期ブロックの外部で「アカウント」配列を使用する方法を提供しません...それへのリンクが外部に出ていない場合のみ。 そのため、これはHaskellほど深刻な防御策ではありませんが、必要なコードは3行だけです。



Github で 、同じアイデアのより洗練されたバージョンを投稿し、 より多くのエラーを防ぎました。

コトリンにないもの

言語開発（M14）の時点では、副作用を制御する方法はありません。これは、一部のアプリケーションクラスを作成するときに重要になる場合があります。



また、高性能で不変のデータ構造用の「ネイティブ」ライブラリはありません。 これは、そのような構造が言語自体に埋め込まれているClojureとScalaとは対照的です。 最も興味深いのは、最近公開されたCHAMPアルゴリズムを使用すれば、Kotlinの（Scala / Clojureと比較して）はるかに生産的な実装を作成できることです。